@archipelagolab/lobi 1.0.1 → 1.0.6

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

@@ -1,265 +0,0 @@
-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

@@ -1,136 +0,0 @@
-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

@@ -1,276 +0,0 @@
-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");
-  });
-});