loudmouth-ai 0.1.0 → 0.2.0

package/extensions/matrix/src/matrix/monitor/index.ts

@@ -1,279 +0,0 @@
-import { format } from "node:util";
-
-import {
-  mergeAllowlist,
-  summarizeMapping,
-  type RuntimeEnv,
-} from "clawdbot/plugin-sdk";
-import type { CoreConfig, ReplyToMode } from "../../types.js";
-import { setActiveMatrixClient } from "../active-client.js";
-import {
-  isBunRuntime,
-  resolveMatrixAuth,
-  resolveSharedMatrixClient,
-  stopSharedClient,
-} from "../client.js";
-import { registerMatrixAutoJoin } from "./auto-join.js";
-import { createDirectRoomTracker } from "./direct.js";
-import { registerMatrixMonitorEvents } from "./events.js";
-import { createMatrixRoomMessageHandler } from "./handler.js";
-import { createMatrixRoomInfoResolver } from "./room-info.js";
-import { resolveMatrixTargets } from "../../resolve-targets.js";
-import { getMatrixRuntime } from "../../runtime.js";
-
-export type MonitorMatrixOpts = {
-  runtime?: RuntimeEnv;
-  abortSignal?: AbortSignal;
-  mediaMaxMb?: number;
-  initialSyncLimit?: number;
-  replyToMode?: ReplyToMode;
-  accountId?: string | null;
-};
-
-const DEFAULT_MEDIA_MAX_MB = 20;
-
-export async function monitorMatrixProvider(opts: MonitorMatrixOpts = {}): Promise<void> {
-  if (isBunRuntime()) {
-    throw new Error("Matrix provider requires Node (bun runtime not supported)");
-  }
-  const core = getMatrixRuntime();
-  let cfg = core.config.loadConfig() as CoreConfig;
-  if (cfg.channels?.matrix?.enabled === false) return;
-
-  const logger = core.logging.getChildLogger({ module: "matrix-auto-reply" });
-  const formatRuntimeMessage = (...args: Parameters<RuntimeEnv["log"]>) => format(...args);
-  const runtime: RuntimeEnv = opts.runtime ?? {
-    log: (...args) => {
-      logger.info(formatRuntimeMessage(...args));
-    },
-    error: (...args) => {
-      logger.error(formatRuntimeMessage(...args));
-    },
-    exit: (code: number): never => {
-      throw new Error(`exit ${code}`);
-    },
-  };
-  const logVerboseMessage = (message: string) => {
-    if (!core.logging.shouldLogVerbose()) return;
-    logger.debug(message);
-  };
-
-  const normalizeUserEntry = (raw: string) =>
-    raw.replace(/^matrix:/i, "").replace(/^user:/i, "").trim();
-  const normalizeRoomEntry = (raw: string) =>
-    raw.replace(/^matrix:/i, "").replace(/^(room|channel):/i, "").trim();
-  const isMatrixUserId = (value: string) => value.startsWith("@") && value.includes(":");
-
-  const allowlistOnly = cfg.channels?.matrix?.allowlistOnly === true;
-  let allowFrom = cfg.channels?.matrix?.dm?.allowFrom ?? [];
-  let roomsConfig = cfg.channels?.matrix?.groups ?? cfg.channels?.matrix?.rooms;
-
-  if (allowFrom.length > 0) {
-    const entries = allowFrom
-      .map((entry) => normalizeUserEntry(String(entry)))
-      .filter((entry) => entry && entry !== "*");
-    if (entries.length > 0) {
-      const mapping: string[] = [];
-      const unresolved: string[] = [];
-      const additions: string[] = [];
-      const pending: string[] = [];
-      for (const entry of entries) {
-        if (isMatrixUserId(entry)) {
-          additions.push(entry);
-          continue;
-        }
-        pending.push(entry);
-      }
-      if (pending.length > 0) {
-        const resolved = await resolveMatrixTargets({
-          cfg,
-          inputs: pending,
-          kind: "user",
-          runtime,
-        });
-        for (const entry of resolved) {
-          if (entry.resolved && entry.id) {
-            additions.push(entry.id);
-            mapping.push(`${entry.input}→${entry.id}`);
-          } else {
-            unresolved.push(entry.input);
-          }
-        }
-      }
-      allowFrom = mergeAllowlist({ existing: allowFrom, additions });
-      summarizeMapping("matrix users", mapping, unresolved, runtime);
-    }
-  }
-
-  if (roomsConfig && Object.keys(roomsConfig).length > 0) {
-    const entries = Object.keys(roomsConfig).filter((key) => key !== "*");
-    const mapping: string[] = [];
-    const unresolved: string[] = [];
-    const nextRooms = { ...roomsConfig };
-    const pending: Array<{ input: string; query: string }> = [];
-    for (const entry of entries) {
-      const trimmed = entry.trim();
-      if (!trimmed) continue;
-      const cleaned = normalizeRoomEntry(trimmed);
-      if (cleaned.startsWith("!") && cleaned.includes(":")) {
-        if (!nextRooms[cleaned]) {
-          nextRooms[cleaned] = roomsConfig[entry];
-        }
-        mapping.push(`${entry}→${cleaned}`);
-        continue;
-      }
-      pending.push({ input: entry, query: trimmed });
-    }
-    if (pending.length > 0) {
-      const resolved = await resolveMatrixTargets({
-        cfg,
-        inputs: pending.map((entry) => entry.query),
-        kind: "group",
-        runtime,
-      });
-      resolved.forEach((entry, index) => {
-        const source = pending[index];
-        if (!source) return;
-        if (entry.resolved && entry.id) {
-          if (!nextRooms[entry.id]) {
-            nextRooms[entry.id] = roomsConfig[source.input];
-          }
-          mapping.push(`${source.input}→${entry.id}`);
-        } else {
-          unresolved.push(source.input);
-        }
-      });
-    }
-    roomsConfig = nextRooms;
-    summarizeMapping("matrix rooms", mapping, unresolved, runtime);
-  }
-
-  cfg = {
-    ...cfg,
-    channels: {
-      ...cfg.channels,
-      matrix: {
-        ...cfg.channels?.matrix,
-        dm: {
-          ...cfg.channels?.matrix?.dm,
-          allowFrom,
-        },
-        ...(roomsConfig ? { groups: roomsConfig } : {}),
-      },
-    },
-  };
-
-  const auth = await resolveMatrixAuth({ cfg });
-  const resolvedInitialSyncLimit =
-    typeof opts.initialSyncLimit === "number"
-      ? Math.max(0, Math.floor(opts.initialSyncLimit))
-      : auth.initialSyncLimit;
-  const authWithLimit =
-    resolvedInitialSyncLimit === auth.initialSyncLimit
-      ? auth
-      : { ...auth, initialSyncLimit: resolvedInitialSyncLimit };
-  const client = await resolveSharedMatrixClient({
-    cfg,
-    auth: authWithLimit,
-    startClient: false,
-    accountId: opts.accountId,
-  });
-  setActiveMatrixClient(client);
-
-  const mentionRegexes = core.channel.mentions.buildMentionRegexes(cfg);
-  const defaultGroupPolicy = cfg.channels?.defaults?.groupPolicy;
-  const groupPolicyRaw = cfg.channels?.matrix?.groupPolicy ?? defaultGroupPolicy ?? "allowlist";
-  const groupPolicy = allowlistOnly && groupPolicyRaw === "open" ? "allowlist" : groupPolicyRaw;
-  const replyToMode = opts.replyToMode ?? cfg.channels?.matrix?.replyToMode ?? "off";
-  const threadReplies = cfg.channels?.matrix?.threadReplies ?? "inbound";
-  const dmConfig = cfg.channels?.matrix?.dm;
-  const dmEnabled = dmConfig?.enabled ?? true;
-  const dmPolicyRaw = dmConfig?.policy ?? "pairing";
-  const dmPolicy = allowlistOnly && dmPolicyRaw !== "disabled" ? "allowlist" : dmPolicyRaw;
-  const textLimit = core.channel.text.resolveTextChunkLimit(cfg, "matrix");
-  const mediaMaxMb = opts.mediaMaxMb ?? cfg.channels?.matrix?.mediaMaxMb ?? DEFAULT_MEDIA_MAX_MB;
-  const mediaMaxBytes = Math.max(1, mediaMaxMb) * 1024 * 1024;
-  const startupMs = Date.now();
-  const startupGraceMs = 0;
-  const directTracker = createDirectRoomTracker(client, { log: logVerboseMessage });
-  registerMatrixAutoJoin({ client, cfg, runtime });
-  const warnedEncryptedRooms = new Set<string>();
-  const warnedCryptoMissingRooms = new Set<string>();
-
-  const { getRoomInfo, getMemberDisplayName } = createMatrixRoomInfoResolver(client);
-  const handleRoomMessage = createMatrixRoomMessageHandler({
-    client,
-    core,
-    cfg,
-    runtime,
-    logger,
-    logVerboseMessage,
-    allowFrom,
-    roomsConfig,
-    mentionRegexes,
-    groupPolicy,
-    replyToMode,
-    threadReplies,
-    dmEnabled,
-    dmPolicy,
-    textLimit,
-    mediaMaxBytes,
-    startupMs,
-    startupGraceMs,
-    directTracker,
-    getRoomInfo,
-    getMemberDisplayName,
-  });
-
-  registerMatrixMonitorEvents({
-    client,
-    auth,
-    logVerboseMessage,
-    warnedEncryptedRooms,
-    warnedCryptoMissingRooms,
-    logger,
-    formatNativeDependencyHint: core.system.formatNativeDependencyHint,
-    onRoomMessage: handleRoomMessage,
-  });
-
-  logVerboseMessage("matrix: starting client");
-  await resolveSharedMatrixClient({
-    cfg,
-    auth: authWithLimit,
-    accountId: opts.accountId,
-  });
-  logVerboseMessage("matrix: client started");
-
-  // matrix-bot-sdk client is already started via resolveSharedMatrixClient
-  logger.info(`matrix: logged in as ${auth.userId}`);
-
-  // If E2EE is enabled, trigger device verification
-  if (auth.encryption && client.crypto) {
-    try {
-      // Request verification from other sessions
-      const verificationRequest = await client.crypto.requestOwnUserVerification();
-      if (verificationRequest) {
-        logger.info("matrix: device verification requested - please verify in another client");
-      }
-    } catch (err) {
-      logger.debug({ error: String(err) }, "Device verification request failed (may already be verified)");
-    }
-  }
-
-  await new Promise<void>((resolve) => {
-    const onAbort = () => {
-      try {
-        logVerboseMessage("matrix: stopping client");
-        stopSharedClient();
-      } finally {
-        setActiveMatrixClient(null);
-        resolve();
-      }
-    };
-    if (opts.abortSignal?.aborted) {
-      onAbort();
-      return;
-    }
-    opts.abortSignal?.addEventListener("abort", onAbort, { once: true });
-  });
-}

package/extensions/matrix/src/matrix/monitor/location.ts

@@ -1,83 +0,0 @@
-import type { LocationMessageEventContent } from "matrix-bot-sdk";
-
-import {
-  formatLocationText,
-  toLocationContext,
-  type NormalizedLocation,
-} from "clawdbot/plugin-sdk";
-import { EventType } from "./types.js";
-
-export type MatrixLocationPayload = {
-  text: string;
-  context: ReturnType<typeof toLocationContext>;
-};
-
-type GeoUriParams = {
-  latitude: number;
-  longitude: number;
-  accuracy?: number;
-};
-
-function parseGeoUri(value: string): GeoUriParams | null {
-  const trimmed = value.trim();
-  if (!trimmed) return null;
-  if (!trimmed.toLowerCase().startsWith("geo:")) return null;
-  const payload = trimmed.slice(4);
-  const [coordsPart, ...paramParts] = payload.split(";");
-  const coords = coordsPart.split(",");
-  if (coords.length < 2) return null;
-  const latitude = Number.parseFloat(coords[0] ?? "");
-  const longitude = Number.parseFloat(coords[1] ?? "");
-  if (!Number.isFinite(latitude) || !Number.isFinite(longitude)) return null;
-
-  const params = new Map<string, string>();
-  for (const part of paramParts) {
-    const segment = part.trim();
-    if (!segment) continue;
-    const eqIndex = segment.indexOf("=");
-    const rawKey = eqIndex === -1 ? segment : segment.slice(0, eqIndex);
-    const rawValue = eqIndex === -1 ? "" : segment.slice(eqIndex + 1);
-    const key = rawKey.trim().toLowerCase();
-    if (!key) continue;
-    const valuePart = rawValue.trim();
-    params.set(key, valuePart ? decodeURIComponent(valuePart) : "");
-  }
-
-  const accuracyRaw = params.get("u");
-  const accuracy = accuracyRaw ? Number.parseFloat(accuracyRaw) : undefined;
-
-  return {
-    latitude,
-    longitude,
-    accuracy: Number.isFinite(accuracy) ? accuracy : undefined,
-  };
-}
-
-export function resolveMatrixLocation(params: {
-  eventType: string;
-  content: LocationMessageEventContent;
-}): MatrixLocationPayload | null {
-  const { eventType, content } = params;
-  const isLocation =
-    eventType === EventType.Location ||
-    (eventType === EventType.RoomMessage && content.msgtype === EventType.Location);
-  if (!isLocation) return null;
-  const geoUri = typeof content.geo_uri === "string" ? content.geo_uri.trim() : "";
-  if (!geoUri) return null;
-  const parsed = parseGeoUri(geoUri);
-  if (!parsed) return null;
-  const caption = typeof content.body === "string" ? content.body.trim() : "";
-  const location: NormalizedLocation = {
-    latitude: parsed.latitude,
-    longitude: parsed.longitude,
-    accuracy: parsed.accuracy,
-    caption: caption || undefined,
-    source: "pin",
-    isLive: false,
-  };
-
-  return {
-    text: formatLocationText(location),
-    context: toLocationContext(location),
-  };
-}

package/extensions/matrix/src/matrix/monitor/media.test.ts

@@ -1,103 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-
-import type { PluginRuntime } from "clawdbot/plugin-sdk";
-import { setMatrixRuntime } from "../../runtime.js";
-import { downloadMatrixMedia } from "./media.js";
-
-describe("downloadMatrixMedia", () => {
-  const saveMediaBuffer = vi.fn().mockResolvedValue({
-    path: "/tmp/media",
-    contentType: "image/png",
-  });
-
-  const runtimeStub = {
-    channel: {
-      media: {
-        saveMediaBuffer: (...args: unknown[]) => saveMediaBuffer(...args),
-      },
-    },
-  } as unknown as PluginRuntime;
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-    setMatrixRuntime(runtimeStub);
-  });
-
-  it("decrypts encrypted media when file payloads are present", async () => {
-    const decryptMedia = vi.fn().mockResolvedValue(Buffer.from("decrypted"));
-
-    const client = {
-      crypto: { decryptMedia },
-      mxcToHttp: vi.fn().mockReturnValue("https://example/mxc"),
-    } as unknown as import("matrix-bot-sdk").MatrixClient;
-
-    const file = {
-      url: "mxc://example/file",
-      key: {
-        kty: "oct",
-        key_ops: ["encrypt", "decrypt"],
-        alg: "A256CTR",
-        k: "secret",
-        ext: true,
-      },
-      iv: "iv",
-      hashes: { sha256: "hash" },
-      v: "v2",
-    };
-
-    const result = await downloadMatrixMedia({
-      client,
-      mxcUrl: "mxc://example/file",
-      contentType: "image/png",
-      maxBytes: 1024,
-      file,
-    });
-
-    // decryptMedia should be called with just the file object (it handles download internally)
-    expect(decryptMedia).toHaveBeenCalledWith(file);
-    expect(saveMediaBuffer).toHaveBeenCalledWith(
-      Buffer.from("decrypted"),
-      "image/png",
-      "inbound",
-      1024,
-    );
-    expect(result?.path).toBe("/tmp/media");
-  });
-
-  it("rejects encrypted media that exceeds maxBytes before decrypting", async () => {
-    const decryptMedia = vi.fn().mockResolvedValue(Buffer.from("decrypted"));
-
-    const client = {
-      crypto: { decryptMedia },
-      mxcToHttp: vi.fn().mockReturnValue("https://example/mxc"),
-    } as unknown as import("matrix-bot-sdk").MatrixClient;
-
-    const file = {
-      url: "mxc://example/file",
-      key: {
-        kty: "oct",
-        key_ops: ["encrypt", "decrypt"],
-        alg: "A256CTR",
-        k: "secret",
-        ext: true,
-      },
-      iv: "iv",
-      hashes: { sha256: "hash" },
-      v: "v2",
-    };
-
-    await expect(
-      downloadMatrixMedia({
-        client,
-        mxcUrl: "mxc://example/file",
-        contentType: "image/png",
-        sizeBytes: 2048,
-        maxBytes: 1024,
-        file,
-      }),
-    ).rejects.toThrow("Matrix media exceeds configured size limit");
-
-    expect(decryptMedia).not.toHaveBeenCalled();
-    expect(saveMediaBuffer).not.toHaveBeenCalled();
-  });
-});

package/extensions/matrix/src/matrix/monitor/media.ts

@@ -1,113 +0,0 @@
-import type { MatrixClient } from "matrix-bot-sdk";
-
-import { getMatrixRuntime } from "../../runtime.js";
-
-// Type for encrypted file info
-type EncryptedFile = {
-  url: string;
-  key: {
-    kty: string;
-    key_ops: string[];
-    alg: string;
-    k: string;
-    ext: boolean;
-  };
-  iv: string;
-  hashes: Record<string, string>;
-  v: string;
-};
-
-async function fetchMatrixMediaBuffer(params: {
-  client: MatrixClient;
-  mxcUrl: string;
-  maxBytes: number;
-}): Promise<{ buffer: Buffer; headerType?: string } | null> {
-  // matrix-bot-sdk provides mxcToHttp helper
-  const url = params.client.mxcToHttp(params.mxcUrl);
-  if (!url) return null;
-
-  // Use the client's download method which handles auth
-  try {
-    const buffer = await params.client.downloadContent(params.mxcUrl);
-    if (buffer.byteLength > params.maxBytes) {
-      throw new Error("Matrix media exceeds configured size limit");
-    }
-    return { buffer: Buffer.from(buffer) };
-  } catch (err) {
-    throw new Error(`Matrix media download failed: ${String(err)}`);
-  }
-}
-
-/**
- * Download and decrypt encrypted media from a Matrix room.
- * Uses matrix-bot-sdk's decryptMedia which handles both download and decryption.
- */
-async function fetchEncryptedMediaBuffer(params: {
-  client: MatrixClient;
-  file: EncryptedFile;
-  maxBytes: number;
-}): Promise<{ buffer: Buffer } | null> {
-  if (!params.client.crypto) {
-    throw new Error("Cannot decrypt media: crypto not enabled");
-  }
-
-  // decryptMedia handles downloading and decrypting the encrypted content internally
-  const decrypted = await params.client.crypto.decryptMedia(params.file);
-
-  if (decrypted.byteLength > params.maxBytes) {
-    throw new Error("Matrix media exceeds configured size limit");
-  }
-
-  return { buffer: decrypted };
-}
-
-export async function downloadMatrixMedia(params: {
-  client: MatrixClient;
-  mxcUrl: string;
-  contentType?: string;
-  sizeBytes?: number;
-  maxBytes: number;
-  file?: EncryptedFile;
-}): Promise<{
-  path: string;
-  contentType?: string;
-  placeholder: string;
-} | null> {
-  let fetched: { buffer: Buffer; headerType?: string } | null;
-  if (
-    typeof params.sizeBytes === "number" &&
-    params.sizeBytes > params.maxBytes
-  ) {
-    throw new Error("Matrix media exceeds configured size limit");
-  }
-
-  if (params.file) {
-    // Encrypted media
-    fetched = await fetchEncryptedMediaBuffer({
-      client: params.client,
-      file: params.file,
-      maxBytes: params.maxBytes,
-    });
-  } else {
-    // Unencrypted media
-    fetched = await fetchMatrixMediaBuffer({
-      client: params.client,
-      mxcUrl: params.mxcUrl,
-      maxBytes: params.maxBytes,
-    });
-  }
-
-  if (!fetched) return null;
-  const headerType = fetched.headerType ?? params.contentType ?? undefined;
-  const saved = await getMatrixRuntime().channel.media.saveMediaBuffer(
-    fetched.buffer,
-    headerType,
-    "inbound",
-    params.maxBytes,
-  );
-  return {
-    path: saved.path,
-    contentType: saved.contentType,
-    placeholder: "[matrix media]",
-  };
-}

package/extensions/matrix/src/matrix/monitor/mentions.ts

@@ -1,31 +0,0 @@
-import { getMatrixRuntime } from "../../runtime.js";
-
-// Type for room message content with mentions
-type MessageContentWithMentions = {
-  msgtype: string;
-  body: string;
-  "m.mentions"?: {
-    user_ids?: string[];
-    room?: boolean;
-  };
-};
-
-export function resolveMentions(params: {
-  content: MessageContentWithMentions;
-  userId?: string | null;
-  text?: string;
-  mentionRegexes: RegExp[];
-}) {
-  const mentions = params.content["m.mentions"];
-  const mentionedUsers = Array.isArray(mentions?.user_ids)
-    ? new Set(mentions.user_ids)
-    : new Set<string>();
-  const wasMentioned =
-    Boolean(mentions?.room) ||
-    (params.userId ? mentionedUsers.has(params.userId) : false) ||
-    getMatrixRuntime().channel.mentions.matchesMentionPatterns(
-      params.text ?? "",
-      params.mentionRegexes,
-    );
-  return { wasMentioned, hasExplicitMention: Boolean(mentions) };
-}

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

@@ -1,96 +0,0 @@
-import type { MatrixClient } from "matrix-bot-sdk";
-
-import type { MarkdownTableMode, ReplyPayload, RuntimeEnv } from "clawdbot/plugin-sdk";
-import { sendMessageMatrix } from "../send.js";
-import { getMatrixRuntime } from "../../runtime.js";
-
-export async function deliverMatrixReplies(params: {
-  replies: ReplyPayload[];
-  roomId: string;
-  client: MatrixClient;
-  runtime: RuntimeEnv;
-  textLimit: number;
-  replyToMode: "off" | "first" | "all";
-  threadId?: string;
-  accountId?: string;
-  tableMode?: MarkdownTableMode;
-}): Promise<void> {
-  const core = getMatrixRuntime();
-  const cfg = core.config.loadConfig();
-  const tableMode =
-    params.tableMode ??
-    core.channel.text.resolveMarkdownTableMode({
-      cfg,
-      channel: "matrix",
-      accountId: params.accountId,
-    });
-  const logVerbose = (message: string) => {
-    if (core.logging.shouldLogVerbose()) {
-      params.runtime.log?.(message);
-    }
-  };
-  const chunkLimit = Math.min(params.textLimit, 4000);
-  const chunkMode = core.channel.text.resolveChunkMode(cfg, "matrix", params.accountId);
-  let hasReplied = false;
-  for (const reply of params.replies) {
-    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 text = core.channel.text.convertMarkdownTables(rawText, tableMode);
-    const mediaList = reply.mediaUrls?.length
-      ? reply.mediaUrls
-      : reply.mediaUrl
-        ? [reply.mediaUrl]
-        : [];
-
-    const shouldIncludeReply = (id?: string) =>
-      Boolean(id) && (params.replyToMode === "all" || !hasReplied);
-
-    if (mediaList.length === 0) {
-      for (const chunk of core.channel.text.chunkMarkdownTextWithMode(
-        text,
-        chunkLimit,
-        chunkMode,
-      )) {
-        const trimmed = chunk.trim();
-        if (!trimmed) continue;
-        await sendMessageMatrix(params.roomId, trimmed, {
-          client: params.client,
-          replyToId: shouldIncludeReply(replyToId) ? replyToId : undefined,
-          threadId: params.threadId,
-          accountId: params.accountId,
-        });
-        if (shouldIncludeReply(replyToId)) {
-          hasReplied = true;
-        }
-      }
-      continue;
-    }
-
-    let first = true;
-    for (const mediaUrl of mediaList) {
-      const caption = first ? text : "";
-      await sendMessageMatrix(params.roomId, caption, {
-        client: params.client,
-        mediaUrl,
-        replyToId: shouldIncludeReply(replyToId) ? replyToId : undefined,
-        threadId: params.threadId,
-        audioAsVoice: reply.audioAsVoice,
-        accountId: params.accountId,
-      });
-      if (shouldIncludeReply(replyToId)) {
-        hasReplied = true;
-      }
-      first = false;
-    }
-  }
-}