@archipelagolab/lobi 1.0.5 → 1.0.7

package/dist/chunk-U4LVIY5F.js

@@ -1,1405 +0,0 @@
-import {
-  createMatrixThreadContextResolver
-} from "./chunk-Q5QT7JBM.js";
-import {
-  deliverMatrixReplies
-} from "./chunk-FQPYAPJJ.js";
-import {
-  createMatrixReplyContextResolver
-} from "./chunk-T72EMFTX.js";
-import {
-  createRoomHistoryTracker
-} from "./chunk-6HX3DEXK.js";
-import {
-  resolveMatrixLocation
-} from "./chunk-VHG4FNIJ.js";
-import {
-  downloadMatrixMedia
-} from "./chunk-CSJO73LD.js";
-import {
-  resolveMentions
-} from "./chunk-KHFWQ334.js";
-import {
-  handleInboundMatrixReaction
-} from "./chunk-TA2QJPPG.js";
-import {
-  resolveMatrixInboundRoute
-} from "./chunk-W6SOBS7M.js";
-import {
-  resolveMatrixReplyToEventId,
-  resolveMatrixThreadRootId,
-  resolveMatrixThreadRouting
-} from "./chunk-UAB5P5QO.js";
-import {
-  isMatrixVerificationRoomMessage
-} from "./chunk-56HN4SH6.js";
-import {
-  EventType,
-  RelationType
-} from "./chunk-GLLRCKKE.js";
-import {
-  resolveMatrixMonitorAccessState
-} from "./chunk-XZSAN55E.js";
-import {
-  resolveMatrixAckReactionConfig
-} from "./chunk-O5IVKDX7.js";
-import {
-  createMatrixDraftStream
-} from "./chunk-ZJGZNPDK.js";
-import {
-  fetchMatrixPollSnapshot
-} from "./chunk-7MVZYR2T.js";
-import {
-  formatMatrixMediaTooLargeText,
-  formatMatrixMediaUnavailableText,
-  formatMatrixMessageText,
-  resolveMatrixMessageAttachment,
-  resolveMatrixMessageBody
-} from "./chunk-3TRKKAVT.js";
-import {
-  resolveMatrixStoredSessionMeta
-} from "./chunk-CETZGSCP.js";
-import {
-  resolveMatrixRoomConfig
-} from "./chunk-VKOO6MIZ.js";
-import {
-  createReplyPrefixOptions,
-  createTypingCallbacks,
-  ensureConfiguredAcpBindingReady,
-  formatAllowlistMatchMeta,
-  getAgentScopedMediaLocalRoots,
-  logInboundDrop,
-  logTypingFailure
-} from "./chunk-RNGAGYCL.js";
-import {
-  formatMatrixErrorMessage
-} from "./chunk-UWPHOAOC.js";
-import {
-  resolveMatrixAllowListMatch
-} from "./chunk-AH4MLRYT.js";
-import {
-  editMessageMatrix,
-  reactMatrixMessage,
-  sendMessageMatrix,
-  sendReadReceiptMatrix,
-  sendTypingMatrix
-} from "./chunk-INNENDEE.js";
-import {
-  MATRIX_OPENCLAW_FINALIZED_PREVIEW_KEY
-} from "./chunk-MTMHGC3G.js";
-import {
-  formatPollAsText,
-  isPollEventType,
-  isPollStartType,
-  parsePollStartContent
-} from "./chunk-IQYYEHSM.js";
-import {
-  isMatrixMediaSizeLimitError
-} from "./chunk-Z6IVJ6ZW.js";
-import {
-  init_shims
-} from "./chunk-7FLQSTPG.js";
-
-// src/matrix/monitor/handler.ts
-init_shims();
-import { resolveControlCommandGate } from "openclaw/plugin-sdk/command-auth";
-import {
-  loadSessionStore,
-  resolveChannelContextVisibilityMode,
-  resolveSessionStoreEntry
-} from "openclaw/plugin-sdk/config-runtime";
-import { getSessionBindingService } from "openclaw/plugin-sdk/conversation-runtime";
-import { evaluateSupplementalContextVisibility } from "openclaw/plugin-sdk/security-runtime";
-import { normalizeOptionalString } from "openclaw/plugin-sdk/text-runtime";
-var ALLOW_FROM_STORE_CACHE_TTL_MS = 3e4;
-var PAIRING_REPLY_COOLDOWN_MS = 5 * 6e4;
-var MAX_TRACKED_PAIRING_REPLY_SENDERS = 512;
-var MAX_TRACKED_SHARED_DM_CONTEXT_NOTICES = 512;
-async function redactMatrixDraftEvent(client, roomId, draftEventId) {
-  await client.redactEvent(roomId, draftEventId).catch(() => {
-  });
-}
-function buildMatrixFinalizedPreviewContent() {
-  return { [MATRIX_OPENCLAW_FINALIZED_PREVIEW_KEY]: true };
-}
-function resolveMatrixMentionPrecheckText(params) {
-  if (params.locationText?.trim()) {
-    return params.locationText.trim();
-  }
-  if (typeof params.content.body === "string" && params.content.body.trim()) {
-    return params.content.body.trim();
-  }
-  if (isPollStartType(params.eventType)) {
-    const parsed = parsePollStartContent(params.content);
-    if (parsed) {
-      return formatPollAsText(parsed);
-    }
-  }
-  return "";
-}
-function resolveMatrixInboundBodyText(params) {
-  if (params.mediaPlaceholder) {
-    return params.rawBody || params.mediaPlaceholder;
-  }
-  if (!params.mediaDownloadFailed || !params.hadMediaUrl) {
-    return params.rawBody;
-  }
-  if (params.mediaSizeLimitExceeded) {
-    return formatMatrixMediaTooLargeText({
-      body: params.rawBody,
-      filename: params.filename,
-      msgtype: params.msgtype
-    });
-  }
-  return formatMatrixMediaUnavailableText({
-    body: params.rawBody,
-    filename: params.filename,
-    msgtype: params.msgtype
-  });
-}
-function markTrackedRoomIfFirst(set, roomId) {
-  if (set.has(roomId)) {
-    return false;
-  }
-  set.add(roomId);
-  if (set.size > MAX_TRACKED_SHARED_DM_CONTEXT_NOTICES) {
-    const oldest = set.keys().next().value;
-    if (typeof oldest === "string") {
-      set.delete(oldest);
-    }
-  }
-  return true;
-}
-function resolveMatrixSharedDmContextNotice(params) {
-  if ((params.dmSessionScope ?? "per-user") === "per-room") {
-    return null;
-  }
-  if (params.sentRooms.has(params.roomId)) {
-    return null;
-  }
-  try {
-    const store = loadSessionStore(params.storePath);
-    const currentSession = resolveMatrixStoredSessionMeta(
-      resolveSessionStoreEntry({
-        store,
-        sessionKey: params.sessionKey
-      }).existing
-    );
-    if (!currentSession) {
-      return null;
-    }
-    if (currentSession.channel && currentSession.channel !== "matrix") {
-      return null;
-    }
-    if (currentSession.accountId && currentSession.accountId !== params.accountId) {
-      return null;
-    }
-    if (!currentSession.directUserId) {
-      return null;
-    }
-    if (!currentSession.roomId || currentSession.roomId === params.roomId) {
-      return null;
-    }
-    return [
-      "This Matrix DM is sharing a session with another Matrix DM room.",
-      "Use /focus here for a one-off isolated thread session when thread bindings are enabled, or set",
-      "channels.lobi.dm.sessionScope to per-room to isolate each Matrix DM room."
-    ].join(" ");
-  } catch (err) {
-    params.logVerboseMessage(
-      `matrix: failed checking shared DM session notice room=${params.roomId} (${String(err)})`
-    );
-    return null;
-  }
-}
-function resolveMatrixPendingHistoryText(params) {
-  if (params.mentionPrecheckText) {
-    return params.mentionPrecheckText;
-  }
-  if (!params.mediaUrl) {
-    return "";
-  }
-  const body = typeof params.content.body === "string" ? params.content.body.trim() : void 0;
-  const filename = typeof params.content.filename === "string" ? params.content.filename.trim() : void 0;
-  const msgtype = typeof params.content.msgtype === "string" ? params.content.msgtype : void 0;
-  return formatMatrixMessageText({
-    body: resolveMatrixMessageBody({ body, filename, msgtype }),
-    attachment: resolveMatrixMessageAttachment({ body, filename, msgtype })
-  }) ?? "";
-}
-function resolveMatrixAllowBotsMode(value) {
-  if (value === true) {
-    return "all";
-  }
-  if (value === "mentions") {
-    return "mentions";
-  }
-  return "off";
-}
-function createMatrixRoomMessageHandler(params) {
-  const {
-    client,
-    core,
-    cfg,
-    accountId,
-    runtime,
-    logger,
-    logVerboseMessage,
-    allowFrom,
-    groupAllowFrom = [],
-    roomsConfig,
-    accountAllowBots,
-    configuredBotUserIds = /* @__PURE__ */ new Set(),
-    groupPolicy,
-    replyToMode,
-    threadReplies,
-    dmThreadReplies,
-    dmSessionScope,
-    streaming,
-    blockStreamingEnabled,
-    dmEnabled,
-    dmPolicy,
-    textLimit,
-    mediaMaxBytes,
-    historyLimit,
-    startupMs,
-    startupGraceMs,
-    dropPreStartupMessages,
-    inboundDeduper,
-    directTracker,
-    getRoomInfo,
-    getMemberDisplayName,
-    needsRoomAliasesForConfig
-  } = params;
-  const contextVisibilityMode = resolveChannelContextVisibilityMode({
-    cfg,
-    channel: "matrix",
-    accountId
-  });
-  let cachedStoreAllowFrom = null;
-  const pairingReplySentAtMsBySender = /* @__PURE__ */ new Map();
-  const resolveThreadContext = createMatrixThreadContextResolver({
-    client,
-    getMemberDisplayName,
-    logVerboseMessage
-  });
-  const resolveReplyContext = createMatrixReplyContextResolver({
-    client,
-    getMemberDisplayName,
-    logVerboseMessage
-  });
-  const roomHistoryTracker = createRoomHistoryTracker();
-  const roomIngressTails = /* @__PURE__ */ new Map();
-  const sharedDmContextNoticeRooms = /* @__PURE__ */ new Set();
-  const readStoreAllowFrom = async () => {
-    const now = Date.now();
-    if (cachedStoreAllowFrom && now < cachedStoreAllowFrom.expiresAtMs) {
-      return cachedStoreAllowFrom.value;
-    }
-    const value = await core.channel.pairing.readAllowFromStore({
-      channel: "matrix",
-      env: process.env,
-      accountId
-    }).catch(() => []);
-    cachedStoreAllowFrom = {
-      value,
-      expiresAtMs: now + ALLOW_FROM_STORE_CACHE_TTL_MS
-    };
-    return value;
-  };
-  const shouldSendPairingReply = (senderId, created) => {
-    const now = Date.now();
-    if (created) {
-      pairingReplySentAtMsBySender.set(senderId, now);
-      return true;
-    }
-    const lastSentAtMs = pairingReplySentAtMsBySender.get(senderId);
-    if (typeof lastSentAtMs === "number" && now - lastSentAtMs < PAIRING_REPLY_COOLDOWN_MS) {
-      return false;
-    }
-    pairingReplySentAtMsBySender.set(senderId, now);
-    if (pairingReplySentAtMsBySender.size > MAX_TRACKED_PAIRING_REPLY_SENDERS) {
-      const oldestSender = pairingReplySentAtMsBySender.keys().next().value;
-      if (typeof oldestSender === "string") {
-        pairingReplySentAtMsBySender.delete(oldestSender);
-      }
-    }
-    return true;
-  };
-  const runRoomIngress = async (roomId, task) => {
-    const previous = roomIngressTails.get(roomId) ?? Promise.resolve();
-    let releaseCurrent;
-    const current = new Promise((resolve) => {
-      releaseCurrent = resolve;
-    });
-    const chain = previous.catch(() => {
-    }).then(() => current);
-    roomIngressTails.set(roomId, chain);
-    await previous.catch(() => {
-    });
-    try {
-      return await task();
-    } finally {
-      releaseCurrent();
-      if (roomIngressTails.get(roomId) === chain) {
-        roomIngressTails.delete(roomId);
-      }
-    }
-  };
-  return async (roomId, event) => {
-    const eventId = typeof event.event_id === "string" ? event.event_id.trim() : "";
-    let claimedInboundEvent = false;
-    let draftStreamRef;
-    let draftConsumed = false;
-    try {
-      const eventType = event.type;
-      if (eventType === EventType.RoomMessageEncrypted) {
-        return;
-      }
-      const isPollEvent = isPollEventType(eventType);
-      const isReactionEvent = eventType === EventType.Reaction;
-      const locationContent = event.content;
-      const isLocationEvent = eventType === EventType.Location || eventType === EventType.RoomMessage && locationContent.msgtype === EventType.Location;
-      if (eventType !== EventType.RoomMessage && !isPollEvent && !isLocationEvent && !isReactionEvent) {
-        return;
-      }
-      logVerboseMessage(
-        `matrix: inbound event room=${roomId} type=${eventType} id=${event.event_id ?? "unknown"}`
-      );
-      if (event.unsigned?.redacted_because) {
-        return;
-      }
-      const senderId = event.sender;
-      if (!senderId) {
-        return;
-      }
-      const eventTs = event.origin_server_ts;
-      const eventAge = event.unsigned?.age;
-      const commitInboundEventIfClaimed = async () => {
-        if (!claimedInboundEvent || !inboundDeduper || !eventId) {
-          return;
-        }
-        await inboundDeduper.commitEvent({ roomId, eventId });
-        claimedInboundEvent = false;
-      };
-      const readIngressPrefix = async () => {
-        const selfUserId = await client.getUserId();
-        if (senderId === selfUserId) {
-          return void 0;
-        }
-        if (dropPreStartupMessages) {
-          if (typeof eventTs === "number" && eventTs < startupMs - startupGraceMs) {
-            return void 0;
-          }
-          if (typeof eventTs !== "number" && typeof eventAge === "number" && eventAge > startupGraceMs) {
-            return void 0;
-          }
-        }
-        let content = event.content;
-        if (eventType === EventType.RoomMessage && isMatrixVerificationRoomMessage({
-          msgtype: content.msgtype,
-          body: content.body
-        })) {
-          logVerboseMessage(`matrix: skip verification/system room message room=${roomId}`);
-          return void 0;
-        }
-        const locationPayload2 = resolveMatrixLocation({
-          eventType,
-          content
-        });
-        const relates = content["m.relates_to"];
-        if (relates && "rel_type" in relates && relates.rel_type === RelationType.Replace) {
-          return void 0;
-        }
-        if (eventId && inboundDeduper) {
-          claimedInboundEvent = inboundDeduper.claimEvent({ roomId, eventId });
-          if (!claimedInboundEvent) {
-            logVerboseMessage(`matrix: skip duplicate inbound event room=${roomId} id=${eventId}`);
-            return void 0;
-          }
-        }
-        const isDirectMessage2 = await directTracker.isDirectMessage({
-          roomId,
-          senderId,
-          selfUserId
-        });
-        return { content, isDirectMessage: isDirectMessage2, locationPayload: locationPayload2, selfUserId };
-      };
-      const continueIngress = async (params2) => {
-        let content = params2.content;
-        const isDirectMessage2 = params2.isDirectMessage;
-        const isRoom2 = !isDirectMessage2;
-        const { locationPayload: locationPayload2, selfUserId } = params2;
-        if (isRoom2 && groupPolicy === "disabled") {
-          await commitInboundEventIfClaimed();
-          return void 0;
-        }
-        const roomInfoForConfig = isRoom2 && needsRoomAliasesForConfig ? await getRoomInfo(roomId, { includeAliases: true }) : void 0;
-        const roomAliasesForConfig = roomInfoForConfig ? [roomInfoForConfig.canonicalAlias ?? "", ...roomInfoForConfig.altAliases].filter(
-          Boolean
-        ) : [];
-        const roomConfigInfo = isRoom2 ? resolveMatrixRoomConfig({
-          rooms: roomsConfig,
-          roomId,
-          aliases: roomAliasesForConfig
-        }) : void 0;
-        const roomConfig2 = roomConfigInfo?.config;
-        const allowBotsMode = resolveMatrixAllowBotsMode(roomConfig2?.allowBots ?? accountAllowBots);
-        const isConfiguredBotSender = configuredBotUserIds.has(senderId);
-        const roomMatchMeta = roomConfigInfo ? `matchKey=${roomConfigInfo.matchKey ?? "none"} matchSource=${roomConfigInfo.matchSource ?? "none"}` : "matchKey=none matchSource=none";
-        if (isConfiguredBotSender && allowBotsMode === "off") {
-          logVerboseMessage(
-            `matrix: drop configured bot sender=${senderId} (allowBots=false${isDirectMessage2 ? "" : `, ${roomMatchMeta}`})`
-          );
-          await commitInboundEventIfClaimed();
-          return void 0;
-        }
-        if (isRoom2 && roomConfig2 && !roomConfigInfo?.allowed) {
-          logVerboseMessage(`matrix: room disabled room=${roomId} (${roomMatchMeta})`);
-          await commitInboundEventIfClaimed();
-          return void 0;
-        }
-        if (isRoom2 && groupPolicy === "allowlist") {
-          if (!roomConfigInfo?.allowlistConfigured) {
-            logVerboseMessage(`matrix: drop room message (no allowlist, ${roomMatchMeta})`);
-            await commitInboundEventIfClaimed();
-            return void 0;
-          }
-          if (!roomConfig2) {
-            logVerboseMessage(`matrix: drop room message (not in allowlist, ${roomMatchMeta})`);
-            await commitInboundEventIfClaimed();
-            return void 0;
-          }
-        }
-        let senderNamePromise = null;
-        const getSenderName = async () => {
-          senderNamePromise ??= getMemberDisplayName(roomId, senderId).catch(() => senderId);
-          return await senderNamePromise;
-        };
-        const storeAllowFrom = await readStoreAllowFrom();
-        const roomUsers = roomConfig2?.users ?? [];
-        const accessState = resolveMatrixMonitorAccessState({
-          allowFrom,
-          storeAllowFrom,
-          groupAllowFrom,
-          roomUsers,
-          senderId,
-          isRoom: isRoom2
-        });
-        const {
-          effectiveGroupAllowFrom: effectiveGroupAllowFrom2,
-          effectiveRoomUsers: effectiveRoomUsers2,
-          groupAllowConfigured,
-          directAllowMatch,
-          roomUserMatch,
-          groupAllowMatch,
-          commandAuthorizers
-        } = accessState;
-        if (isDirectMessage2) {
-          if (!dmEnabled || dmPolicy === "disabled") {
-            await commitInboundEventIfClaimed();
-            return void 0;
-          }
-          if (dmPolicy !== "open") {
-            const allowMatchMeta = formatAllowlistMatchMeta(directAllowMatch);
-            if (!directAllowMatch.allowed) {
-              if (!isReactionEvent && dmPolicy === "pairing") {
-                const senderName3 = await getSenderName();
-                const { code, created } = await core.channel.pairing.upsertPairingRequest({
-                  channel: "matrix",
-                  id: senderId,
-                  accountId,
-                  meta: { name: senderName3 }
-                });
-                if (shouldSendPairingReply(senderId, created)) {
-                  const pairingReply = core.channel.pairing.buildPairingReply({
-                    channel: "matrix",
-                    idLine: `Your Matrix user id: ${senderId}`,
-                    code
-                  });
-                  logVerboseMessage(
-                    created ? `matrix pairing request sender=${senderId} name=${senderName3 ?? "unknown"} (${allowMatchMeta})` : `matrix pairing reminder sender=${senderId} name=${senderName3 ?? "unknown"} (${allowMatchMeta})`
-                  );
-                  try {
-                    await sendMessageMatrix(
-                      `room:${roomId}`,
-                      created ? pairingReply : `${pairingReply}
-
-Pairing request is still pending approval. Reusing existing code.`,
-                      {
-                        client,
-                        cfg,
-                        accountId
-                      }
-                    );
-                    await commitInboundEventIfClaimed();
-                  } catch (err) {
-                    logVerboseMessage(
-                      `matrix pairing reply failed for ${senderId}: ${String(err)}`
-                    );
-                    return void 0;
-                  }
-                } else {
-                  logVerboseMessage(
-                    `matrix pairing reminder suppressed sender=${senderId} (cooldown)`
-                  );
-                  await commitInboundEventIfClaimed();
-                }
-              }
-              if (isReactionEvent || dmPolicy !== "pairing") {
-                logVerboseMessage(
-                  `matrix: blocked ${isReactionEvent ? "reaction" : "dm"} sender ${senderId} (dmPolicy=${dmPolicy}, ${allowMatchMeta})`
-                );
-                await commitInboundEventIfClaimed();
-              }
-              return void 0;
-            }
-          }
-        }
-        if (isRoom2 && roomUserMatch && !roomUserMatch.allowed) {
-          logVerboseMessage(
-            `matrix: blocked sender ${senderId} (room users allowlist, ${roomMatchMeta}, ${formatAllowlistMatchMeta(
-              roomUserMatch
-            )})`
-          );
-          await commitInboundEventIfClaimed();
-          return void 0;
-        }
-        if (isRoom2 && groupPolicy === "allowlist" && effectiveRoomUsers2.length === 0 && groupAllowConfigured && groupAllowMatch && !groupAllowMatch.allowed) {
-          logVerboseMessage(
-            `matrix: blocked sender ${senderId} (groupAllowFrom, ${roomMatchMeta}, ${formatAllowlistMatchMeta(
-              groupAllowMatch
-            )})`
-          );
-          await commitInboundEventIfClaimed();
-          return void 0;
-        }
-        if (isRoom2) {
-          logVerboseMessage(`matrix: allow room ${roomId} (${roomMatchMeta})`);
-        }
-        if (isReactionEvent) {
-          const senderName3 = await getSenderName();
-          await handleInboundMatrixReaction({
-            client,
-            core,
-            cfg,
-            accountId,
-            roomId,
-            event,
-            senderId,
-            senderLabel: senderName3,
-            selfUserId,
-            isDirectMessage: isDirectMessage2,
-            logVerboseMessage
-          });
-          await commitInboundEventIfClaimed();
-          return void 0;
-        }
-        let pollSnapshotPromise = null;
-        const getPollSnapshot = async () => {
-          if (!isPollEvent) {
-            return null;
-          }
-          pollSnapshotPromise ??= fetchMatrixPollSnapshot(client, roomId, event).catch((err) => {
-            logVerboseMessage(
-              `matrix: failed resolving poll snapshot room=${roomId} id=${event.event_id ?? "unknown"}: ${String(err)}`
-            );
-            return null;
-          });
-          return await pollSnapshotPromise;
-        };
-        const mentionPrecheckText = resolveMatrixMentionPrecheckText({
-          eventType,
-          content,
-          locationText: locationPayload2?.text
-        });
-        const contentUrl = "url" in content && typeof content.url === "string" ? content.url : void 0;
-        const contentFile = "file" in content && content.file && typeof content.file === "object" ? content.file : void 0;
-        const mediaUrl = contentUrl ?? contentFile?.url;
-        const pendingHistoryText = resolveMatrixPendingHistoryText({
-          mentionPrecheckText,
-          content,
-          mediaUrl
-        });
-        const pendingHistoryPollText = !pendingHistoryText && isPollEvent && historyLimit > 0 ? (await getPollSnapshot())?.text : "";
-        if (!mentionPrecheckText && !mediaUrl && !isPollEvent) {
-          await commitInboundEventIfClaimed();
-          return void 0;
-        }
-        const _messageId2 = event.event_id ?? "";
-        const _threadRootId2 = resolveMatrixThreadRootId({ event, content });
-        const thread2 = resolveMatrixThreadRouting({
-          isDirectMessage: isDirectMessage2,
-          threadReplies,
-          dmThreadReplies,
-          messageId: _messageId2,
-          threadRootId: _threadRootId2
-        });
-        const {
-          route: _route2,
-          configuredBinding: _configuredBinding,
-          runtimeBindingId: _runtimeBindingId
-        } = resolveMatrixInboundRoute({
-          cfg,
-          accountId,
-          roomId,
-          senderId,
-          isDirectMessage: isDirectMessage2,
-          dmSessionScope,
-          threadId: thread2.threadId,
-          eventTs: eventTs ?? void 0,
-          resolveAgentRoute: core.channel.routing.resolveAgentRoute
-        });
-        const hasExplicitSessionBinding2 = _configuredBinding !== null || _runtimeBindingId !== null;
-        const agentMentionRegexes = core.channel.mentions.buildMentionRegexes(cfg, _route2.agentId);
-        const selfDisplayName = content.formatted_body ? await getMemberDisplayName(roomId, selfUserId).catch(() => void 0) : void 0;
-        const { wasMentioned: wasMentioned2, hasExplicitMention } = resolveMentions({
-          content,
-          userId: selfUserId,
-          displayName: selfDisplayName,
-          text: mentionPrecheckText,
-          mentionRegexes: agentMentionRegexes
-        });
-        if (isConfiguredBotSender && allowBotsMode === "mentions" && !isDirectMessage2 && !wasMentioned2) {
-          logVerboseMessage(
-            `matrix: drop configured bot sender=${senderId} (allowBots=mentions, missing mention, ${roomMatchMeta})`
-          );
-          await commitInboundEventIfClaimed();
-          return void 0;
-        }
-        const allowTextCommands = core.channel.commands.shouldHandleTextCommands({
-          cfg,
-          surface: "matrix"
-        });
-        const useAccessGroups = cfg.commands?.useAccessGroups !== false;
-        const hasControlCommandInMessage = core.channel.text.hasControlCommand(
-          mentionPrecheckText,
-          cfg
-        );
-        const commandGate = resolveControlCommandGate({
-          useAccessGroups,
-          authorizers: commandAuthorizers,
-          allowTextCommands,
-          hasControlCommand: hasControlCommandInMessage
-        });
-        const commandAuthorized2 = commandGate.commandAuthorized;
-        if (isRoom2 && commandGate.shouldBlock) {
-          logInboundDrop({
-            log: logVerboseMessage,
-            channel: "matrix",
-            reason: "control command (unauthorized)",
-            target: senderId
-          });
-          await commitInboundEventIfClaimed();
-          return void 0;
-        }
-        const shouldRequireMention2 = isRoom2 ? roomConfig2?.autoReply === true ? false : roomConfig2?.autoReply === false ? true : typeof roomConfig2?.requireMention === "boolean" ? roomConfig2?.requireMention : true : false;
-        const shouldBypassMention2 = allowTextCommands && isRoom2 && shouldRequireMention2 && !wasMentioned2 && !hasExplicitMention && commandAuthorized2 && hasControlCommandInMessage;
-        const canDetectMention2 = agentMentionRegexes.length > 0 || hasExplicitMention;
-        if (isRoom2 && shouldRequireMention2 && !wasMentioned2 && !shouldBypassMention2) {
-          const pendingHistoryBody = pendingHistoryText || pendingHistoryPollText;
-          if (historyLimit > 0 && pendingHistoryBody) {
-            const pendingEntry = {
-              sender: senderId,
-              body: pendingHistoryBody,
-              timestamp: eventTs ?? void 0,
-              messageId: _messageId2
-            };
-            roomHistoryTracker.recordPending(roomId, pendingEntry);
-          }
-          logger.info("skipping room message", { roomId, reason: "no-mention" });
-          await commitInboundEventIfClaimed();
-          return void 0;
-        }
-        if (isPollEvent) {
-          const pollSnapshot = await getPollSnapshot();
-          if (!pollSnapshot) {
-            return void 0;
-          }
-          content = {
-            msgtype: "m.text",
-            body: pollSnapshot.text
-          };
-        }
-        let media2 = null;
-        let mediaDownloadFailed = false;
-        let mediaSizeLimitExceeded = false;
-        const finalContentUrl = "url" in content && typeof content.url === "string" ? content.url : void 0;
-        const finalContentFile = "file" in content && content.file && typeof content.file === "object" ? content.file : void 0;
-        const finalMediaUrl = finalContentUrl ?? finalContentFile?.url;
-        const contentBody = typeof content.body === "string" ? content.body.trim() : "";
-        const contentFilename = typeof content.filename === "string" ? content.filename.trim() : "";
-        const originalFilename = contentFilename || contentBody || void 0;
-        const contentInfo = "info" in content && content.info && typeof content.info === "object" ? content.info : void 0;
-        const contentType = contentInfo?.mimetype;
-        const contentSize = typeof contentInfo?.size === "number" ? contentInfo.size : void 0;
-        if (finalMediaUrl?.startsWith("mxc://")) {
-          try {
-            media2 = await downloadMatrixMedia({
-              client,
-              mxcUrl: finalMediaUrl,
-              contentType,
-              sizeBytes: contentSize,
-              maxBytes: mediaMaxBytes,
-              file: finalContentFile,
-              originalFilename
-            });
-          } catch (err) {
-            mediaDownloadFailed = true;
-            if (isMatrixMediaSizeLimitError(err)) {
-              mediaSizeLimitExceeded = true;
-            }
-            const errorText = formatMatrixErrorMessage(err);
-            logVerboseMessage(
-              `matrix: media download failed room=${roomId} id=${event.event_id ?? "unknown"} type=${content.msgtype} error=${errorText}`
-            );
-            logger.warn("matrix media download failed", {
-              roomId,
-              eventId: event.event_id,
-              msgtype: content.msgtype,
-              encrypted: Boolean(finalContentFile),
-              error: errorText
-            });
-          }
-        }
-        const rawBody = locationPayload2?.text ?? contentBody;
-        const bodyText2 = resolveMatrixInboundBodyText({
-          rawBody,
-          filename: typeof content.filename === "string" ? content.filename : void 0,
-          mediaPlaceholder: media2?.placeholder,
-          msgtype: content.msgtype,
-          hadMediaUrl: Boolean(finalMediaUrl),
-          mediaDownloadFailed,
-          mediaSizeLimitExceeded
-        });
-        if (!bodyText2) {
-          await commitInboundEventIfClaimed();
-          return void 0;
-        }
-        const senderName2 = await getSenderName();
-        if (_configuredBinding) {
-          const ensured = await ensureConfiguredAcpBindingReady({
-            cfg,
-            configuredBinding: _configuredBinding
-          });
-          if (!ensured.ok) {
-            logInboundDrop({
-              log: logVerboseMessage,
-              channel: "matrix",
-              reason: "configured ACP binding unavailable",
-              target: _configuredBinding.spec.conversationId
-            });
-            return void 0;
-          }
-        }
-        if (_runtimeBindingId) {
-          getSessionBindingService().touch(_runtimeBindingId, eventTs ?? void 0);
-        }
-        const preparedTrigger = isRoom2 && historyLimit > 0 ? roomHistoryTracker.prepareTrigger(_route2.agentId, roomId, historyLimit, {
-          sender: senderName2,
-          body: bodyText2,
-          timestamp: eventTs ?? void 0,
-          messageId: _messageId2
-        }) : void 0;
-        const inboundHistory2 = preparedTrigger?.history;
-        const triggerSnapshot2 = preparedTrigger;
-        return {
-          route: _route2,
-          hasExplicitSessionBinding: hasExplicitSessionBinding2,
-          roomConfig: roomConfig2,
-          isDirectMessage: isDirectMessage2,
-          isRoom: isRoom2,
-          shouldRequireMention: shouldRequireMention2,
-          wasMentioned: wasMentioned2,
-          shouldBypassMention: shouldBypassMention2,
-          canDetectMention: canDetectMention2,
-          commandAuthorized: commandAuthorized2,
-          inboundHistory: inboundHistory2,
-          senderName: senderName2,
-          bodyText: bodyText2,
-          media: media2,
-          locationPayload: locationPayload2,
-          messageId: _messageId2,
-          triggerSnapshot: triggerSnapshot2,
-          threadRootId: _threadRootId2,
-          thread: thread2,
-          effectiveGroupAllowFrom: effectiveGroupAllowFrom2,
-          effectiveRoomUsers: effectiveRoomUsers2
-        };
-      };
-      const ingressResult = historyLimit > 0 ? await runRoomIngress(roomId, async () => {
-        const prefix = await readIngressPrefix();
-        if (!prefix) {
-          return void 0;
-        }
-        if (prefix.isDirectMessage) {
-          return { deferredPrefix: prefix };
-        }
-        return { ingressResult: await continueIngress(prefix) };
-      }) : void 0;
-      const resolvedIngressResult = historyLimit > 0 ? ingressResult?.deferredPrefix ? await continueIngress(ingressResult.deferredPrefix) : ingressResult?.ingressResult : await (async () => {
-        const prefix = await readIngressPrefix();
-        if (!prefix) {
-          return void 0;
-        }
-        return await continueIngress(prefix);
-      })();
-      if (!resolvedIngressResult) {
-        return;
-      }
-      const {
-        route: _route,
-        hasExplicitSessionBinding,
-        roomConfig,
-        isDirectMessage,
-        isRoom,
-        shouldRequireMention,
-        wasMentioned,
-        shouldBypassMention,
-        canDetectMention,
-        commandAuthorized,
-        inboundHistory,
-        senderName,
-        bodyText,
-        media,
-        locationPayload,
-        messageId: _messageId,
-        triggerSnapshot,
-        threadRootId: _threadRootId,
-        thread,
-        effectiveGroupAllowFrom,
-        effectiveRoomUsers
-      } = resolvedIngressResult;
-      const replyToEventId = resolveMatrixReplyToEventId(event.content);
-      const threadTarget = thread.threadId;
-      const isRoomContextSenderAllowed = (contextSenderId) => {
-        if (!isRoom || !contextSenderId) {
-          return true;
-        }
-        if (effectiveRoomUsers.length > 0) {
-          return resolveMatrixAllowListMatch({
-            allowList: effectiveRoomUsers,
-            userId: contextSenderId
-          }).allowed;
-        }
-        if (groupPolicy === "allowlist" && effectiveGroupAllowFrom.length > 0) {
-          return resolveMatrixAllowListMatch({
-            allowList: effectiveGroupAllowFrom,
-            userId: contextSenderId
-          }).allowed;
-        }
-        return true;
-      };
-      const shouldIncludeRoomContextSender = (kind, contextSenderId) => evaluateSupplementalContextVisibility({
-        mode: contextVisibilityMode,
-        kind,
-        senderAllowed: isRoomContextSenderAllowed(contextSenderId)
-      }).include;
-      let threadContext = _threadRootId ? await resolveThreadContext({ roomId, threadRootId: _threadRootId }) : void 0;
-      let threadContextBlockedByPolicy = false;
-      if (threadContext?.senderId && !shouldIncludeRoomContextSender("thread", threadContext.senderId)) {
-        logVerboseMessage(`matrix: drop thread root context (mode=${contextVisibilityMode})`);
-        threadContextBlockedByPolicy = true;
-        threadContext = void 0;
-      }
-      let replyContext;
-      if (replyToEventId && replyToEventId === _threadRootId && threadContext?.summary) {
-        replyContext = {
-          replyToBody: threadContext.summary,
-          replyToSender: threadContext.senderLabel,
-          replyToSenderId: threadContext.senderId
-        };
-      } else if (replyToEventId && replyToEventId === _threadRootId && threadContextBlockedByPolicy) {
-        replyContext = await resolveReplyContext({ roomId, eventId: replyToEventId });
-      } else {
-        replyContext = replyToEventId ? await resolveReplyContext({ roomId, eventId: replyToEventId }) : void 0;
-      }
-      if (replyContext?.replyToSenderId && !shouldIncludeRoomContextSender("quote", replyContext.replyToSenderId)) {
-        logVerboseMessage(`matrix: drop reply context (mode=${contextVisibilityMode})`);
-        replyContext = void 0;
-      }
-      const roomInfo = isRoom ? await getRoomInfo(roomId) : void 0;
-      const roomName = roomInfo?.name;
-      const envelopeFrom = isDirectMessage ? senderName : roomName ?? roomId;
-      const textWithId = `${bodyText}
-[matrix event id: ${_messageId} room: ${roomId}]`;
-      const storePath = core.channel.session.resolveStorePath(cfg.session?.store, {
-        agentId: _route.agentId
-      });
-      const envelopeOptions = core.channel.reply.resolveEnvelopeFormatOptions(cfg);
-      const previousTimestamp = core.channel.session.readSessionUpdatedAt({
-        storePath,
-        sessionKey: _route.sessionKey
-      });
-      const sharedDmNoticeSessionKey = threadTarget ? _route.mainSessionKey || _route.sessionKey : _route.sessionKey;
-      const sharedDmContextNotice = isDirectMessage ? hasExplicitSessionBinding ? null : resolveMatrixSharedDmContextNotice({
-        storePath,
-        sessionKey: sharedDmNoticeSessionKey,
-        roomId,
-        accountId: _route.accountId,
-        dmSessionScope,
-        sentRooms: sharedDmContextNoticeRooms,
-        logVerboseMessage
-      }) : null;
-      const body = core.channel.reply.formatAgentEnvelope({
-        channel: "Matrix",
-        from: envelopeFrom,
-        timestamp: eventTs ?? void 0,
-        previousTimestamp,
-        envelope: envelopeOptions,
-        body: textWithId
-      });
-      const groupSystemPrompt = normalizeOptionalString(roomConfig?.systemPrompt);
-      const ctxPayload = core.channel.reply.finalizeInboundContext({
-        Body: body,
-        RawBody: bodyText,
-        CommandBody: bodyText,
-        InboundHistory: inboundHistory && inboundHistory.length > 0 ? inboundHistory : void 0,
-        From: isDirectMessage ? `matrix:${senderId}` : `matrix:channel:${roomId}`,
-        To: `room:${roomId}`,
-        SessionKey: _route.sessionKey,
-        AccountId: _route.accountId,
-        ChatType: isDirectMessage ? "direct" : "channel",
-        ConversationLabel: envelopeFrom,
-        SenderName: senderName,
-        SenderId: senderId,
-        SenderUsername: senderId.split(":")[0]?.replace(/^@/, ""),
-        GroupSubject: isRoom ? roomName ?? roomId : void 0,
-        GroupId: isRoom ? roomId : void 0,
-        GroupSystemPrompt: isRoom ? groupSystemPrompt : void 0,
-        Provider: "matrix",
-        Surface: "matrix",
-        WasMentioned: isRoom ? wasMentioned : void 0,
-        MessageSid: _messageId,
-        ReplyToId: threadTarget ? void 0 : replyToEventId ?? void 0,
-        ReplyToBody: replyContext?.replyToBody,
-        ReplyToSender: replyContext?.replyToSender,
-        MessageThreadId: threadTarget,
-        ThreadStarterBody: threadContext?.threadStarterBody,
-        Timestamp: eventTs ?? void 0,
-        MediaPath: media?.path,
-        MediaType: media?.contentType,
-        MediaUrl: media?.path,
-        ...locationPayload?.context,
-        CommandAuthorized: commandAuthorized,
-        CommandSource: "text",
-        NativeChannelId: roomId,
-        NativeDirectUserId: isDirectMessage ? senderId : void 0,
-        OriginatingChannel: "matrix",
-        OriginatingTo: `room:${roomId}`
-      });
-      await core.channel.session.recordInboundSession({
-        storePath,
-        sessionKey: ctxPayload.SessionKey ?? _route.sessionKey,
-        ctx: ctxPayload,
-        updateLastRoute: isDirectMessage ? {
-          sessionKey: _route.mainSessionKey,
-          channel: "matrix",
-          to: `room:${roomId}`,
-          accountId: _route.accountId
-        } : void 0,
-        onRecordError: (err) => {
-          logger.warn("failed updating session meta", {
-            error: String(err),
-            storePath,
-            sessionKey: ctxPayload.SessionKey ?? _route.sessionKey
-          });
-        }
-      });
-      if (sharedDmContextNotice && markTrackedRoomIfFirst(sharedDmContextNoticeRooms, roomId)) {
-        client.sendMessage(roomId, {
-          msgtype: "m.notice",
-          body: sharedDmContextNotice
-        }).catch((err) => {
-          logVerboseMessage(
-            `matrix: failed sending shared DM session notice room=${roomId}: ${String(err)}`
-          );
-        });
-      }
-      const preview = bodyText.slice(0, 200).replace(/\n/g, "\\n");
-      logVerboseMessage(`matrix inbound: room=${roomId} from=${senderId} preview="${preview}"`);
-      const replyTarget = ctxPayload.To;
-      if (!replyTarget) {
-        runtime.error?.("matrix: missing reply target");
-        return;
-      }
-      const { ackReaction, ackReactionScope: ackScope } = resolveMatrixAckReactionConfig({
-        cfg,
-        agentId: _route.agentId,
-        accountId
-      });
-      const shouldAckReaction = () => Boolean(
-        ackReaction && core.channel.reactions.shouldAckReaction({
-          scope: ackScope,
-          isDirect: isDirectMessage,
-          isGroup: isRoom,
-          isMentionableGroup: isRoom,
-          requireMention: shouldRequireMention,
-          canDetectMention,
-          effectiveWasMentioned: wasMentioned || shouldBypassMention,
-          shouldBypassMention
-        })
-      );
-      if (shouldAckReaction() && _messageId) {
-        reactMatrixMessage(roomId, _messageId, ackReaction, client).catch((err) => {
-          logVerboseMessage(`matrix react failed for room ${roomId}: ${String(err)}`);
-        });
-      }
-      if (_messageId) {
-        sendReadReceiptMatrix(roomId, _messageId, client).catch((err) => {
-          logVerboseMessage(
-            `matrix: read receipt failed room=${roomId} id=${_messageId}: ${String(err)}`
-          );
-        });
-      }
-      const tableMode = core.channel.text.resolveMarkdownTableMode({
-        cfg,
-        channel: "matrix",
-        accountId: _route.accountId
-      });
-      const mediaLocalRoots = getAgentScopedMediaLocalRoots(cfg, _route.agentId);
-      let finalReplyDeliveryFailed = false;
-      let nonFinalReplyDeliveryFailed = false;
-      const { onModelSelected, ...prefixOptions } = createReplyPrefixOptions({
-        cfg,
-        agentId: _route.agentId,
-        channel: "matrix",
-        accountId: _route.accountId
-      });
-      const typingCallbacks = createTypingCallbacks({
-        start: () => sendTypingMatrix(roomId, true, void 0, client),
-        stop: () => sendTypingMatrix(roomId, false, void 0, client),
-        onStartError: (err) => {
-          logTypingFailure({
-            log: logVerboseMessage,
-            channel: "matrix",
-            action: "start",
-            target: roomId,
-            error: err
-          });
-        },
-        onStopError: (err) => {
-          logTypingFailure({
-            log: logVerboseMessage,
-            channel: "matrix",
-            action: "stop",
-            target: roomId,
-            error: err
-          });
-        }
-      });
-      const draftStreamingEnabled = streaming !== "off";
-      const quietDraftStreaming = streaming === "quiet";
-      const draftReplyToId = replyToMode !== "off" && !threadTarget ? _messageId : void 0;
-      const draftStream = draftStreamingEnabled ? createMatrixDraftStream({
-        roomId,
-        client,
-        cfg,
-        mode: quietDraftStreaming ? "quiet" : "partial",
-        threadId: threadTarget,
-        replyToId: draftReplyToId,
-        preserveReplyId: replyToMode === "all",
-        accountId: _route.accountId,
-        log: logVerboseMessage
-      }) : void 0;
-      draftStreamRef = draftStream;
-      let currentDraftMessageGeneration = 0;
-      let currentDraftBlockOffset = 0;
-      let latestDraftFullText = "";
-      const pendingDraftBoundaries = [];
-      const latestQueuedDraftBoundaryOffsets = /* @__PURE__ */ new Map();
-      let currentDraftReplyToId = draftReplyToId;
-      const getDisplayableDraftText = () => {
-        const nextDraftBoundaryOffset = pendingDraftBoundaries.find(
-          (boundary) => boundary.messageGeneration === currentDraftMessageGeneration
-        )?.endOffset;
-        if (nextDraftBoundaryOffset === void 0) {
-          return latestDraftFullText.slice(currentDraftBlockOffset);
-        }
-        return latestDraftFullText.slice(currentDraftBlockOffset, nextDraftBoundaryOffset);
-      };
-      const updateDraftFromLatestFullText = () => {
-        const blockText = getDisplayableDraftText();
-        if (blockText) {
-          draftStream?.update(blockText);
-        }
-      };
-      const queueDraftBlockBoundary = (payload, context) => {
-        const payloadTextLength = payload.text?.length ?? 0;
-        const messageGeneration = context?.assistantMessageIndex ?? currentDraftMessageGeneration;
-        const lastQueuedDraftBoundaryOffset = latestQueuedDraftBoundaryOffsets.get(messageGeneration) ?? 0;
-        const nextDraftBoundaryOffset = lastQueuedDraftBoundaryOffset + payloadTextLength;
-        latestQueuedDraftBoundaryOffsets.set(messageGeneration, nextDraftBoundaryOffset);
-        pendingDraftBoundaries.push({
-          messageGeneration,
-          endOffset: nextDraftBoundaryOffset
-        });
-      };
-      const advanceDraftBlockBoundary = (options) => {
-        const completedBoundary = pendingDraftBoundaries.shift();
-        if (completedBoundary) {
-          if (!pendingDraftBoundaries.some(
-            (entry) => entry.messageGeneration === completedBoundary.messageGeneration
-          )) {
-            latestQueuedDraftBoundaryOffsets.delete(completedBoundary.messageGeneration);
-          }
-          if (completedBoundary.messageGeneration === currentDraftMessageGeneration) {
-            currentDraftBlockOffset = completedBoundary.endOffset;
-          }
-          return;
-        }
-        if (options?.fallbackToLatestEnd) {
-          currentDraftBlockOffset = latestDraftFullText.length;
-        }
-      };
-      const resetDraftBlockOffsets = () => {
-        currentDraftMessageGeneration += 1;
-        currentDraftBlockOffset = 0;
-        latestDraftFullText = "";
-      };
-      const { dispatcher, replyOptions, markDispatchIdle, markRunComplete } = core.channel.reply.createReplyDispatcherWithTyping({
-        ...prefixOptions,
-        humanDelay: core.channel.reply.resolveHumanDelayConfig(cfg, _route.agentId),
-        deliver: async (payload, info) => {
-          if (draftStream && info.kind !== "tool" && !payload.isCompactionNotice) {
-            const hasMedia = Boolean(payload.mediaUrl) || (payload.mediaUrls?.length ?? 0) > 0;
-            await draftStream.stop();
-            const draftEventId = draftStream.eventId();
-            if (draftConsumed) {
-              await deliverMatrixReplies({
-                cfg,
-                replies: [payload],
-                roomId,
-                client,
-                runtime,
-                textLimit,
-                replyToMode,
-                threadId: threadTarget,
-                accountId: _route.accountId,
-                mediaLocalRoots,
-                tableMode
-              });
-              return;
-            }
-            const payloadReplyToId = normalizeOptionalString(payload.replyToId);
-            const payloadReplyMismatch = replyToMode !== "off" && !threadTarget && payloadReplyToId !== currentDraftReplyToId;
-            const mustDeliverFinalNormally = draftStream.mustDeliverFinalNormally();
-            if (draftEventId && payload.text && !hasMedia && !payloadReplyMismatch && !mustDeliverFinalNormally) {
-              try {
-                const requiresFinalEdit = quietDraftStreaming || !draftStream.matchesPreparedText(payload.text);
-                if (requiresFinalEdit) {
-                  await editMessageMatrix(roomId, draftEventId, payload.text, {
-                    client,
-                    cfg,
-                    threadId: threadTarget,
-                    accountId: _route.accountId,
-                    extraContent: quietDraftStreaming ? buildMatrixFinalizedPreviewContent() : void 0
-                  });
-                } else if (!await draftStream.finalizeLive()) {
-                  throw new Error("Matrix draft live finalize failed");
-                }
-              } catch {
-                await redactMatrixDraftEvent(client, roomId, draftEventId);
-                await deliverMatrixReplies({
-                  cfg,
-                  replies: [payload],
-                  roomId,
-                  client,
-                  runtime,
-                  textLimit,
-                  replyToMode,
-                  threadId: threadTarget,
-                  accountId: _route.accountId,
-                  mediaLocalRoots,
-                  tableMode
-                });
-              }
-              draftConsumed = true;
-            } else if (draftEventId && hasMedia && !payloadReplyMismatch) {
-              let textEditOk = !mustDeliverFinalNormally;
-              const payloadText = payload.text;
-              const payloadTextMatchesDraft = typeof payloadText === "string" && draftStream.matchesPreparedText(payloadText);
-              const reusesDraftTextUnchanged = typeof payloadText === "string" && Boolean(payloadText.trim()) && payloadTextMatchesDraft;
-              const requiresFinalTextEdit = quietDraftStreaming || typeof payloadText === "string" && !payloadTextMatchesDraft;
-              if (textEditOk && payloadText && requiresFinalTextEdit) {
-                textEditOk = await editMessageMatrix(roomId, draftEventId, payloadText, {
-                  client,
-                  cfg,
-                  threadId: threadTarget,
-                  accountId: _route.accountId,
-                  extraContent: quietDraftStreaming ? buildMatrixFinalizedPreviewContent() : void 0
-                }).then(
-                  () => true,
-                  () => false
-                );
-              } else if (textEditOk && reusesDraftTextUnchanged) {
-                textEditOk = await draftStream.finalizeLive();
-              }
-              const reusesDraftAsFinalText = Boolean(payload.text?.trim()) && textEditOk;
-              if (!reusesDraftAsFinalText) {
-                await redactMatrixDraftEvent(client, roomId, draftEventId);
-              }
-              await deliverMatrixReplies({
-                cfg,
-                replies: [
-                  { ...payload, text: reusesDraftAsFinalText ? void 0 : payload.text }
-                ],
-                roomId,
-                client,
-                runtime,
-                textLimit,
-                replyToMode,
-                threadId: threadTarget,
-                accountId: _route.accountId,
-                mediaLocalRoots,
-                tableMode
-              });
-              draftConsumed = true;
-            } else {
-              const draftRedacted = Boolean(draftEventId) && (payloadReplyMismatch || mustDeliverFinalNormally);
-              if (draftRedacted && draftEventId) {
-                await redactMatrixDraftEvent(client, roomId, draftEventId);
-              }
-              const deliveredFallback = await deliverMatrixReplies({
-                cfg,
-                replies: [payload],
-                roomId,
-                client,
-                runtime,
-                textLimit,
-                replyToMode,
-                threadId: threadTarget,
-                accountId: _route.accountId,
-                mediaLocalRoots,
-                tableMode
-              });
-              if (draftRedacted || deliveredFallback) {
-                draftConsumed = true;
-              }
-            }
-            if (info.kind === "block") {
-              draftConsumed = false;
-              advanceDraftBlockBoundary({ fallbackToLatestEnd: true });
-              draftStream.reset();
-              currentDraftReplyToId = replyToMode === "all" ? draftReplyToId : void 0;
-              updateDraftFromLatestFullText();
-              await sendTypingMatrix(roomId, true, void 0, client).catch(() => {
-              });
-            }
-          } else {
-            await deliverMatrixReplies({
-              cfg,
-              replies: [payload],
-              roomId,
-              client,
-              runtime,
-              textLimit,
-              replyToMode,
-              threadId: threadTarget,
-              accountId: _route.accountId,
-              mediaLocalRoots,
-              tableMode
-            });
-          }
-        },
-        onError: (err, info) => {
-          if (info.kind === "final") {
-            finalReplyDeliveryFailed = true;
-          } else {
-            nonFinalReplyDeliveryFailed = true;
-          }
-          if (info.kind === "block") {
-            advanceDraftBlockBoundary({ fallbackToLatestEnd: true });
-          }
-          runtime.error?.(`matrix ${info.kind} reply failed: ${String(err)}`);
-        },
-        onReplyStart: typingCallbacks.onReplyStart,
-        onIdle: typingCallbacks.onIdle
-      });
-      const { queuedFinal, counts } = await core.channel.reply.withReplyDispatcher({
-        dispatcher,
-        onSettled: () => {
-          markDispatchIdle();
-        },
-        run: async () => {
-          try {
-            return await core.channel.reply.dispatchReplyFromConfig({
-              ctx: ctxPayload,
-              cfg,
-              dispatcher,
-              replyOptions: {
-                ...replyOptions,
-                skillFilter: roomConfig?.skills,
-                // Keep block streaming enabled when explicitly requested, even
-                // with draft previews on. The draft remains the live preview
-                // for the current assistant block, while block deliveries
-                // finalize completed blocks into their own preserved events.
-                disableBlockStreaming: !blockStreamingEnabled,
-                onPartialReply: draftStream ? (payload) => {
-                  latestDraftFullText = payload.text ?? "";
-                  updateDraftFromLatestFullText();
-                } : void 0,
-                onBlockReplyQueued: draftStream ? (payload, context) => {
-                  if (payload.isCompactionNotice === true) {
-                    return;
-                  }
-                  queueDraftBlockBoundary(payload, context);
-                } : void 0,
-                // Reset draft boundary bookkeeping on assistant message
-                // boundaries so post-tool blocks stream from a fresh
-                // cumulative payload (payload.text resets upstream).
-                onAssistantMessageStart: draftStream ? () => {
-                  resetDraftBlockOffsets();
-                } : void 0,
-                onModelSelected
-              }
-            });
-          } finally {
-            markRunComplete();
-          }
-        }
-      });
-      if (finalReplyDeliveryFailed) {
-        logVerboseMessage(
-          `matrix: final reply delivery failed room=${roomId} id=${_messageId}; leaving event uncommitted`
-        );
-        return;
-      }
-      if (!queuedFinal && nonFinalReplyDeliveryFailed) {
-        logVerboseMessage(
-          `matrix: non-final reply delivery failed room=${roomId} id=${_messageId}; leaving event uncommitted`
-        );
-        return;
-      }
-      if (isRoom && triggerSnapshot) {
-        roomHistoryTracker.consumeHistory(_route.agentId, roomId, triggerSnapshot, _messageId);
-      }
-      if (!queuedFinal) {
-        await commitInboundEventIfClaimed();
-        return;
-      }
-      const finalCount = counts.final;
-      logVerboseMessage(
-        `matrix: delivered ${finalCount} reply${finalCount === 1 ? "" : "ies"} to ${replyTarget}`
-      );
-      await commitInboundEventIfClaimed();
-    } catch (err) {
-      runtime.error?.(`matrix handler failed: ${String(err)}`);
-    } finally {
-      if (draftStreamRef) {
-        const draftEventId = await draftStreamRef.stop().catch(() => void 0);
-        if (draftEventId && !draftConsumed) {
-          await redactMatrixDraftEvent(client, roomId, draftEventId);
-        }
-      }
-      if (claimedInboundEvent && inboundDeduper && eventId) {
-        inboundDeduper.releaseEvent({ roomId, eventId });
-      }
-    }
-  };
-}
-
-export {
-  createMatrixRoomMessageHandler
-};
-//# sourceMappingURL=chunk-U4LVIY5F.js.map