@archipelagolab/lobi 1.0.0

package/src/matrix/monitor/replies.test.ts

@@ -0,0 +1,265 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import type { PluginRuntime, RuntimeEnv } from "../../../runtime-api.js";
+import type { MatrixClient } from "../sdk.js";
+
+const sendMessageMatrixMock = vi.hoisted(() => vi.fn().mockResolvedValue({ messageId: "mx-1" }));
+const chunkMatrixTextMock = vi.hoisted(() =>
+  vi.fn((text: string, _opts?: unknown) => ({
+    trimmedText: text.trim(),
+    convertedText: text,
+    singleEventLimit: 4000,
+    fitsInSingleEvent: true,
+    chunks: text ? [text] : [],
+  })),
+);
+
+vi.mock("../send.js", () => ({
+  chunkMatrixText: (text: string, opts?: unknown) => chunkMatrixTextMock(text, opts),
+  sendMessageMatrix: (to: string, message: string, opts?: unknown) =>
+    sendMessageMatrixMock(to, message, opts),
+}));
+
+import { setMatrixRuntime } from "../../runtime.js";
+import { deliverMatrixReplies } from "./replies.js";
+
+describe("deliverMatrixReplies", () => {
+  const cfg = { channels: { matrix: {} } };
+  const loadConfigMock = vi.fn(() => ({}));
+  const resolveMarkdownTableModeMock = vi.fn<(params: unknown) => string>(() => "code");
+  const convertMarkdownTablesMock = vi.fn((text: string) => text);
+  const resolveChunkModeMock = vi.fn<
+    (cfg: unknown, channel: unknown, accountId?: unknown) => string
+  >(() => "length");
+  const chunkMarkdownTextWithModeMock = vi.fn((text: string) => [text]);
+
+  const runtimeStub = {
+    config: {
+      loadConfig: () => loadConfigMock(),
+    },
+    channel: {
+      text: {
+        resolveMarkdownTableMode: (params: unknown) => resolveMarkdownTableModeMock(params),
+        convertMarkdownTables: (text: string) => convertMarkdownTablesMock(text),
+        resolveChunkMode: (cfg: unknown, channel: unknown, accountId?: unknown) =>
+          resolveChunkModeMock(cfg, channel, accountId),
+        chunkMarkdownTextWithMode: (text: string) => chunkMarkdownTextWithModeMock(text),
+      },
+    },
+    logging: {
+      shouldLogVerbose: () => false,
+    },
+  } as unknown as PluginRuntime;
+
+  const runtimeEnv: RuntimeEnv = {
+    log: vi.fn(),
+    error: vi.fn(),
+  } as unknown as RuntimeEnv;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    setMatrixRuntime(runtimeStub);
+    chunkMatrixTextMock.mockReset().mockImplementation((text: string) => ({
+      trimmedText: text.trim(),
+      convertedText: text,
+      singleEventLimit: 4000,
+      fitsInSingleEvent: true,
+      chunks: text ? [text] : [],
+    }));
+  });
+
+  it("keeps replyToId on first reply only when replyToMode=first", async () => {
+    chunkMatrixTextMock.mockImplementation((text: string) => ({
+      trimmedText: text.trim(),
+      convertedText: text,
+      singleEventLimit: 4000,
+      fitsInSingleEvent: true,
+      chunks: text.split("|"),
+    }));
+
+    await deliverMatrixReplies({
+      cfg,
+      replies: [
+        { text: "first-a|first-b", replyToId: "reply-1" },
+        { text: "second", replyToId: "reply-2" },
+      ],
+      roomId: "room:1",
+      client: {} as MatrixClient,
+      runtime: runtimeEnv,
+      textLimit: 4000,
+      replyToMode: "first",
+    });
+
+    expect(sendMessageMatrixMock).toHaveBeenCalledTimes(3);
+    expect(sendMessageMatrixMock.mock.calls[0]?.[2]).toEqual(
+      expect.objectContaining({ replyToId: "reply-1", threadId: undefined }),
+    );
+    expect(sendMessageMatrixMock.mock.calls[1]?.[2]).toEqual(
+      expect.objectContaining({ replyToId: "reply-1", threadId: undefined }),
+    );
+    expect(sendMessageMatrixMock.mock.calls[2]?.[2]).toEqual(
+      expect.objectContaining({ replyToId: undefined, threadId: undefined }),
+    );
+  });
+
+  it("keeps replyToId on every reply when replyToMode=all", async () => {
+    await deliverMatrixReplies({
+      cfg,
+      replies: [
+        {
+          text: "caption",
+          mediaUrls: ["https://example.com/a.jpg", "https://example.com/b.jpg"],
+          replyToId: "reply-media",
+          audioAsVoice: true,
+        },
+        { text: "plain", replyToId: "reply-text" },
+      ],
+      roomId: "room:2",
+      client: {} as MatrixClient,
+      runtime: runtimeEnv,
+      textLimit: 4000,
+      replyToMode: "all",
+      mediaLocalRoots: ["/tmp/openclaw-matrix-test"],
+    });
+
+    expect(sendMessageMatrixMock).toHaveBeenCalledTimes(3);
+    expect(sendMessageMatrixMock.mock.calls[0]).toEqual([
+      "room:2",
+      "caption",
+      expect.objectContaining({
+        mediaUrl: "https://example.com/a.jpg",
+        mediaLocalRoots: ["/tmp/openclaw-matrix-test"],
+        replyToId: "reply-media",
+      }),
+    ]);
+    expect(sendMessageMatrixMock.mock.calls[1]).toEqual([
+      "room:2",
+      "",
+      expect.objectContaining({
+        mediaUrl: "https://example.com/b.jpg",
+        mediaLocalRoots: ["/tmp/openclaw-matrix-test"],
+        replyToId: "reply-media",
+      }),
+    ]);
+    expect(sendMessageMatrixMock.mock.calls[2]?.[2]).toEqual(
+      expect.objectContaining({ replyToId: "reply-text" }),
+    );
+  });
+
+  it("suppresses replyToId when threadId is set", async () => {
+    chunkMatrixTextMock.mockImplementation((text: string) => ({
+      trimmedText: text.trim(),
+      convertedText: text,
+      singleEventLimit: 4000,
+      fitsInSingleEvent: true,
+      chunks: text.split("|"),
+    }));
+
+    await deliverMatrixReplies({
+      cfg,
+      replies: [{ text: "hello|thread", replyToId: "reply-thread" }],
+      roomId: "room:3",
+      client: {} as MatrixClient,
+      runtime: runtimeEnv,
+      textLimit: 4000,
+      replyToMode: "all",
+      threadId: "thread-77",
+    });
+
+    expect(sendMessageMatrixMock).toHaveBeenCalledTimes(2);
+    expect(sendMessageMatrixMock.mock.calls[0]?.[2]).toEqual(
+      expect.objectContaining({ replyToId: undefined, threadId: "thread-77" }),
+    );
+    expect(sendMessageMatrixMock.mock.calls[1]?.[2]).toEqual(
+      expect.objectContaining({ replyToId: undefined, threadId: "thread-77" }),
+    );
+  });
+
+  it("suppresses reasoning-only text before Matrix sends", async () => {
+    await deliverMatrixReplies({
+      cfg,
+      replies: [
+        { text: "Reasoning:\n_hidden_" },
+        { text: "<think>still hidden</think>" },
+        { text: "Visible answer" },
+      ],
+      roomId: "room:5",
+      client: {} as MatrixClient,
+      runtime: runtimeEnv,
+      textLimit: 4000,
+      replyToMode: "off",
+    });
+
+    expect(sendMessageMatrixMock).toHaveBeenCalledTimes(1);
+    expect(sendMessageMatrixMock).toHaveBeenCalledWith(
+      "room:5",
+      "Visible answer",
+      expect.objectContaining({ cfg }),
+    );
+  });
+
+  it("uses supplied cfg for chunking and send delivery without reloading runtime config", async () => {
+    const explicitCfg = {
+      channels: {
+        matrix: {
+          accounts: {
+            ops: {
+              chunkMode: "newline",
+            },
+          },
+        },
+      },
+    };
+    loadConfigMock.mockImplementation(() => {
+      throw new Error("deliverMatrixReplies should not reload runtime config when cfg is provided");
+    });
+
+    await deliverMatrixReplies({
+      cfg: explicitCfg,
+      replies: [{ text: "hello", replyToId: "reply-1" }],
+      roomId: "room:4",
+      client: {} as MatrixClient,
+      runtime: runtimeEnv,
+      textLimit: 4000,
+      replyToMode: "all",
+      accountId: "ops",
+    });
+
+    expect(loadConfigMock).not.toHaveBeenCalled();
+    expect(chunkMatrixTextMock).toHaveBeenCalledWith("hello", {
+      cfg: explicitCfg,
+      accountId: "ops",
+      tableMode: "code",
+    });
+    expect(sendMessageMatrixMock).toHaveBeenCalledWith(
+      "room:4",
+      "hello",
+      expect.objectContaining({
+        cfg: explicitCfg,
+        accountId: "ops",
+        replyToId: "reply-1",
+      }),
+    );
+  });
+
+  it("passes raw media captions through to sendMessageMatrix without pre-converting them", async () => {
+    convertMarkdownTablesMock.mockImplementation((text: string) => `converted:${text}`);
+
+    await deliverMatrixReplies({
+      cfg,
+      replies: [{ text: "caption", mediaUrl: "https://example.com/a.jpg" }],
+      roomId: "room:6",
+      client: {} as MatrixClient,
+      runtime: runtimeEnv,
+      textLimit: 4000,
+      replyToMode: "off",
+    });
+
+    expect(sendMessageMatrixMock).toHaveBeenCalledWith(
+      "room:6",
+      "caption",
+      expect.objectContaining({
+        mediaUrl: "https://example.com/a.jpg",
+      }),
+    );
+  });
+});

package/src/matrix/monitor/replies.ts

@@ -0,0 +1,136 @@
+import { normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/text-runtime";
+import { getMatrixRuntime } from "../../runtime.js";
+import type { MatrixClient } from "../sdk.js";
+import { chunkMatrixText, sendMessageMatrix } from "../send.js";
+import type { MarkdownTableMode, OpenClawConfig, ReplyPayload, RuntimeEnv } from "./runtime-api.js";
+
+const THINKING_TAG_RE = /<\s*\/?\s*(?:think(?:ing)?|thought|antthinking)\b[^<>]*>/gi;
+const THINKING_BLOCK_RE =
+  /<\s*(?:think(?:ing)?|thought|antthinking)\b[^<>]*>[\s\S]*?<\s*\/\s*(?:think(?:ing)?|thought|antthinking)\s*>/gi;
+
+function shouldSuppressReasoningReplyText(text?: string): boolean {
+  if (typeof text !== "string") {
+    return false;
+  }
+  const trimmedStart = text.trimStart();
+  if (!trimmedStart) {
+    return false;
+  }
+  if (normalizeLowercaseStringOrEmpty(trimmedStart).startsWith("reasoning:")) {
+    return true;
+  }
+  THINKING_TAG_RE.lastIndex = 0;
+  if (!THINKING_TAG_RE.test(text)) {
+    return false;
+  }
+  THINKING_BLOCK_RE.lastIndex = 0;
+  const withoutThinkingBlocks = text.replace(THINKING_BLOCK_RE, "");
+  THINKING_TAG_RE.lastIndex = 0;
+  return !withoutThinkingBlocks.replace(THINKING_TAG_RE, "").trim();
+}
+
+export async function deliverMatrixReplies(params: {
+  cfg: OpenClawConfig;
+  replies: ReplyPayload[];
+  roomId: string;
+  client: MatrixClient;
+  runtime: RuntimeEnv;
+  textLimit: number;
+  replyToMode: "off" | "first" | "all" | "batched";
+  threadId?: string;
+  accountId?: string;
+  mediaLocalRoots?: readonly string[];
+  tableMode?: MarkdownTableMode;
+}): Promise<boolean> {
+  const core = getMatrixRuntime();
+  const tableMode =
+    params.tableMode ??
+    core.channel.text.resolveMarkdownTableMode({
+      cfg: params.cfg,
+      channel: "matrix",
+      accountId: params.accountId,
+    });
+  const logVerbose = (message: string) => {
+    if (core.logging.shouldLogVerbose()) {
+      params.runtime.log?.(message);
+    }
+  };
+  let hasReplied = false;
+  let deliveredAny = false;
+  for (const reply of params.replies) {
+    if (reply.isReasoning === true || shouldSuppressReasoningReplyText(reply.text)) {
+      logVerbose("matrix reply suppressed as reasoning-only");
+      continue;
+    }
+    const hasMedia = Boolean(reply?.mediaUrl) || (reply?.mediaUrls?.length ?? 0) > 0;
+    if (!reply?.text && !hasMedia) {
+      if (reply?.audioAsVoice) {
+        logVerbose("matrix reply has audioAsVoice without media/text; skipping");
+        continue;
+      }
+      params.runtime.error?.("matrix reply missing text/media");
+      continue;
+    }
+    const replyToIdRaw = reply.replyToId?.trim();
+    const replyToId = params.threadId || params.replyToMode === "off" ? undefined : replyToIdRaw;
+    const rawText = reply.text ?? "";
+    const mediaList = reply.mediaUrls?.length
+      ? reply.mediaUrls
+      : reply.mediaUrl
+        ? [reply.mediaUrl]
+        : [];
+
+    const shouldIncludeReply = (id?: string) =>
+      Boolean(id) && (params.replyToMode === "all" || !hasReplied);
+    const replyToIdForReply = shouldIncludeReply(replyToId) ? replyToId : undefined;
+
+    if (mediaList.length === 0) {
+      let sentTextChunk = false;
+      const { chunks } = chunkMatrixText(rawText, {
+        cfg: params.cfg,
+        accountId: params.accountId,
+        tableMode,
+      });
+      for (const chunk of chunks) {
+        const trimmed = chunk.trim();
+        if (!trimmed) {
+          continue;
+        }
+        await sendMessageMatrix(params.roomId, trimmed, {
+          client: params.client,
+          cfg: params.cfg,
+          replyToId: replyToIdForReply,
+          threadId: params.threadId,
+          accountId: params.accountId,
+        });
+        deliveredAny = true;
+        sentTextChunk = true;
+      }
+      if (replyToIdForReply && !hasReplied && sentTextChunk) {
+        hasReplied = true;
+      }
+      continue;
+    }
+
+    let first = true;
+    for (const mediaUrl of mediaList) {
+      const caption = first ? rawText : "";
+      await sendMessageMatrix(params.roomId, caption, {
+        client: params.client,
+        cfg: params.cfg,
+        mediaUrl,
+        mediaLocalRoots: params.mediaLocalRoots,
+        replyToId: replyToIdForReply,
+        threadId: params.threadId,
+        audioAsVoice: reply.audioAsVoice,
+        accountId: params.accountId,
+      });
+      deliveredAny = true;
+      first = false;
+    }
+    if (replyToIdForReply && !hasReplied) {
+      hasReplied = true;
+    }
+  }
+  return deliveredAny;
+}

package/src/matrix/monitor/reply-context.test.ts

@@ -0,0 +1,276 @@
+import { describe, expect, it, vi } from "vitest";
+import { createMatrixReplyContextResolver, summarizeMatrixReplyEvent } from "./reply-context.js";
+import type { MatrixRawEvent } from "./types.js";
+
+describe("matrix reply context", () => {
+  it("summarizes reply events from body text", () => {
+    expect(
+      summarizeMatrixReplyEvent({
+        event_id: "$original",
+        sender: "@alice:example.org",
+        type: "m.room.message",
+        origin_server_ts: Date.now(),
+        content: {
+          msgtype: "m.text",
+          body: " Some quoted message ",
+        },
+      } as MatrixRawEvent),
+    ).toBe("Some quoted message");
+  });
+
+  it("truncates long reply bodies", () => {
+    const longBody = "x".repeat(600);
+    const result = summarizeMatrixReplyEvent({
+      event_id: "$original",
+      sender: "@alice:example.org",
+      type: "m.room.message",
+      origin_server_ts: Date.now(),
+      content: {
+        msgtype: "m.text",
+        body: longBody,
+      },
+    } as MatrixRawEvent);
+    expect(result).toBeDefined();
+    expect(result!.length).toBeLessThanOrEqual(500);
+    expect(result!.endsWith("...")).toBe(true);
+  });
+
+  it("handles media-only reply events", () => {
+    expect(
+      summarizeMatrixReplyEvent({
+        event_id: "$original",
+        sender: "@alice:example.org",
+        type: "m.room.message",
+        origin_server_ts: Date.now(),
+        content: {
+          msgtype: "m.image",
+          body: "photo.jpg",
+        },
+      } as MatrixRawEvent),
+    ).toBe("[matrix image attachment]");
+  });
+
+  it("summarizes poll start events from poll content", () => {
+    expect(
+      summarizeMatrixReplyEvent({
+        event_id: "$poll",
+        sender: "@alice:example.org",
+        type: "m.poll.start",
+        origin_server_ts: Date.now(),
+        content: {
+          "m.poll.start": {
+            question: { "m.text": "Lunch?" },
+            kind: "m.poll.disclosed",
+            max_selections: 1,
+            answers: [
+              { id: "a1", "m.text": "Pizza" },
+              { id: "a2", "m.text": "Sushi" },
+            ],
+          },
+        },
+      } as MatrixRawEvent),
+    ).toBe("[Poll]\nLunch?\n\n1. Pizza\n2. Sushi");
+  });
+
+  it("resolves and caches reply context", async () => {
+    const getEvent = vi.fn(async () => ({
+      event_id: "$original",
+      sender: "@alice:example.org",
+      type: "m.room.message",
+      origin_server_ts: Date.now(),
+      content: {
+        msgtype: "m.text",
+        body: "This is the original message",
+      },
+    }));
+    const getMemberDisplayName = vi.fn(async () => "Alice");
+    const resolveReplyContext = createMatrixReplyContextResolver({
+      client: {
+        getEvent,
+      } as never,
+      getMemberDisplayName,
+      logVerboseMessage: () => {},
+    });
+
+    const result = await resolveReplyContext({
+      roomId: "!room:example.org",
+      eventId: "$original",
+    });
+
+    expect(result).toEqual({
+      replyToBody: "This is the original message",
+      replyToSender: "Alice",
+      replyToSenderId: "@alice:example.org",
+    });
+
+    // Second call should use cache
+    await resolveReplyContext({
+      roomId: "!room:example.org",
+      eventId: "$original",
+    });
+
+    expect(getEvent).toHaveBeenCalledTimes(1);
+    expect(getMemberDisplayName).toHaveBeenCalledTimes(1);
+  });
+
+  it("returns empty context when event fetch fails", async () => {
+    const getEvent = vi.fn().mockRejectedValueOnce(new Error("not found"));
+    const getMemberDisplayName = vi.fn(async () => "Alice");
+    const resolveReplyContext = createMatrixReplyContextResolver({
+      client: {
+        getEvent,
+      } as never,
+      getMemberDisplayName,
+      logVerboseMessage: () => {},
+    });
+
+    const result = await resolveReplyContext({
+      roomId: "!room:example.org",
+      eventId: "$missing",
+    });
+
+    expect(result).toEqual({});
+  });
+
+  it("returns empty context for redacted events", async () => {
+    const getEvent = vi.fn(async () => ({
+      event_id: "$redacted",
+      sender: "@alice:example.org",
+      type: "m.room.message",
+      origin_server_ts: Date.now(),
+      unsigned: {
+        redacted_because: { type: "m.room.redaction" },
+      },
+      content: {},
+    }));
+    const getMemberDisplayName = vi.fn(async () => "Alice");
+    const resolveReplyContext = createMatrixReplyContextResolver({
+      client: {
+        getEvent,
+      } as never,
+      getMemberDisplayName,
+      logVerboseMessage: () => {},
+    });
+
+    const result = await resolveReplyContext({
+      roomId: "!room:example.org",
+      eventId: "$redacted",
+    });
+
+    expect(result).toEqual({});
+    expect(getMemberDisplayName).not.toHaveBeenCalled();
+  });
+
+  it("does not cache fetch failures so retries can succeed", async () => {
+    const getEvent = vi
+      .fn()
+      .mockRejectedValueOnce(new Error("temporary failure"))
+      .mockResolvedValueOnce({
+        event_id: "$original",
+        sender: "@bob:example.org",
+        type: "m.room.message",
+        origin_server_ts: Date.now(),
+        content: {
+          msgtype: "m.text",
+          body: "Recovered message",
+        },
+      });
+    const getMemberDisplayName = vi.fn(async () => "Bob");
+    const resolveReplyContext = createMatrixReplyContextResolver({
+      client: {
+        getEvent,
+      } as never,
+      getMemberDisplayName,
+      logVerboseMessage: () => {},
+    });
+
+    // First call fails
+    const first = await resolveReplyContext({
+      roomId: "!room:example.org",
+      eventId: "$original",
+    });
+    expect(first).toEqual({});
+
+    // Second call succeeds (should retry, not use cached failure)
+    const second = await resolveReplyContext({
+      roomId: "!room:example.org",
+      eventId: "$original",
+    });
+    expect(second).toEqual({
+      replyToBody: "Recovered message",
+      replyToSender: "Bob",
+      replyToSenderId: "@bob:example.org",
+    });
+
+    expect(getEvent).toHaveBeenCalledTimes(2);
+  });
+
+  it("falls back to senderId when display name resolution fails", async () => {
+    const getEvent = vi.fn(async () => ({
+      event_id: "$original",
+      sender: "@charlie:example.org",
+      type: "m.room.message",
+      origin_server_ts: Date.now(),
+      content: {
+        msgtype: "m.text",
+        body: "Hello",
+      },
+    }));
+    const getMemberDisplayName = vi.fn().mockRejectedValueOnce(new Error("unknown member"));
+    const resolveReplyContext = createMatrixReplyContextResolver({
+      client: {
+        getEvent,
+      } as never,
+      getMemberDisplayName,
+      logVerboseMessage: () => {},
+    });
+
+    const result = await resolveReplyContext({
+      roomId: "!room:example.org",
+      eventId: "$original",
+    });
+
+    expect(result).toEqual({
+      replyToBody: "Hello",
+      replyToSender: "@charlie:example.org",
+      replyToSenderId: "@charlie:example.org",
+    });
+  });
+
+  it("uses LRU eviction — recently accessed entries survive over older ones", async () => {
+    let callCount = 0;
+    const getEvent = vi.fn().mockImplementation((_roomId: string, eventId: string) => {
+      callCount++;
+      return Promise.resolve({
+        event_id: eventId,
+        sender: `@user${callCount}:example.org`,
+        type: "m.room.message",
+        origin_server_ts: Date.now(),
+        content: { msgtype: "m.text", body: `msg-${eventId}` },
+      });
+    });
+    const getMemberDisplayName = vi
+      .fn()
+      .mockImplementation((_r: string, userId: string) => Promise.resolve(userId));
+
+    // Use a small cache by testing the eviction pattern:
+    // The actual MAX_CACHED_REPLY_CONTEXTS is 256. We cannot override it easily,
+    // but we can verify that a cache hit reorders entries (delete + re-insert).
+    const resolveReplyContext = createMatrixReplyContextResolver({
+      client: { getEvent } as never,
+      getMemberDisplayName,
+      logVerboseMessage: () => {},
+    });
+
+    // Populate cache with two entries
+    await resolveReplyContext({ roomId: "!r:e", eventId: "$A" });
+    await resolveReplyContext({ roomId: "!r:e", eventId: "$B" });
+    expect(getEvent).toHaveBeenCalledTimes(2);
+
+    // Access $A again — should be a cache hit (no new getEvent call)
+    // and should move $A to the end of the Map for LRU.
+    const hitResult = await resolveReplyContext({ roomId: "!r:e", eventId: "$A" });
+    expect(getEvent).toHaveBeenCalledTimes(2); // Still 2 — cache hit
+    expect(hitResult.replyToBody).toBe("msg-$A");
+  });
+});