@openclaw/nextcloud-talk 2026.5.2 → 2026.5.3-beta.2

package/src/inbound.authz.test.ts

@@ -1,149 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import type { PluginRuntime, RuntimeEnv } from "../runtime-api.js";
-import type { ResolvedNextcloudTalkAccount } from "./accounts.js";
-import { handleNextcloudTalkInbound } from "./inbound.js";
-import { setNextcloudTalkRuntime } from "./runtime.js";
-import type { CoreConfig, NextcloudTalkInboundMessage } from "./types.js";
-
-function installInboundAuthzRuntime(params: {
-  readAllowFromStore: () => Promise<string[]>;
-  buildMentionRegexes: () => RegExp[];
-}) {
-  setNextcloudTalkRuntime({
-    channel: {
-      pairing: {
-        readAllowFromStore: params.readAllowFromStore,
-      },
-      commands: {
-        shouldHandleTextCommands: () => false,
-      },
-      text: {
-        hasControlCommand: () => false,
-      },
-      mentions: {
-        buildMentionRegexes: params.buildMentionRegexes,
-        matchesMentionPatterns: () => false,
-      },
-    },
-  } as unknown as PluginRuntime);
-}
-
-function createTestRuntimeEnv(): RuntimeEnv {
-  return {
-    log: vi.fn(),
-    error: vi.fn(),
-  } as unknown as RuntimeEnv;
-}
-
-describe("nextcloud-talk inbound authz", () => {
-  it("does not treat DM pairing-store entries as group allowlist entries", async () => {
-    const readAllowFromStore = vi.fn(async () => ["attacker"]);
-    const buildMentionRegexes = vi.fn(() => [/@openclaw/i]);
-
-    installInboundAuthzRuntime({ readAllowFromStore, buildMentionRegexes });
-
-    const message: NextcloudTalkInboundMessage = {
-      messageId: "m-1",
-      roomToken: "room-1",
-      roomName: "Room 1",
-      senderId: "attacker",
-      senderName: "Attacker",
-      text: "hello",
-      mediaType: "text/plain",
-      timestamp: Date.now(),
-      isGroupChat: true,
-    };
-
-    const account: ResolvedNextcloudTalkAccount = {
-      accountId: "default",
-      enabled: true,
-      baseUrl: "",
-      secret: "",
-      secretSource: "none", // pragma: allowlist secret
-      config: {
-        dmPolicy: "pairing",
-        allowFrom: [],
-        groupPolicy: "allowlist",
-        groupAllowFrom: [],
-      },
-    };
-
-    const config: CoreConfig = {
-      channels: {
-        "nextcloud-talk": {
-          dmPolicy: "pairing",
-          allowFrom: [],
-          groupPolicy: "allowlist",
-          groupAllowFrom: [],
-        },
-      },
-    };
-
-    await handleNextcloudTalkInbound({
-      message,
-      account,
-      config,
-      runtime: createTestRuntimeEnv(),
-    });
-
-    expect(readAllowFromStore).toHaveBeenCalledWith({
-      channel: "nextcloud-talk",
-      accountId: "default",
-    });
-    expect(buildMentionRegexes).not.toHaveBeenCalled();
-  });
-
-  it("matches group rooms by token instead of colliding room names", async () => {
-    const readAllowFromStore = vi.fn(async () => []);
-    const buildMentionRegexes = vi.fn(() => [/@openclaw/i]);
-
-    installInboundAuthzRuntime({ readAllowFromStore, buildMentionRegexes });
-
-    const message: NextcloudTalkInboundMessage = {
-      messageId: "m-2",
-      roomToken: "room-attacker",
-      roomName: "Room Trusted",
-      senderId: "trusted-user",
-      senderName: "Trusted User",
-      text: "hello",
-      mediaType: "text/plain",
-      timestamp: Date.now(),
-      isGroupChat: true,
-    };
-
-    const account: ResolvedNextcloudTalkAccount = {
-      accountId: "default",
-      enabled: true,
-      baseUrl: "",
-      secret: "",
-      secretSource: "none",
-      config: {
-        dmPolicy: "pairing",
-        allowFrom: [],
-        groupPolicy: "allowlist",
-        groupAllowFrom: ["trusted-user"],
-        rooms: {
-          "room-trusted": {
-            enabled: true,
-          },
-        },
-      },
-    };
-
-    await handleNextcloudTalkInbound({
-      message,
-      account,
-      config: {
-        channels: {
-          "nextcloud-talk": {
-            groupPolicy: "allowlist",
-            groupAllowFrom: ["trusted-user"],
-          },
-        },
-      },
-      runtime: createTestRuntimeEnv(),
-    });
-
-    expect(buildMentionRegexes).not.toHaveBeenCalled();
-  });
-});

package/src/inbound.behavior.test.ts

@@ -1,202 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import type { PluginRuntime, RuntimeEnv } from "../runtime-api.js";
-import type { ResolvedNextcloudTalkAccount } from "./accounts.js";
-import { handleNextcloudTalkInbound } from "./inbound.js";
-import { setNextcloudTalkRuntime } from "./runtime.js";
-import type { CoreConfig, NextcloudTalkInboundMessage } from "./types.js";
-
-const {
-  createChannelPairingControllerMock,
-  dispatchInboundReplyWithBaseMock,
-  readStoreAllowFromForDmPolicyMock,
-  resolveDmGroupAccessWithCommandGateMock,
-  resolveAllowlistProviderRuntimeGroupPolicyMock,
-  resolveDefaultGroupPolicyMock,
-  warnMissingProviderGroupPolicyFallbackOnceMock,
-} = vi.hoisted(() => {
-  return {
-    createChannelPairingControllerMock: vi.fn(),
-    dispatchInboundReplyWithBaseMock: vi.fn(),
-    readStoreAllowFromForDmPolicyMock: vi.fn(),
-    resolveDmGroupAccessWithCommandGateMock: vi.fn(),
-    resolveAllowlistProviderRuntimeGroupPolicyMock: vi.fn(),
-    resolveDefaultGroupPolicyMock: vi.fn(),
-    warnMissingProviderGroupPolicyFallbackOnceMock: vi.fn(),
-  };
-});
-
-const sendMessageNextcloudTalkMock = vi.hoisted(() => vi.fn());
-const resolveNextcloudTalkRoomKindMock = vi.hoisted(() => vi.fn());
-
-vi.mock("../runtime-api.js", async () => {
-  const actual = await vi.importActual<typeof import("../runtime-api.js")>("../runtime-api.js");
-  return {
-    ...actual,
-    createChannelPairingController: createChannelPairingControllerMock,
-    dispatchInboundReplyWithBase: dispatchInboundReplyWithBaseMock,
-    readStoreAllowFromForDmPolicy: readStoreAllowFromForDmPolicyMock,
-    resolveDmGroupAccessWithCommandGate: resolveDmGroupAccessWithCommandGateMock,
-    resolveAllowlistProviderRuntimeGroupPolicy: resolveAllowlistProviderRuntimeGroupPolicyMock,
-    resolveDefaultGroupPolicy: resolveDefaultGroupPolicyMock,
-    warnMissingProviderGroupPolicyFallbackOnce: warnMissingProviderGroupPolicyFallbackOnceMock,
-  };
-});
-
-vi.mock("./send.js", () => ({
-  sendMessageNextcloudTalk: sendMessageNextcloudTalkMock,
-}));
-
-vi.mock("./room-info.js", async () => {
-  const actual = await vi.importActual<typeof import("./room-info.js")>("./room-info.js");
-  return {
-    ...actual,
-    resolveNextcloudTalkRoomKind: resolveNextcloudTalkRoomKindMock,
-  };
-});
-
-function installRuntime(params?: {
-  buildMentionRegexes?: () => RegExp[];
-  matchesMentionPatterns?: (body: string, regexes: RegExp[]) => boolean;
-}) {
-  setNextcloudTalkRuntime({
-    channel: {
-      pairing: {
-        readAllowFromStore: vi.fn(async () => []),
-        upsertPairingRequest: vi.fn(async () => ({ code: "123456", created: true })),
-      },
-      commands: {
-        shouldHandleTextCommands: vi.fn(() => false),
-      },
-      text: {
-        hasControlCommand: vi.fn(() => false),
-      },
-      mentions: {
-        buildMentionRegexes: params?.buildMentionRegexes ?? vi.fn(() => []),
-        matchesMentionPatterns: params?.matchesMentionPatterns ?? vi.fn(() => false),
-      },
-    },
-  } as unknown as PluginRuntime);
-}
-
-function createRuntimeEnv() {
-  return {
-    log: vi.fn(),
-    error: vi.fn(),
-  } as unknown as RuntimeEnv;
-}
-
-function createAccount(
-  overrides?: Partial<ResolvedNextcloudTalkAccount>,
-): ResolvedNextcloudTalkAccount {
-  return {
-    accountId: "default",
-    enabled: true,
-    baseUrl: "https://cloud.example.com",
-    secret: "secret",
-    secretSource: "config",
-    config: {
-      dmPolicy: "pairing",
-      allowFrom: [],
-      groupPolicy: "allowlist",
-      groupAllowFrom: [],
-    },
-    ...overrides,
-  };
-}
-
-function createMessage(
-  overrides?: Partial<NextcloudTalkInboundMessage>,
-): NextcloudTalkInboundMessage {
-  return {
-    messageId: "msg-1",
-    roomToken: "room-1",
-    roomName: "Room 1",
-    senderId: "user-1",
-    senderName: "Alice",
-    text: "hello",
-    mediaType: "text/plain",
-    timestamp: Date.now(),
-    isGroupChat: false,
-    ...overrides,
-  };
-}
-
-describe("nextcloud-talk inbound behavior", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-    installRuntime();
-    resolveNextcloudTalkRoomKindMock.mockResolvedValue("direct");
-    resolveDefaultGroupPolicyMock.mockReturnValue("allowlist");
-    resolveAllowlistProviderRuntimeGroupPolicyMock.mockReturnValue({
-      groupPolicy: "allowlist",
-      providerMissingFallbackApplied: false,
-    });
-    warnMissingProviderGroupPolicyFallbackOnceMock.mockReturnValue(undefined);
-    readStoreAllowFromForDmPolicyMock.mockResolvedValue([]);
-  });
-
-  // The DM pairing assertion currently depends on a mocked runtime barrel that Vitest
-  // does not bind reliably for this extension package.
-  it.skip("issues a DM pairing challenge and sends the challenge text", async () => {
-    createChannelPairingControllerMock.mockReturnValue({
-      readStoreForDmPolicy: vi.fn(),
-      issueChallenge: vi.fn(),
-    });
-    resolveDmGroupAccessWithCommandGateMock.mockReturnValue({
-      decision: "pairing",
-      reason: "pairing_required",
-      commandAuthorized: false,
-      effectiveGroupAllowFrom: [],
-    });
-    sendMessageNextcloudTalkMock.mockResolvedValue(undefined);
-
-    const statusSink = vi.fn();
-    await handleNextcloudTalkInbound({
-      message: createMessage(),
-      account: createAccount(),
-      config: { channels: { "nextcloud-talk": {} } } as CoreConfig,
-      runtime: createRuntimeEnv(),
-      statusSink,
-    });
-  });
-
-  it("drops unmentioned group traffic before dispatch", async () => {
-    installRuntime({
-      buildMentionRegexes: vi.fn(() => [/@openclaw/i]),
-      matchesMentionPatterns: vi.fn(() => false),
-    });
-    createChannelPairingControllerMock.mockReturnValue({
-      readStoreForDmPolicy: vi.fn(),
-      issueChallenge: vi.fn(),
-    });
-    resolveNextcloudTalkRoomKindMock.mockResolvedValue("group");
-    resolveDmGroupAccessWithCommandGateMock.mockReturnValue({
-      decision: "allow",
-      reason: "allow",
-      commandAuthorized: false,
-      effectiveGroupAllowFrom: ["user-1"],
-    });
-    const runtime = createRuntimeEnv();
-
-    await handleNextcloudTalkInbound({
-      message: createMessage({
-        roomToken: "room-group",
-        roomName: "Ops",
-        isGroupChat: true,
-      }),
-      account: createAccount({
-        config: {
-          dmPolicy: "pairing",
-          allowFrom: [],
-          groupPolicy: "allowlist",
-          groupAllowFrom: ["user-1"],
-        },
-      }),
-      config: { channels: { "nextcloud-talk": {} } } as CoreConfig,
-      runtime,
-    });
-
-    expect(dispatchInboundReplyWithBaseMock).not.toHaveBeenCalled();
-    expect(runtime.log).toHaveBeenCalledWith("nextcloud-talk: drop room room-group (no mention)");
-  });
-});

package/src/inbound.ts

@@ -1,320 +0,0 @@
-import { normalizeOptionalString } from "openclaw/plugin-sdk/text-runtime";
-import {
-  GROUP_POLICY_BLOCKED_LABEL,
-  createChannelPairingController,
-  deliverFormattedTextWithAttachments,
-  dispatchInboundReplyWithBase,
-  logInboundDrop,
-  readStoreAllowFromForDmPolicy,
-  resolveAllowlistProviderRuntimeGroupPolicy,
-  resolveDefaultGroupPolicy,
-  resolveDmGroupAccessWithCommandGate,
-  warnMissingProviderGroupPolicyFallbackOnce,
-  type OpenClawConfig,
-  type OutboundReplyPayload,
-  type RuntimeEnv,
-} from "../runtime-api.js";
-import type { ResolvedNextcloudTalkAccount } from "./accounts.js";
-import {
-  normalizeNextcloudTalkAllowlist,
-  resolveNextcloudTalkAllowlistMatch,
-  resolveNextcloudTalkGroupAllow,
-  resolveNextcloudTalkMentionGate,
-  resolveNextcloudTalkRequireMention,
-  resolveNextcloudTalkRoomMatch,
-} from "./policy.js";
-import { resolveNextcloudTalkRoomKind } from "./room-info.js";
-import { getNextcloudTalkRuntime } from "./runtime.js";
-import { sendMessageNextcloudTalk } from "./send.js";
-import type { CoreConfig, NextcloudTalkInboundMessage } from "./types.js";
-
-const CHANNEL_ID = "nextcloud-talk" as const;
-
-async function deliverNextcloudTalkReply(params: {
-  cfg: CoreConfig;
-  payload: OutboundReplyPayload;
-  roomToken: string;
-  accountId: string;
-  statusSink?: (patch: { lastOutboundAt?: number }) => void;
-}): Promise<void> {
-  const { cfg, payload, roomToken, accountId, statusSink } = params;
-  await deliverFormattedTextWithAttachments({
-    payload,
-    send: async ({ text, replyToId }) => {
-      await sendMessageNextcloudTalk(roomToken, text, {
-        cfg,
-        accountId,
-        replyTo: replyToId,
-      });
-      statusSink?.({ lastOutboundAt: Date.now() });
-    },
-  });
-}
-
-export async function handleNextcloudTalkInbound(params: {
-  message: NextcloudTalkInboundMessage;
-  account: ResolvedNextcloudTalkAccount;
-  config: CoreConfig;
-  runtime: RuntimeEnv;
-  statusSink?: (patch: { lastInboundAt?: number; lastOutboundAt?: number }) => void;
-}): Promise<void> {
-  const { message, account, config, runtime, statusSink } = params;
-  const core = getNextcloudTalkRuntime();
-  const pairing = createChannelPairingController({
-    core,
-    channel: CHANNEL_ID,
-    accountId: account.accountId,
-  });
-
-  const rawBody = message.text?.trim() ?? "";
-  if (!rawBody) {
-    return;
-  }
-
-  const roomKind = await resolveNextcloudTalkRoomKind({
-    account,
-    roomToken: message.roomToken,
-    runtime,
-  });
-  const isGroup = roomKind === "direct" ? false : roomKind === "group" ? true : message.isGroupChat;
-  const senderId = message.senderId;
-  const senderName = message.senderName;
-  const roomToken = message.roomToken;
-  const roomName = message.roomName;
-
-  statusSink?.({ lastInboundAt: message.timestamp });
-
-  const dmPolicy = account.config.dmPolicy ?? "pairing";
-  const defaultGroupPolicy = resolveDefaultGroupPolicy(config as OpenClawConfig);
-  const { groupPolicy, providerMissingFallbackApplied } =
-    resolveAllowlistProviderRuntimeGroupPolicy({
-      providerConfigPresent:
-        ((config.channels as Record<string, unknown> | undefined)?.["nextcloud-talk"] ??
-          undefined) !== undefined,
-      groupPolicy: account.config.groupPolicy,
-      defaultGroupPolicy,
-    });
-  warnMissingProviderGroupPolicyFallbackOnce({
-    providerMissingFallbackApplied,
-    providerKey: "nextcloud-talk",
-    accountId: account.accountId,
-    blockedLabel: GROUP_POLICY_BLOCKED_LABEL.room,
-    log: (message) => runtime.log?.(message),
-  });
-
-  const configAllowFrom = normalizeNextcloudTalkAllowlist(account.config.allowFrom);
-  const configGroupAllowFrom = normalizeNextcloudTalkAllowlist(account.config.groupAllowFrom);
-  const storeAllowFrom = await readStoreAllowFromForDmPolicy({
-    provider: CHANNEL_ID,
-    accountId: account.accountId,
-    dmPolicy,
-    readStore: pairing.readStoreForDmPolicy,
-  });
-  const storeAllowList = normalizeNextcloudTalkAllowlist(storeAllowFrom);
-
-  const roomMatch = resolveNextcloudTalkRoomMatch({
-    rooms: account.config.rooms,
-    roomToken,
-  });
-  const roomConfig = roomMatch.roomConfig;
-  if (isGroup && !roomMatch.allowed) {
-    runtime.log?.(`nextcloud-talk: drop room ${roomToken} (not allowlisted)`);
-    return;
-  }
-  if (roomConfig?.enabled === false) {
-    runtime.log?.(`nextcloud-talk: drop room ${roomToken} (disabled)`);
-    return;
-  }
-
-  const roomAllowFrom = normalizeNextcloudTalkAllowlist(roomConfig?.allowFrom);
-
-  const allowTextCommands = core.channel.commands.shouldHandleTextCommands({
-    cfg: config as OpenClawConfig,
-    surface: CHANNEL_ID,
-  });
-  const useAccessGroups =
-    (config.commands as Record<string, unknown> | undefined)?.useAccessGroups !== false;
-  const hasControlCommand = core.channel.text.hasControlCommand(rawBody, config as OpenClawConfig);
-  const access = resolveDmGroupAccessWithCommandGate({
-    isGroup,
-    dmPolicy,
-    groupPolicy,
-    allowFrom: configAllowFrom,
-    groupAllowFrom: configGroupAllowFrom,
-    storeAllowFrom: storeAllowList,
-    isSenderAllowed: (allowFrom) =>
-      resolveNextcloudTalkAllowlistMatch({
-        allowFrom,
-        senderId,
-      }).allowed,
-    command: {
-      useAccessGroups,
-      allowTextCommands,
-      hasControlCommand,
-    },
-  });
-  const commandAuthorized = access.commandAuthorized;
-  const effectiveGroupAllowFrom = access.effectiveGroupAllowFrom;
-
-  if (isGroup) {
-    if (access.decision !== "allow") {
-      runtime.log?.(`nextcloud-talk: drop group sender ${senderId} (reason=${access.reason})`);
-      return;
-    }
-    const groupAllow = resolveNextcloudTalkGroupAllow({
-      groupPolicy,
-      outerAllowFrom: effectiveGroupAllowFrom,
-      innerAllowFrom: roomAllowFrom,
-      senderId,
-    });
-    if (!groupAllow.allowed) {
-      runtime.log?.(`nextcloud-talk: drop group sender ${senderId} (policy=${groupPolicy})`);
-      return;
-    }
-  } else {
-    if (access.decision !== "allow") {
-      if (access.decision === "pairing") {
-        await pairing.issueChallenge({
-          senderId,
-          senderIdLine: `Your Nextcloud user id: ${senderId}`,
-          meta: { name: senderName || undefined },
-          sendPairingReply: async (text) => {
-            await sendMessageNextcloudTalk(roomToken, text, {
-              cfg: config,
-              accountId: account.accountId,
-            });
-            statusSink?.({ lastOutboundAt: Date.now() });
-          },
-          onReplyError: (err) => {
-            runtime.error?.(`nextcloud-talk: pairing reply failed for ${senderId}: ${String(err)}`);
-          },
-        });
-      }
-      runtime.log?.(`nextcloud-talk: drop DM sender ${senderId} (reason=${access.reason})`);
-      return;
-    }
-  }
-
-  if (access.shouldBlockControlCommand) {
-    logInboundDrop({
-      log: (message) => runtime.log?.(message),
-      channel: CHANNEL_ID,
-      reason: "control command (unauthorized)",
-      target: senderId,
-    });
-    return;
-  }
-
-  const mentionRegexes = core.channel.mentions.buildMentionRegexes(config as OpenClawConfig);
-  const wasMentioned = mentionRegexes.length
-    ? core.channel.mentions.matchesMentionPatterns(rawBody, mentionRegexes)
-    : false;
-  const shouldRequireMention = isGroup
-    ? resolveNextcloudTalkRequireMention({
-        roomConfig,
-        wildcardConfig: roomMatch.wildcardConfig,
-      })
-    : false;
-  const mentionGate = resolveNextcloudTalkMentionGate({
-    isGroup,
-    requireMention: shouldRequireMention,
-    wasMentioned,
-    allowTextCommands,
-    hasControlCommand,
-    commandAuthorized,
-  });
-  if (isGroup && mentionGate.shouldSkip) {
-    runtime.log?.(`nextcloud-talk: drop room ${roomToken} (no mention)`);
-    return;
-  }
-
-  const route = core.channel.routing.resolveAgentRoute({
-    cfg: config as OpenClawConfig,
-    channel: CHANNEL_ID,
-    accountId: account.accountId,
-    peer: {
-      kind: isGroup ? "group" : "direct",
-      id: isGroup ? roomToken : senderId,
-    },
-  });
-
-  const fromLabel = isGroup ? `room:${roomName || roomToken}` : senderName || `user:${senderId}`;
-  const storePath = core.channel.session.resolveStorePath(
-    (config.session as Record<string, unknown> | undefined)?.store as string | undefined,
-    {
-      agentId: route.agentId,
-    },
-  );
-  const envelopeOptions = core.channel.reply.resolveEnvelopeFormatOptions(config as OpenClawConfig);
-  const previousTimestamp = core.channel.session.readSessionUpdatedAt({
-    storePath,
-    sessionKey: route.sessionKey,
-  });
-  const body = core.channel.reply.formatAgentEnvelope({
-    channel: "Nextcloud Talk",
-    from: fromLabel,
-    timestamp: message.timestamp,
-    previousTimestamp,
-    envelope: envelopeOptions,
-    body: rawBody,
-  });
-
-  const groupSystemPrompt = normalizeOptionalString(roomConfig?.systemPrompt);
-
-  const ctxPayload = core.channel.reply.finalizeInboundContext({
-    Body: body,
-    BodyForAgent: rawBody,
-    RawBody: rawBody,
-    CommandBody: rawBody,
-    From: isGroup ? `nextcloud-talk:room:${roomToken}` : `nextcloud-talk:${senderId}`,
-    To: `nextcloud-talk:${roomToken}`,
-    SessionKey: route.sessionKey,
-    AccountId: route.accountId,
-    ChatType: isGroup ? "group" : "direct",
-    ConversationLabel: fromLabel,
-    SenderName: senderName || undefined,
-    SenderId: senderId,
-    GroupSubject: isGroup ? roomName || roomToken : undefined,
-    GroupSystemPrompt: isGroup ? groupSystemPrompt : undefined,
-    Provider: CHANNEL_ID,
-    Surface: CHANNEL_ID,
-    WasMentioned: isGroup ? wasMentioned : undefined,
-    MessageSid: message.messageId,
-    Timestamp: message.timestamp,
-    OriginatingChannel: CHANNEL_ID,
-    OriginatingTo: `nextcloud-talk:${roomToken}`,
-    CommandAuthorized: commandAuthorized,
-  });
-
-  await dispatchInboundReplyWithBase({
-    cfg: config as OpenClawConfig,
-    channel: CHANNEL_ID,
-    accountId: account.accountId,
-    route,
-    storePath,
-    ctxPayload,
-    core,
-    deliver: async (payload) => {
-      await deliverNextcloudTalkReply({
-        cfg: config,
-        payload,
-        roomToken,
-        accountId: account.accountId,
-        statusSink,
-      });
-    },
-    onRecordError: (err) => {
-      runtime.error?.(`nextcloud-talk: failed updating session meta: ${String(err)}`);
-    },
-    onDispatchError: (err, info) => {
-      runtime.error?.(`nextcloud-talk ${info.kind} reply failed: ${String(err)}`);
-    },
-    replyOptions: {
-      skillFilter: roomConfig?.skills,
-      disableBlockStreaming:
-        typeof account.config.blockStreaming === "boolean"
-          ? !account.config.blockStreaming
-          : undefined,
-    },
-  });
-}