@archipelagolab/lobi 1.0.1 → 1.0.6

package/dist/chunk-YWHH3MB6.js

@@ -0,0 +1,1405 @@
+import {
+  createMatrixThreadContextResolver
+} from "./chunk-ZSOPE7DO.js";
+import {
+  deliverMatrixReplies
+} from "./chunk-AUUABFHL.js";
+import {
+  createMatrixReplyContextResolver
+} from "./chunk-SHBAAFFH.js";
+import {
+  createRoomHistoryTracker
+} from "./chunk-TPYWUZOR.js";
+import {
+  resolveMatrixLocation
+} from "./chunk-VPQICZQR.js";
+import {
+  downloadMatrixMedia
+} from "./chunk-SWWK35VQ.js";
+import {
+  resolveMentions
+} from "./chunk-LUGTGPT6.js";
+import {
+  handleInboundMatrixReaction
+} from "./chunk-LMD5UTKM.js";
+import {
+  resolveMatrixInboundRoute
+} from "./chunk-YNHADHHS.js";
+import {
+  resolveMatrixReplyToEventId,
+  resolveMatrixThreadRootId,
+  resolveMatrixThreadRouting
+} from "./chunk-JU2Y33DB.js";
+import {
+  isMatrixVerificationRoomMessage
+} from "./chunk-FK6RGYBB.js";
+import {
+  EventType,
+  RelationType
+} from "./chunk-CPLEC5LJ.js";
+import {
+  resolveMatrixMonitorAccessState
+} from "./chunk-KAWXMSYC.js";
+import {
+  resolveMatrixAckReactionConfig
+} from "./chunk-WS6HWBKT.js";
+import {
+  createMatrixDraftStream
+} from "./chunk-HSXRCP25.js";
+import {
+  fetchMatrixPollSnapshot
+} from "./chunk-FFCG5NRU.js";
+import {
+  formatMatrixMediaTooLargeText,
+  formatMatrixMediaUnavailableText,
+  formatMatrixMessageText,
+  resolveMatrixMessageAttachment,
+  resolveMatrixMessageBody
+} from "./chunk-VBDLTKI2.js";
+import {
+  resolveMatrixStoredSessionMeta
+} from "./chunk-4L2QI6AY.js";
+import {
+  resolveMatrixRoomConfig
+} from "./chunk-F6APWSAA.js";
+import {
+  createReplyPrefixOptions,
+  createTypingCallbacks,
+  ensureConfiguredAcpBindingReady,
+  formatAllowlistMatchMeta,
+  getAgentScopedMediaLocalRoots,
+  logInboundDrop,
+  logTypingFailure
+} from "./chunk-F43CC2X2.js";
+import {
+  formatMatrixErrorMessage
+} from "./chunk-H5MLA6PA.js";
+import {
+  resolveMatrixAllowListMatch
+} from "./chunk-U44IVNP2.js";
+import {
+  editMessageMatrix,
+  reactMatrixMessage,
+  sendMessageMatrix,
+  sendReadReceiptMatrix,
+  sendTypingMatrix
+} from "./chunk-QAR5POXD.js";
+import {
+  MATRIX_OPENCLAW_FINALIZED_PREVIEW_KEY
+} from "./chunk-JGIZPU2Y.js";
+import {
+  formatPollAsText,
+  isPollEventType,
+  isPollStartType,
+  parsePollStartContent
+} from "./chunk-LZQFDJNW.js";
+import {
+  isMatrixMediaSizeLimitError
+} from "./chunk-I7JJQ4BQ.js";
+import {
+  init_shims
+} from "./chunk-G4TIS2SC.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-YWHH3MB6.js.map