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

package/src/reply-dispatcher.test.ts

@@ -1,8 +1,656 @@
-import type { ClawlingChatClient } from "@newbase-clawchat/sdk";
+import type { ClawlingChatClient } from "./ws-client.ts";
+import { EventEmitter } from "node:events";
 import { describe, expect, it, vi } from "vitest";
 import { createOpenclawClawlingReplyDispatcher } from "./reply-dispatcher.ts";
+import {
+  flushAlignedOutboundQueue,
+  getAlignedOutboundQueueSize,
+} from "./outbound.ts";
+
+type SentFrame = {
+  event: string;
+  payload: Record<string, unknown>;
+  chat_id?: string;
+  trace_id?: string;
+};
+
+type TestClient = ClawlingChatClient & {
+  sent: SentFrame[];
+  typing: ReturnType<typeof vi.fn>;
+};
+
+function mockClient(
+  sent: SentFrame[] = [],
+  options: { transportState?: "open" | "closed"; state?: string; autoAck?: boolean } = {},
+): TestClient & { setTransportState: (state: "open" | "closed") => void; setState: (state: string) => void } {
+  let trace = 0;
+  let transportState = options.transportState ?? "open";
+  let clientState = options.state ?? "connected";
+  const autoAck = options.autoAck ?? true;
+  const client = Object.assign(new EventEmitter(), {
+    sent,
+    nextTraceId: vi.fn(() => `trace-${++trace}`),
+    sendWire: vi.fn((wire: string) => {
+      const env = JSON.parse(wire) as SentFrame & { trace_id?: string };
+      sent.push({ event: env.event, payload: env.payload, chat_id: env.chat_id, trace_id: env.trace_id });
+      if (autoAck && (env.event === "message.send" || env.event === "message.reply")) {
+        const payload = env.payload as { message_id?: string };
+        queueMicrotask(() => {
+          client.emit("raw", {
+            version: "2",
+            event: "message.ack",
+            trace_id: env.trace_id,
+            emitted_at: Date.now(),
+            payload: { message_id: payload.message_id ?? "server-m1", accepted_at: 1234 },
+          });
+        });
+      }
+    }),
+    emitRaw: vi.fn((event: string, payload: Record<string, unknown>, routing?: { chat_id?: string }) => {
+      sent.push({ event, payload, chat_id: routing?.chat_id });
+    }),
+    sendRawEnvelope: vi.fn((env: { event: string; payload: Record<string, unknown>; chat_id?: string; trace_id?: string }) => {
+      sent.push({ event: env.event, payload: env.payload, chat_id: env.chat_id, trace_id: env.trace_id });
+    }),
+    typing: vi.fn(),
+    setTransportState: (state: "open" | "closed") => {
+      transportState = state;
+    },
+    setState: (state: string) => {
+      clientState = state;
+    },
+  });
+  Object.defineProperty(client, "state", { get: () => clientState });
+  Object.defineProperty(client, "transportState", { get: () => transportState });
+  return client as unknown as TestClient & {
+    setTransportState: (state: "open" | "closed") => void;
+    setState: (state: string) => void;
+  };
+}
+
+function runtimeWithHooks(setHooks: (hooks: Record<string, unknown>) => void) {
+  return {
+    channel: {
+      reply: {
+        resolveHumanDelayConfig: vi.fn(() => ({ enabled: false })),
+        createReplyDispatcherWithTyping: vi.fn((options) => {
+          setHooks(options as Record<string, unknown>);
+          return { dispatcher: {}, replyOptions: {}, markDispatchIdle: vi.fn() };
+        }),
+      },
+    },
+  } as never;
+}
+
+function replyAccount(overrides: Record<string, unknown> = {}) {
+  return {
+    accountId: "default",
+    userId: "agent-1",
+    replyMode: "static",
+    forwardThinking: true,
+    forwardToolCalls: false,
+    richInteractions: false,
+    stream: { flushIntervalMs: 250, minChunkChars: 1, maxBufferChars: 2000 },
+    ack: { timeout: 10000, autoResendOnTimeout: false },
+    ...overrides,
+  } as never;
+}
+
+type TestStore = {
+  claimMessageOnce?: (input: unknown) => true | false | null;
+  updateMessageByIdentity?: (input: unknown) => void;
+  insertMessage?: (input: unknown) => unknown;
+};
+
+async function runStaticReplyWithStore(store: TestStore) {
+  let hooks: Record<string, unknown> = {};
+  const sent: SentFrame[] = [];
+  const client = mockClient(sent);
+
+  createOpenclawClawlingReplyDispatcher({
+    cfg: {} as never,
+    runtime: runtimeWithHooks((next) => {
+      hooks = next;
+    }),
+    account: replyAccount(),
+    client,
+    target: { chatId: "chat-1", chatType: "direct" },
+    store: store as never,
+    log: { info: vi.fn(), error: vi.fn() },
+  });
+
+  await (hooks.deliver as (payload: { text?: string }, info: { kind: string }) => Promise<void>)(
+    { text: "static reply" },
+    { kind: "final" },
+  );
+
+  return {
+    queuedFinal: sent.some((entry) => entry.event === "message.send" || entry.event === "message.reply"),
+    sent,
+  };
+}
+
+async function runStreamingReplyWithStore(store: TestStore, chunks: string[]) {
+  let hooks: Record<string, unknown> = {};
+  const sent: SentFrame[] = [];
+  const client = mockClient(sent);
+  const created = createOpenclawClawlingReplyDispatcher({
+    cfg: {} as never,
+    runtime: runtimeWithHooks((next) => {
+      hooks = next;
+    }),
+    account: replyAccount({ replyMode: "stream", forwardThinking: true }),
+    client,
+    target: { chatId: "chat-1", chatType: "direct" },
+    inboundMessageId: "inbound-1",
+    inboundForFinalReply: {
+      chatId: "chat-1",
+      senderId: "user-1",
+      senderNickName: "User 1",
+      bodyText: "hello",
+    },
+    store: store as never,
+    log: { info: vi.fn(), error: vi.fn() },
+  });
+
+  await (hooks.onReplyStart as (() => Promise<void>) | undefined)?.();
+  if (chunks[0]) {
+    await created.replyOptions.onPartialReply?.({ text: chunks[0] });
+  }
+  await (hooks.deliver as (payload: { text?: string }, info: { kind: string }) => Promise<void>)(
+    { text: chunks.at(-1) ?? "" },
+    { kind: "final" },
+  );
+  await (hooks.onIdle as () => Promise<void>)();
+
+  return {
+    sent,
+    streamingMessageId: sent.find((entry) => entry.event === "message.created")?.payload.message_id,
+  };
+}
 
 describe("openclaw-clawchat reply-dispatcher", () => {
+  it("forces OpenClaw block streaming delivery for ClawChat stream mode", () => {
+    let hooks: Record<string, unknown> = {};
+    const sent: SentFrame[] = [];
+    const client = mockClient(sent);
+
+    const created = createOpenclawClawlingReplyDispatcher({
+      cfg: {} as never,
+      runtime: runtimeWithHooks((next) => {
+        hooks = next;
+      }),
+      account: replyAccount({ replyMode: "stream" }),
+      client,
+      target: { chatId: "chat-1", chatType: "direct" },
+      store: { claimMessageOnce: vi.fn(() => true), insertMessage: vi.fn() } as never,
+      log: { info: vi.fn(), error: vi.fn() },
+    });
+
+    expect(hooks).toBeTruthy();
+    expect((created.replyOptions as Record<string, unknown>).sourceReplyDeliveryMode).toBe("automatic");
+    expect((created.replyOptions as Record<string, unknown>).disableBlockStreaming).toBe(false);
+    expect(typeof created.replyOptions.onPartialReply).toBe("function");
+  });
+
+  it("does not force OpenClaw block streaming delivery for explicit static mode", () => {
+    const client = mockClient();
+
+    const created = createOpenclawClawlingReplyDispatcher({
+      cfg: {} as never,
+      runtime: runtimeWithHooks(() => {}),
+      account: replyAccount({ replyMode: "static" }),
+      client,
+      target: { chatId: "chat-1", chatType: "direct" },
+      store: { claimMessageOnce: vi.fn(() => true), insertMessage: vi.fn() } as never,
+      log: { info: vi.fn(), error: vi.fn() },
+    });
+
+    expect((created.replyOptions as Record<string, unknown>).disableBlockStreaming).toBeUndefined();
+    expect(created.replyOptions.onPartialReply).toBeUndefined();
+  });
+
+  it("claims static outbound before send and uses the claimed payload message_id", async () => {
+    const store = {
+      claimMessageOnce: vi.fn(() => true),
+      insertMessage: vi.fn(),
+    };
+
+    const result = await runStaticReplyWithStore(store);
+    const messageId = store.claimMessageOnce.mock.calls[0]![0].messageId;
+
+    expect(messageId).toEqual(expect.any(String));
+    expect(store.claimMessageOnce).toHaveBeenCalledWith(expect.objectContaining({
+      direction: "outbound",
+      kind: "message",
+      messageId,
+    }));
+    expect(result.sent[0]?.payload.message_id).toBe(messageId);
+    expect(store.insertMessage).not.toHaveBeenCalledWith(expect.objectContaining({ kind: "message" }));
+  });
+
+  it("does not send static outbound when the storage claim is duplicate or unavailable", async () => {
+    const duplicateStore = { claimMessageOnce: vi.fn(() => false), insertMessage: vi.fn() };
+    const unavailableStore = { claimMessageOnce: vi.fn(() => null), insertMessage: vi.fn() };
+
+    await expect(runStaticReplyWithStore(duplicateStore)).resolves.toMatchObject({ queuedFinal: false });
+    await expect(runStaticReplyWithStore(unavailableStore)).resolves.toMatchObject({ queuedFinal: false });
+    expect(duplicateStore.claimMessageOnce).toHaveBeenCalledWith(expect.objectContaining({
+      direction: "outbound",
+      kind: "message",
+    }));
+  });
+
+  it("claims static forwarded thinking before sending", async () => {
+    let hooks: Record<string, unknown> = {};
+    const store = { claimMessageOnce: vi.fn(() => true), insertMessage: vi.fn() };
+    const sent: SentFrame[] = [];
+    const client = mockClient(sent);
+
+    createOpenclawClawlingReplyDispatcher({
+      cfg: {} as never,
+      runtime: runtimeWithHooks((next) => {
+        hooks = next;
+      }),
+      account: replyAccount({ replyMode: "static", forwardThinking: true }),
+      client,
+      target: { chatId: "chat-1", chatType: "direct" },
+      store: store as never,
+      log: { info: vi.fn(), error: vi.fn() },
+    });
+
+    await (hooks.deliver as (payload: { text?: string; isReasoning?: boolean }) => Promise<void>)(
+      { text: "thinking text", isReasoning: true },
+    );
+    const messageId = store.claimMessageOnce.mock.calls[0]?.[0].messageId;
+
+    expect(store.claimMessageOnce).toHaveBeenCalledWith(expect.objectContaining({
+      kind: "message",
+      direction: "outbound",
+      eventType: "message.send",
+      messageId,
+      text: "thinking text",
+    }));
+    expect(sent[0]?.payload.message_id).toBe(messageId);
+    expect(store.insertMessage).toHaveBeenCalledWith(expect.objectContaining({
+      kind: "thinking",
+      messageId,
+      text: "thinking text",
+    }));
+  });
+
+  it("does not send static forwarded thinking when the storage claim is duplicate or unavailable", async () => {
+    for (const claimResult of [false, null] as const) {
+      let hooks: Record<string, unknown> = {};
+      const store = { claimMessageOnce: vi.fn(() => claimResult), insertMessage: vi.fn() };
+      const sent: SentFrame[] = [];
+      const client = mockClient(sent);
+
+      createOpenclawClawlingReplyDispatcher({
+        cfg: {} as never,
+        runtime: runtimeWithHooks((next) => {
+          hooks = next;
+        }),
+        account: replyAccount({ replyMode: "static", forwardThinking: true }),
+        client,
+        target: { chatId: "chat-1", chatType: "direct" },
+        store: store as never,
+        log: { info: vi.fn(), error: vi.fn() },
+      });
+
+      await (hooks.deliver as (payload: { text?: string; isReasoning?: boolean }) => Promise<void>)(
+        { text: "thinking text", isReasoning: true },
+      );
+
+      expect(store.claimMessageOnce).toHaveBeenCalledWith(expect.objectContaining({
+        kind: "message",
+        direction: "outbound",
+      }));
+      expect(sent).toHaveLength(0);
+      expect(store.insertMessage).not.toHaveBeenCalled();
+    }
+  });
+
+  it("claims a streaming outbound message once and updates the row on final reply", async () => {
+    const store = {
+      claimMessageOnce: vi.fn(() => true),
+      updateMessageByIdentity: vi.fn(),
+      insertMessage: vi.fn(),
+    };
+
+    const result = await runStreamingReplyWithStore(store, ["hello", "hello final"]);
+
+    expect(result.streamingMessageId).toEqual(expect.any(String));
+    expect(store.claimMessageOnce).toHaveBeenCalledTimes(1);
+    expect(store.claimMessageOnce).toHaveBeenCalledWith(expect.objectContaining({
+      direction: "outbound",
+      eventType: "message.created",
+      messageId: result.streamingMessageId,
+    }));
+    expect(store.updateMessageByIdentity).toHaveBeenCalledWith(expect.objectContaining({
+      direction: "outbound",
+      eventType: "message.reply",
+      messageId: result.streamingMessageId,
+      text: "hello final",
+    }));
+  });
+
+  it("queues the consolidated streaming final reply while disconnected and flushes it after reconnect", async () => {
+    let hooks: Record<string, unknown> = {};
+    const sent: SentFrame[] = [];
+    const client = mockClient(sent, { transportState: "closed", state: "reconnecting" });
+    const store = {
+      claimMessageOnce: vi.fn(() => true),
+      updateMessageByIdentity: vi.fn(),
+      insertMessage: vi.fn(),
+    };
+
+    createOpenclawClawlingReplyDispatcher({
+      cfg: {} as never,
+      runtime: runtimeWithHooks((next) => {
+        hooks = next;
+      }),
+      account: replyAccount({ replyMode: "stream", forwardThinking: true }),
+      client,
+      target: { chatId: "chat-1", chatType: "direct" },
+      inboundMessageId: "inbound-1",
+      inboundForFinalReply: {
+        chatId: "chat-1",
+        senderId: "user-1",
+        senderNickName: "User 1",
+        bodyText: "hello",
+      },
+      store: store as never,
+      log: { info: vi.fn(), error: vi.fn() },
+    });
+
+    await (hooks.deliver as (payload: { text?: string }, info: { kind: string }) => Promise<void>)(
+      { text: "final answer" },
+      { kind: "final" },
+    );
+    const streamingMessageId = sent.find((entry) => entry.event === "message.created")?.payload.message_id;
+    expect(streamingMessageId).toEqual(expect.any(String));
+
+    const idle = (hooks.onIdle as () => Promise<void>)();
+    await new Promise((resolve) => setTimeout(resolve, 0));
+
+    expect(getAlignedOutboundQueueSize(client)).toBe(1);
+    expect(sent.filter((entry) => entry.event === "message.reply")).toHaveLength(0);
+
+    client.setTransportState("open");
+    client.setState("connected");
+    flushAlignedOutboundQueue(client);
+    await idle;
+
+    const finalReply = sent.find((entry) => entry.event === "message.reply");
+    expect(finalReply?.payload.message_id).toBe(streamingMessageId);
+    expect(finalReply?.payload).toMatchObject({
+      message: {
+        body: { fragments: [{ kind: "text", text: "final answer" }] },
+        context: {
+          reply: {
+            reply_to_msg_id: "inbound-1",
+            reply_preview: {
+              id: "user-1",
+              nick_name: "User 1",
+              fragments: [{ kind: "text", text: "hello" }],
+            },
+          },
+        },
+      },
+    });
+    expect(store.updateMessageByIdentity).toHaveBeenCalledWith(expect.objectContaining({
+      eventType: "message.reply",
+      messageId: streamingMessageId,
+      text: "final answer",
+    }));
+  });
+
+  it("requeues only the consolidated streaming final reply after disconnect before ack", async () => {
+    let hooks: Record<string, unknown> = {};
+    const sent: SentFrame[] = [];
+    const client = mockClient(sent, { autoAck: false });
+    const store = {
+      claimMessageOnce: vi.fn(() => true),
+      updateMessageByIdentity: vi.fn(),
+      insertMessage: vi.fn(),
+    };
+
+    createOpenclawClawlingReplyDispatcher({
+      cfg: {} as never,
+      runtime: runtimeWithHooks((next) => {
+        hooks = next;
+      }),
+      account: replyAccount({ replyMode: "stream", forwardThinking: true }),
+      client,
+      target: { chatId: "chat-1", chatType: "direct" },
+      inboundMessageId: "inbound-1",
+      inboundForFinalReply: {
+        chatId: "chat-1",
+        senderId: "user-1",
+        senderNickName: "User 1",
+        bodyText: "hello",
+      },
+      store,
+      log: { info: vi.fn(), error: vi.fn() },
+    });
+
+    await (hooks.deliver as (payload: { text?: string }, info: { kind: string }) => Promise<void>)(
+      { text: "final answer" },
+      { kind: "final" },
+    );
+
+    const idle = (hooks.onIdle as () => Promise<void>)();
+    await new Promise((resolve) => setTimeout(resolve, 0));
+
+    const streamingMessageId = sent.find((entry) => entry.event === "message.created")?.payload.message_id;
+    const firstFinalReply = sent.find((entry) => entry.event === "message.reply");
+    expect(streamingMessageId).toEqual(expect.any(String));
+    expect(firstFinalReply?.payload.message_id).toBe(streamingMessageId);
+    expect(firstFinalReply?.trace_id).toEqual(expect.any(String));
+
+    const lifecycleFramesBeforeReconnect = sent.filter((entry) =>
+      entry.event === "message.created" || entry.event === "message.add" || entry.event === "message.done"
+    );
+    const lifecycleCountsBeforeReconnect = {
+      created: lifecycleFramesBeforeReconnect.filter((entry) => entry.event === "message.created").length,
+      add: lifecycleFramesBeforeReconnect.filter((entry) => entry.event === "message.add").length,
+      done: lifecycleFramesBeforeReconnect.filter((entry) => entry.event === "message.done").length,
+    };
+    expect(lifecycleCountsBeforeReconnect.created).toBe(1);
+    expect(lifecycleCountsBeforeReconnect.add).toBeGreaterThanOrEqual(1);
+    expect(lifecycleCountsBeforeReconnect.done).toBe(1);
+    expect(lifecycleFramesBeforeReconnect.every((entry) => entry.payload.message_id === streamingMessageId)).toBe(true);
+
+    client.setTransportState("closed");
+    client.emit("close", { code: 1006, reason: "network lost" });
+    expect(getAlignedOutboundQueueSize(client)).toBe(1);
+
+    client.setTransportState("open");
+    client.setState("connected");
+    flushAlignedOutboundQueue(client);
+
+    expect({
+      created: sent.filter((entry) => entry.event === "message.created").length,
+      add: sent.filter((entry) => entry.event === "message.add").length,
+      done: sent.filter((entry) => entry.event === "message.done").length,
+    }).toEqual(lifecycleCountsBeforeReconnect);
+
+    const finalReplies = sent.filter((entry) => entry.event === "message.reply");
+    expect(finalReplies).toHaveLength(2);
+    expect(finalReplies[1]?.trace_id).toBe(firstFinalReply?.trace_id);
+    expect(finalReplies[1]?.payload.message_id).toBe(streamingMessageId);
+
+    client.emit("raw", {
+      version: "2",
+      event: "message.ack",
+      trace_id: firstFinalReply?.trace_id,
+      emitted_at: Date.now(),
+      payload: { message_id: streamingMessageId, accepted_at: 5678 },
+    });
+
+    await idle;
+    expect(store.updateMessageByIdentity).toHaveBeenCalledWith(expect.objectContaining({
+      eventType: "message.reply",
+      messageId: streamingMessageId,
+      text: "final answer",
+    }));
+  });
+
+  it("keeps thinking rows separate from outbound message claims", async () => {
+    let hooks: Record<string, unknown> = {};
+    const store = {
+      claimMessageOnce: vi.fn(() => true),
+      updateMessageByIdentity: vi.fn(),
+      insertMessage: vi.fn(),
+    };
+    const sent: SentFrame[] = [];
+    const client = mockClient(sent);
+    const created = createOpenclawClawlingReplyDispatcher({
+      cfg: {} as never,
+      runtime: runtimeWithHooks((next) => {
+        hooks = next;
+      }),
+      account: replyAccount({ replyMode: "stream", forwardThinking: true }),
+      client,
+      target: { chatId: "chat-1", chatType: "direct" },
+      inboundMessageId: "inbound-1",
+      inboundForFinalReply: {
+        chatId: "chat-1",
+        senderId: "user-1",
+        senderNickName: "User 1",
+        bodyText: "hello",
+      },
+      store: store as never,
+      log: { info: vi.fn(), error: vi.fn() },
+    });
+
+    await created.replyOptions.onReasoningStream?.({ text: "thinking out loud" });
+    await (hooks.deliver as (payload: { text?: string }, info: { kind: string }) => Promise<void>)(
+      { text: "final answer" },
+      { kind: "final" },
+    );
+    await (hooks.onIdle as () => Promise<void>)();
+    const messageId = sent.find((entry) => entry.event === "message.created")?.payload.message_id;
+
+    expect(store.claimMessageOnce).toHaveBeenCalledTimes(1);
+    expect(store.insertMessage).toHaveBeenCalledTimes(1);
+    expect(store.insertMessage).toHaveBeenCalledWith(expect.objectContaining({
+      kind: "thinking",
+      messageId,
+      text: "thinking out loud",
+    }));
+  });
+
+  it("does not append a static message row after the pre-send claim", async () => {
+    let hooks: Record<string, unknown> = {};
+    const store = { claimMessageOnce: vi.fn(() => true), insertMessage: vi.fn() };
+    const client = mockClient();
+
+    createOpenclawClawlingReplyDispatcher({
+      cfg: {} as never,
+      runtime: runtimeWithHooks((next) => {
+        hooks = next;
+      }),
+      account: replyAccount(),
+      client,
+      target: { chatId: "chat-1", chatType: "direct" },
+      store,
+      log: { info: vi.fn(), error: vi.fn() },
+    });
+
+    await (hooks.deliver as (payload: { text?: string }, info: { kind: string }) => Promise<void>)(
+      { text: "static reply" },
+      { kind: "final" },
+    );
+
+    expect(store.claimMessageOnce).toHaveBeenCalledWith(expect.objectContaining({
+      kind: "message",
+      direction: "outbound",
+      eventType: "message.send",
+      text: "static reply",
+    }));
+    expect(store.insertMessage).not.toHaveBeenCalledWith(expect.objectContaining({ kind: "message" }));
+  });
+
+  it("persists streaming final outbound message and thinking with the same final message id", async () => {
+    let hooks: Record<string, unknown> = {};
+    const store = {
+      claimMessageOnce: vi.fn(() => true),
+      updateMessageByIdentity: vi.fn(),
+      insertMessage: vi.fn(),
+    };
+    const sent: SentFrame[] = [];
+    const client = mockClient(sent);
+
+    const created = createOpenclawClawlingReplyDispatcher({
+      cfg: {} as never,
+      runtime: runtimeWithHooks((next) => {
+        hooks = next;
+      }),
+      account: replyAccount({ replyMode: "stream", forwardThinking: true }),
+      client,
+      target: { chatId: "chat-1", chatType: "direct" },
+      inboundMessageId: "inbound-1",
+      inboundForFinalReply: {
+        chatId: "chat-1",
+        senderId: "user-1",
+        senderNickName: "User 1",
+        bodyText: "hello",
+      },
+      store,
+      log: { info: vi.fn(), error: vi.fn() },
+    });
+
+    await created.replyOptions.onReasoningStream?.({
+      text: "reasoning text",
+    });
+    await (hooks.deliver as (payload: { text?: string }, info: { kind: string }) => Promise<void>)(
+      { text: "final answer" },
+      { kind: "final" },
+    );
+    await (hooks.onIdle as () => Promise<void>)();
+
+    expect(sent.map((entry) => entry.event)).toEqual([
+      "message.created",
+      "message.add",
+      "message.add",
+      "message.done",
+      "message.reply",
+    ]);
+    const messageId = sent.find((entry) => entry.event === "message.created")?.payload.message_id;
+    expect(store.claimMessageOnce).toHaveBeenCalledTimes(1);
+    expect(store.claimMessageOnce).toHaveBeenCalledWith(expect.objectContaining({
+      platform: "openclaw",
+      accountId: "default",
+      kind: "message",
+      direction: "outbound",
+      eventType: "message.created",
+      chatId: "chat-1",
+      messageId,
+    }));
+    expect(store.updateMessageByIdentity).toHaveBeenCalledWith(expect.objectContaining({
+      kind: "message",
+      direction: "outbound",
+      eventType: "message.reply",
+      messageId,
+      text: "final answer",
+    }));
+    expect(store.insertMessage).toHaveBeenCalledTimes(1);
+    const thinkingRow = store.insertMessage.mock.calls[0]![0];
+    expect(thinkingRow).toMatchObject({
+      platform: "openclaw",
+      accountId: "default",
+      kind: "thinking",
+      direction: "outbound",
+      eventType: "message.send",
+      chatId: "chat-1",
+      text: "reasoning text",
+    });
+    expect(thinkingRow.messageId).toBe(messageId);
+    expect(messageId).toEqual(expect.any(String));
+  });
+
   it("uses the inbound sender id in consolidated streaming reply previews", async () => {
     let hooks:
       | {
@@ -11,18 +659,8 @@ describe("openclaw-clawchat reply-dispatcher", () => {
         }
       | undefined;
     const sent: Array<{ event: string; payload: Record<string, unknown> }> = [];
-    const client = {
-      opts: {
-        transport: {
-          send: (data: string) => {
-            const env = JSON.parse(data) as { event: string; payload: Record<string, unknown> };
-            sent.push({ event: env.event, payload: env.payload });
-          },
-        },
-        traceIdFactory: () => "trace-chat-marker",
-      },
-      typing: vi.fn(),
-    } as unknown as ClawlingChatClient;
+    const client = mockClient(sent);
+    const store = { claimMessageOnce: vi.fn(() => true), updateMessageByIdentity: vi.fn(), insertMessage: vi.fn() };
 
     createOpenclawClawlingReplyDispatcher({
       cfg: {} as never,
@@ -58,6 +696,7 @@ describe("openclaw-clawchat reply-dispatcher", () => {
         senderNickName: "User 1",
         bodyText: "hello",
       },
+      store: store as never,
       log: { info: vi.fn(), error: vi.fn() },
     });
 
@@ -88,18 +727,8 @@ describe("openclaw-clawchat reply-dispatcher", () => {
         }
       | undefined;
     const sent: Array<{ event: string; payload: Record<string, unknown> }> = [];
-    const client = {
-      opts: {
-        transport: {
-          send: (data: string) => {
-            const env = JSON.parse(data) as { event: string; payload: Record<string, unknown> };
-            sent.push({ event: env.event, payload: env.payload });
-          },
-        },
-        traceIdFactory: () => "trace-1",
-      },
-      typing: vi.fn(),
-    } as unknown as ClawlingChatClient;
+    const client = mockClient(sent);
+    const store = { claimMessageOnce: vi.fn(() => true), updateMessageByIdentity: vi.fn(), insertMessage: vi.fn() };
 
     createOpenclawClawlingReplyDispatcher({
       cfg: {} as never,
@@ -154,18 +783,8 @@ describe("openclaw-clawchat reply-dispatcher", () => {
         }
       | undefined;
     const sent: Array<{ event: string; payload: Record<string, unknown> }> = [];
-    const client = {
-      opts: {
-        transport: {
-          send: (data: string) => {
-            const env = JSON.parse(data) as { event: string; payload: Record<string, unknown> };
-            sent.push({ event: env.event, payload: env.payload });
-          },
-        },
-        traceIdFactory: () => "trace-2",
-      },
-      typing: vi.fn(),
-    } as unknown as ClawlingChatClient;
+    const client = mockClient(sent);
+    const store = { claimMessageOnce: vi.fn(() => true), updateMessageByIdentity: vi.fn(), insertMessage: vi.fn() };
 
     createOpenclawClawlingReplyDispatcher({
       cfg: {} as never,
@@ -200,6 +819,7 @@ describe("openclaw-clawchat reply-dispatcher", () => {
         senderNickName: "User 1",
         bodyText: "hello",
       },
+      store: store as never,
       log: { info: vi.fn(), error: vi.fn() },
     });
 
@@ -222,13 +842,7 @@ describe("openclaw-clawchat reply-dispatcher", () => {
           onError?: (error: unknown, info: { kind: string }) => void;
         }
       | undefined;
-    const client = {
-      sendMessage: vi.fn().mockResolvedValue({
-        payload: { message_id: "server-m1", accepted_at: 1234 },
-      }),
-      replyMessage: vi.fn(),
-      typing: vi.fn(),
-    } as unknown as ClawlingChatClient;
+    const client = mockClient();
 
     const logError = vi.fn();
     createOpenclawClawlingReplyDispatcher({
@@ -264,8 +878,7 @@ describe("openclaw-clawchat reply-dispatcher", () => {
     hooks?.onError?.(new Error("boom"), { kind: "dispatch" });
     await new Promise((resolve) => setTimeout(resolve, 0));
 
-    expect(client.sendMessage).not.toHaveBeenCalled();
-    expect(client.replyMessage).not.toHaveBeenCalled();
+    expect(client.sent).toHaveLength(0);
     expect(logError).toHaveBeenCalledWith(
       expect.stringContaining("openclaw-clawchat dispatch reply failed: Error: boom"),
     );
@@ -278,13 +891,8 @@ describe("openclaw-clawchat reply-dispatcher", () => {
         }
       | undefined;
     const logError = vi.fn();
-    const client = {
-      sendMessage: vi.fn().mockRejectedValue(
-        new Error("ack timeout after 15000ms for trace_id=trace-fallback"),
-      ),
-      replyMessage: vi.fn(),
-      typing: vi.fn(),
-    } as unknown as ClawlingChatClient;
+    const client = mockClient();
+    const store = { claimMessageOnce: vi.fn(() => true), insertMessage: vi.fn() };
 
     createOpenclawClawlingReplyDispatcher({
       cfg: {} as never,
@@ -319,7 +927,7 @@ describe("openclaw-clawchat reply-dispatcher", () => {
     hooks?.onError?.(new Error("final delivery failed"), { kind: "final" });
     await new Promise((resolve) => setTimeout(resolve, 0));
 
-    expect(client.sendMessage).not.toHaveBeenCalled();
+    expect(client.sent).toHaveLength(0);
     expect(logError).toHaveBeenCalledWith(
       expect.stringContaining(
         "openclaw-clawchat final reply failed: Error: final delivery failed",
@@ -333,13 +941,7 @@ describe("openclaw-clawchat reply-dispatcher", () => {
           onError?: (error: unknown, info: { kind: string }) => void;
         }
       | undefined;
-    const client = {
-      sendMessage: vi.fn().mockResolvedValue({
-        payload: { message_id: "server-m1", accepted_at: 1234 },
-      }),
-      replyMessage: vi.fn(),
-      typing: vi.fn(),
-    } as unknown as ClawlingChatClient;
+    const client = mockClient();
 
     const logError = vi.fn();
     createOpenclawClawlingReplyDispatcher({
@@ -378,7 +980,7 @@ describe("openclaw-clawchat reply-dispatcher", () => {
     );
     await new Promise((resolve) => setTimeout(resolve, 0));
 
-    expect(client.sendMessage).not.toHaveBeenCalled();
+    expect(client.sent).toHaveLength(0);
     expect(logError).toHaveBeenCalledWith(
       expect.stringContaining("openclaw-clawchat dispatch reply failed: Error: boom"),
     );
@@ -401,14 +1003,8 @@ describe("openclaw-clawchat reply-dispatcher", () => {
           }, info?: { kind: "tool" | "block" | "final" }) => Promise<void>;
         }
       | undefined;
-    const client = {
-      sendMessage: vi.fn().mockResolvedValue({
-        payload: { message_id: "server-m1", accepted_at: 1234 },
-        trace_id: "trace-rich",
-      }),
-      replyMessage: vi.fn(),
-      typing: vi.fn(),
-    } as unknown as ClawlingChatClient;
+    const client = mockClient();
+    const store = { claimMessageOnce: vi.fn(() => true), insertMessage: vi.fn() };
 
     createOpenclawClawlingReplyDispatcher({
       cfg: {} as never,
@@ -431,9 +1027,11 @@ describe("openclaw-clawchat reply-dispatcher", () => {
         forwardToolCalls: false,
         richInteractions: true,
         stream: { flushIntervalMs: 250, minChunkChars: 40, maxBufferChars: 2000 },
+        ack: { timeout: 10000, autoResendOnTimeout: false },
       } as never,
       client,
       target: { chatId: "chat-1", chatType: "direct" },
+      store: store as never,
       log: { info: vi.fn(), error: vi.fn() },
     });
 
@@ -458,8 +1056,8 @@ describe("openclaw-clawchat reply-dispatcher", () => {
       { kind: "final" },
     );
 
-    expect(client.sendMessage).toHaveBeenCalledWith(
-      expect.objectContaining({
+    expect(client.sent[0]?.payload).toMatchObject({
+      message: {
         body: {
           fragments: [
             {
@@ -474,8 +1072,8 @@ describe("openclaw-clawchat reply-dispatcher", () => {
             },
           ],
         },
-      }),
-    );
+      },
+    });
   });
 
   it("sends plain fallback text for presentations when rich interactions are disabled", async () => {
@@ -490,14 +1088,8 @@ describe("openclaw-clawchat reply-dispatcher", () => {
           }, info?: { kind: "tool" | "block" | "final" }) => Promise<void>;
         }
       | undefined;
-    const client = {
-      sendMessage: vi.fn().mockResolvedValue({
-        payload: { message_id: "server-m1", accepted_at: 1234 },
-        trace_id: "trace-fallback",
-      }),
-      replyMessage: vi.fn(),
-      typing: vi.fn(),
-    } as unknown as ClawlingChatClient;
+    const client = mockClient();
+    const store = { claimMessageOnce: vi.fn(() => true), insertMessage: vi.fn() };
 
     createOpenclawClawlingReplyDispatcher({
       cfg: {} as never,
@@ -520,9 +1112,11 @@ describe("openclaw-clawchat reply-dispatcher", () => {
         forwardToolCalls: false,
         richInteractions: false,
         stream: { flushIntervalMs: 250, minChunkChars: 40, maxBufferChars: 2000 },
+        ack: { timeout: 10000, autoResendOnTimeout: false },
       } as never,
       client,
       target: { chatId: "chat-1", chatType: "direct" },
+      store: store as never,
       log: { info: vi.fn(), error: vi.fn() },
     });
 
@@ -537,13 +1131,13 @@ describe("openclaw-clawchat reply-dispatcher", () => {
       { kind: "final" },
     );
 
-    expect(client.sendMessage).toHaveBeenCalledWith(
-      expect.objectContaining({
+    expect(client.sent[0]?.payload).toMatchObject({
+      message: {
         body: {
           fragments: [{ kind: "text", text: expect.stringContaining("Delete /tmp/example.txt?") }],
         },
-      }),
-    );
+      },
+    });
   });
 
   it("prefers mediaUrls over legacy mediaUrl so one image is not sent twice", async () => {
@@ -566,19 +1160,19 @@ describe("openclaw-clawchat reply-dispatcher", () => {
         JSON.stringify({
           code: 0,
           msg: "ok",
-          data: { url: "https://cdn/uploaded.png", size: 12, mime: "image/png" },
+          data: {
+            kind: "image",
+            url: "https://cdn/uploaded.png",
+            name: "uploaded.png",
+            size: 12,
+            mime: "image/png",
+          },
         }),
         { status: 200, headers: { "content-type": "application/json" } },
       ),
     );
-    const client = {
-      sendMessage: vi.fn().mockResolvedValue({
-        payload: { message_id: "server-m1", accepted_at: 1234 },
-        trace_id: "trace-media",
-      }),
-      replyMessage: vi.fn(),
-      typing: vi.fn(),
-    } as unknown as ClawlingChatClient;
+    const client = mockClient();
+    const store = { claimMessageOnce: vi.fn(() => true), insertMessage: vi.fn() };
 
     try {
       createOpenclawClawlingReplyDispatcher({
@@ -604,9 +1198,11 @@ describe("openclaw-clawchat reply-dispatcher", () => {
           forwardThinking: true,
           forwardToolCalls: false,
           stream: { flushIntervalMs: 250, minChunkChars: 40, maxBufferChars: 2000 },
+          ack: { timeout: 10000, autoResendOnTimeout: false },
         } as never,
         client,
         target: { chatId: "chat-1", chatType: "direct" },
+        store: store as never,
         log: { info: vi.fn(), error: vi.fn() },
       });
 
@@ -622,23 +1218,25 @@ describe("openclaw-clawchat reply-dispatcher", () => {
       expect(loadWebMedia).toHaveBeenCalledTimes(1);
       expect(loadWebMedia).toHaveBeenCalledWith("https://cdn/image.png", expect.any(Object));
       expect(fetchMock).toHaveBeenCalledTimes(1);
-      expect(client.sendMessage).toHaveBeenCalledWith(
-        expect.objectContaining({
-          chat_id: "chat-1",
-          body: {
-            fragments: [
-              { kind: "text", text: "look" },
-              {
-                kind: "image",
-                url: "https://cdn/uploaded.png",
-                mime: "image/png",
-                size: 12,
-                name: "image.png",
-              },
-            ],
+      expect(client.sent[0]).toMatchObject({
+        chat_id: "chat-1",
+        payload: {
+          message: {
+            body: {
+              fragments: [
+                { kind: "text", text: "look" },
+                {
+                  kind: "image",
+                  url: "https://cdn/uploaded.png",
+                  mime: "image/png",
+                  size: 12,
+                  name: "uploaded.png",
+                },
+              ],
+            },
           },
-        }),
-      );
+        },
+      });
     } finally {
       fetchMock.mockRestore();
     }
@@ -662,18 +1260,8 @@ describe("openclaw-clawchat reply-dispatcher", () => {
         }
       | undefined;
     const sent: Array<{ event: string; payload: Record<string, unknown> }> = [];
-    const client = {
-      opts: {
-        transport: {
-          send: (data: string) => {
-            const env = JSON.parse(data) as { event: string; payload: Record<string, unknown> };
-            sent.push({ event: env.event, payload: env.payload });
-          },
-        },
-        traceIdFactory: () => "trace-stream-rich",
-      },
-      typing: vi.fn(),
-    } as unknown as ClawlingChatClient;
+    const client = mockClient(sent);
+    const store = { claimMessageOnce: vi.fn(() => true), updateMessageByIdentity: vi.fn(), insertMessage: vi.fn() };
 
     createOpenclawClawlingReplyDispatcher({
       cfg: {} as never,
@@ -706,6 +1294,7 @@ describe("openclaw-clawchat reply-dispatcher", () => {
         senderNickName: "User 1",
         bodyText: "hello",
       },
+      store: store as never,
       log: { info: vi.fn(), error: vi.fn() },
     });
 
@@ -756,14 +1345,8 @@ describe("openclaw-clawchat reply-dispatcher", () => {
           }, info?: { kind: "tool" | "block" | "final" }) => Promise<void>;
         }
       | undefined;
-    const client = {
-      sendMessage: vi.fn().mockResolvedValue({
-        payload: { message_id: "server-m1", accepted_at: 1234 },
-        trace_id: "trace-block-rich",
-      }),
-      replyMessage: vi.fn(),
-      typing: vi.fn(),
-    } as unknown as ClawlingChatClient;
+    const client = mockClient();
+    const store = { claimMessageOnce: vi.fn(() => true), insertMessage: vi.fn() };
 
     createOpenclawClawlingReplyDispatcher({
       cfg: {} as never,
@@ -786,9 +1369,11 @@ describe("openclaw-clawchat reply-dispatcher", () => {
         forwardToolCalls: false,
         richInteractions: true,
         stream: { flushIntervalMs: 250, minChunkChars: 40, maxBufferChars: 2000 },
+        ack: { timeout: 10000, autoResendOnTimeout: false },
       } as never,
       client,
       target: { chatId: "chat-1", chatType: "direct" },
+      store: store as never,
       log: { info: vi.fn(), error: vi.fn() },
     });
 
@@ -805,8 +1390,8 @@ describe("openclaw-clawchat reply-dispatcher", () => {
       { kind: "block" },
     );
 
-    expect(client.sendMessage).toHaveBeenCalledWith(
-      expect.objectContaining({
+    expect(client.sent[0]?.payload).toMatchObject({
+      message: {
         body: {
           fragments: [
             {
@@ -818,7 +1403,7 @@ describe("openclaw-clawchat reply-dispatcher", () => {
             },
           ],
         },
-      }),
-    );
+      },
+    });
   });
 });