@inline-openclaw/inline 0.0.29 → 0.0.30

package/dist/index.js

@@ -34276,6 +34276,10 @@ import {
   parseCommandArgs,
   resolveCommandArgMenu
 } from "openclaw/plugin-sdk/native-command-registry";
+import {
+  createChannelInboundDebouncer,
+  shouldDebounceTextInbound
+} from "openclaw/plugin-sdk/channel-inbound";
 import { resolveDefaultModelForAgent } from "openclaw/plugin-sdk/agent-runtime";
 import { applyModelOverrideToSessionEntry, updateSessionStore } from "openclaw/plugin-sdk/config-runtime";
 import { buildModelsProviderData } from "openclaw/plugin-sdk/models-provider-runtime";
@@ -35219,6 +35223,18 @@ function buildInlineInboundMessageSid(params) {
   }
   return String(params.msgId);
 }
+function buildInlineDebounceKey(params) {
+  if (params.senderId == null)
+    return null;
+  return `inline:${params.accountId}:${String(params.chatId)}:${String(params.senderId)}`;
+}
+function buildSyntheticInlineTextMessage(params) {
+  return {
+    ...params.base,
+    message: params.text,
+    ...params.mentioned !== undefined ? { mentioned: params.mentioned } : {}
+  };
+}
 var INLINE_ACTION_MAX_ROWS = 8;
 var INLINE_ACTION_MAX_PER_ROW = 8;
 function isRecord3(value) {
@@ -36037,1000 +36053,1078 @@ async function monitorInlineProvider(params) {
     participantFetches.set(chatKey, run);
     await run;
   };
-  const loop = (async () => {
+  const handleInboundNow = async (input) => {
+    const chatId = input.chatId;
+    const msg = input.msg;
+    const rawBodyOverride = input.rawBodyOverride ?? null;
+    const reactionEvent = input.reactionEvent ?? null;
+    const callbackActionEvent = input.callbackActionEvent ?? null;
+    let rawBody = "";
+    let currentContent = null;
+    let currentAttachmentText = null;
+    let currentEntityText = null;
+    if (!reactionEvent && !callbackActionEvent) {
+      if (rawBodyOverride != null) {
+        rawBody = rawBodyOverride.trim();
+      } else {
+        currentContent = summarizeInlineMessageContent(msg);
+        rawBody = buildInlineInboundBodyText(currentContent);
+        currentAttachmentText = currentContent.attachmentText || null;
+        currentEntityText = currentContent.entityText || null;
+      }
+      if (!rawBody)
+        return;
+    }
+    statusSink?.({ lastInboundAt: Date.now() });
+    let chatInfo;
     try {
-      for await (const event of client.events()) {
-        if (abortSignal.aborted)
-          break;
-        const rawEvent = event;
-        let msg;
-        let rawBody = "";
-        let currentContent = null;
-        let currentAttachmentText = null;
-        let currentEntityText = null;
-        let reactionEvent = null;
-        let inboundChatId = null;
-        let callbackActionEvent = null;
-        if (event.kind === "message.new") {
-          inboundChatId = event.chatId;
-          msg = {
-            ...event.message,
-            chatId: event.chatId
-          };
-          currentContent = summarizeInlineMessageContent(msg);
-          rawBody = buildInlineInboundBodyText(currentContent);
-          currentAttachmentText = currentContent.attachmentText || null;
-          currentEntityText = currentContent.entityText || null;
-          if (!rawBody)
-            continue;
-          if (msg.out || msg.fromId === meId)
-            continue;
-        } else if (event.kind === "reaction.add") {
-          inboundChatId = event.chatId;
-          if (event.reaction.userId === meId)
-            continue;
-          const onBotMessage = await isReactionTargetBotMessage({
-            client,
-            chatId: event.chatId,
-            messageId: event.reaction.messageId,
-            meId,
-            botMessageIdsByChat
-          }).catch((err) => {
-            statusSink?.({ lastError: `getChatHistory (reaction target) failed: ${String(err)}` });
-            return false;
-          });
-          if (!onBotMessage)
-            continue;
-          reactionEvent = {
-            action: "added",
-            emoji: event.reaction.emoji,
-            targetMessageId: event.reaction.messageId
-          };
-          msg = {
-            id: event.reaction.messageId,
-            chatId: event.chatId,
-            date: event.date,
-            fromId: event.reaction.userId,
-            message: "",
-            out: false,
-            mentioned: false,
-            replyToMsgId: event.reaction.messageId
-          };
-        } else if (event.kind === "reaction.delete") {
-          inboundChatId = event.chatId;
-          if (event.userId === meId)
-            continue;
-          const onBotMessage = await isReactionTargetBotMessage({
-            client,
-            chatId: event.chatId,
-            messageId: event.messageId,
-            meId,
-            botMessageIdsByChat
-          }).catch((err) => {
-            statusSink?.({ lastError: `getChatHistory (reaction target) failed: ${String(err)}` });
-            return false;
-          });
-          if (!onBotMessage)
-            continue;
-          reactionEvent = {
-            action: "removed",
-            emoji: event.emoji,
-            targetMessageId: event.messageId
-          };
-          msg = {
-            id: event.messageId,
-            chatId: event.chatId,
-            date: event.date,
-            fromId: event.userId,
-            message: "",
-            out: false,
-            mentioned: false,
-            replyToMsgId: event.messageId
-          };
-        } else if (rawEvent["kind"] === "message.action.invoke") {
-          const actorUserId = rawEvent["actorUserId"];
-          const interactionId = rawEvent["interactionId"];
-          const actionId = rawEvent["actionId"];
-          const targetMessageId = rawEvent["messageId"];
-          const data = rawEvent["data"];
-          const eventChatId = rawEvent["chatId"];
-          const eventDate = rawEvent["date"];
-          if (!actorUserId || !interactionId || !actionId || !targetMessageId || !eventChatId || !eventDate || !data) {
-            continue;
-          }
-          inboundChatId = eventChatId;
-          if (actorUserId === meId)
-            continue;
-          callbackActionEvent = {
-            interactionId,
-            actionId,
-            targetMessageId,
-            data
-          };
-          msg = {
-            id: targetMessageId,
-            chatId: eventChatId,
-            date: eventDate,
-            fromId: actorUserId,
-            message: "",
-            out: false,
-            mentioned: false,
-            replyToMsgId: targetMessageId
-          };
-        } else {
-          continue;
-        }
-        if (!inboundChatId)
-          continue;
-        const chatId = inboundChatId;
-        statusSink?.({ lastInboundAt: Date.now() });
-        let chatInfo;
-        try {
-          chatInfo = await resolveChatInfo(client, chatCache, chatId);
-        } catch (err) {
-          chatInfo = { kind: "group", title: null };
-          statusSink?.({ lastError: `getChat failed: ${String(err)}` });
-        }
-        const isGroup = chatInfo.kind !== "direct";
-        const replyThreadsEnabled = account.config.capabilities?.replyThreads === true || isInlineReplyThreadsEnabled({ cfg, accountId: account.accountId });
-        const replyThreadContext = await resolveInlineInboundReplyThreadContext({
-          replyThreadsEnabled,
-          client,
-          chatId,
-          chatInfo,
-          chatCache
-        }).catch((err) => {
-          statusSink?.({ lastError: `getChat (reply thread) failed: ${String(err)}` });
-          return null;
-        });
-        const effectiveChatId = replyThreadContext?.parentChatId ?? chatId;
-        const effectiveGroupTitle = replyThreadContext?.parentChatTitle ?? chatInfo.title ?? null;
-        const senderId = String(msg.fromId);
-        await hydrateChatParticipants(chatId);
-        const senderProfile = senderProfilesById.get(senderId);
-        const senderUsername = senderProfile?.username;
-        const senderName = senderProfile?.name ?? (!isGroup ? chatInfo.title ?? undefined : undefined);
-        if (reactionEvent) {
-          const actor = senderUsername != null && senderUsername.length > 0 ? `@${senderUsername}` : senderName ?? `user:${senderId}`;
-          const emoji3 = reactionEvent.emoji.trim() || "a reaction";
-          const messageId = String(reactionEvent.targetMessageId);
-          if (reactionEvent.action === "added") {
-            rawBody = `${actor} reacted with ${emoji3} to your message #${messageId}`;
-          } else {
-            rawBody = `${actor} removed ${emoji3} from your message #${messageId}`;
-          }
-        } else if (callbackActionEvent) {
-          const actor = senderUsername != null && senderUsername.length > 0 ? `@${senderUsername}` : senderName ?? `user:${senderId}`;
-          const payload = {
-            type: "inline_message_action_callback",
-            interaction_id: String(callbackActionEvent.interactionId),
-            actor_user_id: senderId,
-            chat_id: String(chatId),
-            message_id: String(callbackActionEvent.targetMessageId),
-            action_id: callbackActionEvent.actionId,
-            data_base64: callbackDataToBase64(callbackActionEvent.data),
-            data_utf8: callbackDataToUtf8(callbackActionEvent.data) ?? null
-          };
-          rawBody = `${actor} pressed a button on message #${String(callbackActionEvent.targetMessageId)}
+      chatInfo = await resolveChatInfo(client, chatCache, chatId);
+    } catch (err) {
+      chatInfo = { kind: "group", title: null };
+      statusSink?.({ lastError: `getChat failed: ${String(err)}` });
+    }
+    const isGroup = chatInfo.kind !== "direct";
+    const replyThreadsEnabled = account.config.capabilities?.replyThreads === true || isInlineReplyThreadsEnabled({ cfg, accountId: account.accountId });
+    const replyThreadContext = await resolveInlineInboundReplyThreadContext({
+      replyThreadsEnabled,
+      client,
+      chatId,
+      chatInfo,
+      chatCache
+    }).catch((err) => {
+      statusSink?.({ lastError: `getChat (reply thread) failed: ${String(err)}` });
+      return null;
+    });
+    const effectiveChatId = replyThreadContext?.parentChatId ?? chatId;
+    const effectiveGroupTitle = replyThreadContext?.parentChatTitle ?? chatInfo.title ?? null;
+    const senderId = String(msg.fromId);
+    await hydrateChatParticipants(chatId);
+    const senderProfile = senderProfilesById.get(senderId);
+    const senderUsername = senderProfile?.username;
+    const senderName = senderProfile?.name ?? (!isGroup ? chatInfo.title ?? undefined : undefined);
+    if (reactionEvent) {
+      const actor = senderUsername != null && senderUsername.length > 0 ? `@${senderUsername}` : senderName ?? `user:${senderId}`;
+      const emoji3 = reactionEvent.emoji.trim() || "a reaction";
+      const messageId = String(reactionEvent.targetMessageId);
+      if (reactionEvent.action === "added") {
+        rawBody = `${actor} reacted with ${emoji3} to your message #${messageId}`;
+      } else {
+        rawBody = `${actor} removed ${emoji3} from your message #${messageId}`;
+      }
+    } else if (callbackActionEvent) {
+      const actor = senderUsername != null && senderUsername.length > 0 ? `@${senderUsername}` : senderName ?? `user:${senderId}`;
+      const payload = {
+        type: "inline_message_action_callback",
+        interaction_id: String(callbackActionEvent.interactionId),
+        actor_user_id: senderId,
+        chat_id: String(chatId),
+        message_id: String(callbackActionEvent.targetMessageId),
+        action_id: callbackActionEvent.actionId,
+        data_base64: callbackDataToBase64(callbackActionEvent.data),
+        data_utf8: callbackDataToUtf8(callbackActionEvent.data) ?? null
+      };
+      rawBody = `${actor} pressed a button on message #${String(callbackActionEvent.targetMessageId)}
 ${JSON.stringify(payload)}`;
-        }
-        const dmPolicy = account.config.dmPolicy ?? "pairing";
-        const defaultGroupPolicy = cfg.channels?.defaults?.groupPolicy;
-        const groupPolicy = account.config.groupPolicy ?? defaultGroupPolicy ?? "allowlist";
-        const configAllowFrom = normalizeAllowlist(account.config.allowFrom);
-        const configGroupAllowFrom = normalizeAllowlist(account.config.groupAllowFrom);
-        const storeAllowFrom = await core3.channel.pairing.readAllowFromStore({
-          channel: CHANNEL_ID,
-          accountId: account.accountId
-        }).catch(() => []);
-        const storeAllowList = normalizeAllowlist(storeAllowFrom);
-        const effectiveAllowFrom = [...configAllowFrom, ...storeAllowList].filter(Boolean);
-        const effectiveGroupAllowFrom = [
-          ...configGroupAllowFrom.length > 0 ? configGroupAllowFrom : configAllowFrom,
-          ...storeAllowList
-        ].filter(Boolean);
-        const callbackCommandBody = callbackActionEvent ? resolveCallbackCommandBodyFromActionData({
-          data: callbackActionEvent.data,
-          ...botUsername ? { botUsername } : {}
-        }) : undefined;
-        let callbackActionAnswered = false;
-        const answerCallbackIfNeeded = async () => {
-          if (!callbackActionEvent || callbackActionAnswered)
-            return;
-          await answerInlineMessageAction(client, callbackActionEvent.interactionId);
-          callbackActionAnswered = true;
-        };
-        if (callbackActionEvent) {
+    }
+    const dmPolicy = account.config.dmPolicy ?? "pairing";
+    const defaultGroupPolicy = cfg.channels?.defaults?.groupPolicy;
+    const groupPolicy = account.config.groupPolicy ?? defaultGroupPolicy ?? "allowlist";
+    const configAllowFrom = normalizeAllowlist(account.config.allowFrom);
+    const configGroupAllowFrom = normalizeAllowlist(account.config.groupAllowFrom);
+    const storeAllowFrom = await core3.channel.pairing.readAllowFromStore({
+      channel: CHANNEL_ID,
+      accountId: account.accountId
+    }).catch(() => []);
+    const storeAllowList = normalizeAllowlist(storeAllowFrom);
+    const effectiveAllowFrom = [...configAllowFrom, ...storeAllowList].filter(Boolean);
+    const effectiveGroupAllowFrom = [
+      ...configGroupAllowFrom.length > 0 ? configGroupAllowFrom : configAllowFrom,
+      ...storeAllowList
+    ].filter(Boolean);
+    const callbackCommandBody = callbackActionEvent ? resolveCallbackCommandBodyFromActionData({
+      data: callbackActionEvent.data,
+      ...botUsername ? { botUsername } : {}
+    }) : undefined;
+    let callbackActionAnswered = false;
+    const answerCallbackIfNeeded = async () => {
+      if (!callbackActionEvent || callbackActionAnswered)
+        return;
+      await answerInlineMessageAction(client, callbackActionEvent.interactionId);
+      callbackActionAnswered = true;
+    };
+    if (callbackActionEvent) {
+      await answerCallbackIfNeeded().catch((error48) => {
+        runtime2.error?.(`inline callback answer failed: ${String(error48)}`);
+      });
+    }
+    const shouldEditCallbackTargetInPlace = callbackActionEvent != null;
+    const normalizedCommandBody = callbackCommandBody ?? normalizeInlineCommandBody(rawBody, botUsername);
+    const allowTextCommands = core3.channel.commands.shouldHandleTextCommands({
+      cfg,
+      surface: CHANNEL_ID
+    });
+    const useAccessGroups = cfg.commands?.useAccessGroups !== false;
+    const allowForCommands = isGroup ? effectiveGroupAllowFrom : effectiveAllowFrom;
+    const senderAllowedForCommands = allowlistMatch({ allowFrom: allowForCommands, senderId });
+    const hasControlCommand = core3.channel.text.hasControlCommand(callbackCommandBody ?? rawBody, cfg, botUsername ? { botUsername } : undefined);
+    const commandGate = resolveControlCommandGate({
+      useAccessGroups,
+      authorizers: [{ configured: allowForCommands.length > 0, allowed: senderAllowedForCommands }],
+      allowTextCommands,
+      hasControlCommand
+    });
+    const commandAuthorized = commandGate.commandAuthorized;
+    if (isGroup) {
+      if (groupPolicy === "disabled") {
+        log?.info(`[${account.accountId}] inline: drop group chat=${String(chatId)} (groupPolicy=disabled)`);
+        await answerCallbackIfNeeded().catch((error48) => {
+          runtime2.error?.(`inline callback answer failed: ${String(error48)}`);
+        });
+        return;
+      }
+      if (groupPolicy === "allowlist") {
+        const allowed = allowlistMatch({ allowFrom: effectiveGroupAllowFrom, senderId });
+        if (!allowed) {
+          log?.info(`[${account.accountId}] inline: drop group sender=${senderId} (groupPolicy=allowlist)`);
           await answerCallbackIfNeeded().catch((error48) => {
             runtime2.error?.(`inline callback answer failed: ${String(error48)}`);
           });
+          return;
         }
-        const shouldEditCallbackTargetInPlace = callbackActionEvent != null;
-        const normalizedCommandBody = callbackCommandBody ?? normalizeInlineCommandBody(rawBody, botUsername);
-        const allowTextCommands = core3.channel.commands.shouldHandleTextCommands({
-          cfg,
-          surface: CHANNEL_ID
-        });
-        const useAccessGroups = cfg.commands?.useAccessGroups !== false;
-        const allowForCommands = isGroup ? effectiveGroupAllowFrom : effectiveAllowFrom;
-        const senderAllowedForCommands = allowlistMatch({ allowFrom: allowForCommands, senderId });
-        const hasControlCommand = core3.channel.text.hasControlCommand(callbackCommandBody ?? rawBody, cfg, botUsername ? { botUsername } : undefined);
-        const commandGate = resolveControlCommandGate({
-          useAccessGroups,
-          authorizers: [{ configured: allowForCommands.length > 0, allowed: senderAllowedForCommands }],
-          allowTextCommands,
-          hasControlCommand
+      }
+    } else {
+      if (dmPolicy === "disabled") {
+        log?.info(`[${account.accountId}] inline: drop DM sender=${senderId} (dmPolicy=disabled)`);
+        await answerCallbackIfNeeded().catch((error48) => {
+          runtime2.error?.(`inline callback answer failed: ${String(error48)}`);
         });
-        const commandAuthorized = commandGate.commandAuthorized;
-        if (isGroup) {
-          if (groupPolicy === "disabled") {
-            log?.info(`[${account.accountId}] inline: drop group chat=${String(chatId)} (groupPolicy=disabled)`);
-            await answerCallbackIfNeeded().catch((error48) => {
-              runtime2.error?.(`inline callback answer failed: ${String(error48)}`);
-            });
-            continue;
-          }
-          if (groupPolicy === "allowlist") {
-            const allowed = allowlistMatch({ allowFrom: effectiveGroupAllowFrom, senderId });
-            if (!allowed) {
-              log?.info(`[${account.accountId}] inline: drop group sender=${senderId} (groupPolicy=allowlist)`);
-              await answerCallbackIfNeeded().catch((error48) => {
-                runtime2.error?.(`inline callback answer failed: ${String(error48)}`);
-              });
-              continue;
-            }
-          }
-        } else {
-          if (dmPolicy === "disabled") {
-            log?.info(`[${account.accountId}] inline: drop DM sender=${senderId} (dmPolicy=disabled)`);
-            await answerCallbackIfNeeded().catch((error48) => {
-              runtime2.error?.(`inline callback answer failed: ${String(error48)}`);
+        return;
+      }
+      if (dmPolicy !== "open") {
+        const allowed = allowlistMatch({ allowFrom: effectiveAllowFrom, senderId });
+        if (!allowed) {
+          if (dmPolicy === "pairing") {
+            const { code, created } = await core3.channel.pairing.upsertPairingRequest({
+              channel: CHANNEL_ID,
+              id: senderId,
+              accountId: account.accountId,
+              meta: {},
+              pairingAdapter: { idLabel: "inlineUserId", normalizeAllowEntry }
             });
-            continue;
-          }
-          if (dmPolicy !== "open") {
-            const allowed = allowlistMatch({ allowFrom: effectiveAllowFrom, senderId });
-            if (!allowed) {
-              if (dmPolicy === "pairing") {
-                const { code, created } = await core3.channel.pairing.upsertPairingRequest({
-                  channel: CHANNEL_ID,
-                  id: senderId,
-                  accountId: account.accountId,
-                  meta: {},
-                  pairingAdapter: { idLabel: "inlineUserId", normalizeAllowEntry }
+            if (created) {
+              try {
+                await client.sendMessage({
+                  chatId,
+                  text: core3.channel.pairing.buildPairingReply({
+                    channel: CHANNEL_ID,
+                    idLine: `Your Inline user id: ${senderId}`,
+                    code
+                  })
                 });
-                if (created) {
-                  try {
-                    await client.sendMessage({
-                      chatId,
-                      text: core3.channel.pairing.buildPairingReply({
-                        channel: CHANNEL_ID,
-                        idLine: `Your Inline user id: ${senderId}`,
-                        code
-                      })
-                    });
-                    statusSink?.({ lastOutboundAt: Date.now() });
-                  } catch (err) {
-                    runtime2.error?.(`inline: pairing reply failed for ${senderId}: ${String(err)}`);
-                  }
-                }
+                statusSink?.({ lastOutboundAt: Date.now() });
+              } catch (err) {
+                runtime2.error?.(`inline: pairing reply failed for ${senderId}: ${String(err)}`);
               }
-              log?.info(`[${account.accountId}] inline: drop DM sender=${senderId} (dmPolicy=${dmPolicy})`);
-              await answerCallbackIfNeeded().catch((error48) => {
-                runtime2.error?.(`inline callback answer failed: ${String(error48)}`);
-              });
-              continue;
             }
           }
-        }
-        if (isGroup && commandGate.shouldBlock) {
-          logInboundDrop({
-            log: (m) => runtime2.log?.(m),
-            channel: CHANNEL_ID,
-            reason: "control command (unauthorized)",
-            target: senderId
-          });
+          log?.info(`[${account.accountId}] inline: drop DM sender=${senderId} (dmPolicy=${dmPolicy})`);
           await answerCallbackIfNeeded().catch((error48) => {
             runtime2.error?.(`inline callback answer failed: ${String(error48)}`);
           });
-          continue;
+          return;
         }
-        const route = core3.channel.routing.resolveAgentRoute({
-          cfg,
-          channel: CHANNEL_ID,
-          accountId: account.accountId,
-          peer: {
-            kind: isGroup ? "group" : "direct",
-            id: isGroup ? String(effectiveChatId) : senderId
+      }
+    }
+    if (isGroup && commandGate.shouldBlock) {
+      logInboundDrop({
+        log: (m) => runtime2.log?.(m),
+        channel: CHANNEL_ID,
+        reason: "control command (unauthorized)",
+        target: senderId
+      });
+      await answerCallbackIfNeeded().catch((error48) => {
+        runtime2.error?.(`inline callback answer failed: ${String(error48)}`);
+      });
+      return;
+    }
+    const route = core3.channel.routing.resolveAgentRoute({
+      cfg,
+      channel: CHANNEL_ID,
+      accountId: account.accountId,
+      peer: {
+        kind: isGroup ? "group" : "direct",
+        id: isGroup ? String(effectiveChatId) : senderId
+      }
+    });
+    const mentionRegexes = core3.channel.mentions.buildMentionRegexes(cfg, route.agentId);
+    const nativeMentioned = typeof msg.mentioned === "boolean" ? msg.mentioned : false;
+    const patternMentioned = mentionRegexes.length ? core3.channel.mentions.matchesMentionPatterns(rawBody, mentionRegexes) : false;
+    const wasMentioned = nativeMentioned || patternMentioned;
+    const messageTimestamp = Number(msg.date) * 1000;
+    const groupHistoryKey = isGroup ? replyThreadContext ? `${route.sessionKey}:thread:${String(replyThreadContext.childChatId)}` : route.sessionKey : null;
+    const pendingHistorySender = senderUsername ? `@${senderUsername}` : senderName ?? `user:${senderId}`;
+    const historyLimit = resolveHistoryLimit({
+      cfg,
+      isGroup,
+      historyLimit: account.config.historyLimit,
+      dmHistoryLimit: account.config.dmHistoryLimit
+    });
+    const historyContext = await buildHistoryContext2({
+      client,
+      chatId,
+      currentMessageId: msg.id,
+      replyToMsgId: msg.replyToMsgId,
+      senderProfilesById,
+      meId,
+      historyLimit,
+      botMessageIdsByChat
+    }).catch((err) => {
+      statusSink?.({ lastError: `getChatHistory failed: ${String(err)}` });
+      return {
+        historyText: null,
+        attachmentText: null,
+        entityText: null,
+        inboundHistory: [],
+        repliedToBot: false,
+        replyToSenderId: null
+      };
+    });
+    const effectiveHistoryContext = replyThreadContext?.anchorMessage != null ? prependInlineReplyThreadAnchor({
+      historyContext,
+      anchorMessage: replyThreadContext.anchorMessage,
+      parentChatId: replyThreadContext.parentChatId,
+      senderProfilesById,
+      meId
+    }) : historyContext;
+    const implicitMention = (reactionEvent != null || callbackActionEvent != null) && isGroup || isGroup && (account.config.replyToBotWithoutMention ?? false) && msg.replyToMsgId != null && effectiveHistoryContext.repliedToBot;
+    const requireMention = isGroup ? resolveInlineGroupRequireMention({
+      cfg,
+      groupId: String(effectiveChatId),
+      accountId: account.accountId,
+      requireMentionDefault: account.config.requireMention ?? false
+    }) : false;
+    const mentionGate = resolveMentionGatingWithBypass({
+      isGroup,
+      requireMention,
+      canDetectMention: typeof msg.mentioned === "boolean" || mentionRegexes.length > 0,
+      wasMentioned,
+      implicitMention,
+      allowTextCommands,
+      hasControlCommand,
+      commandAuthorized
+    });
+    if (isGroup && mentionGate.shouldSkip) {
+      runtime2.log?.(`inline: drop group chat ${String(chatId)} (no mention)`);
+      const pendingBody = normalizeHistoryText(currentContent?.text) ?? normalizeHistoryText(rawBody);
+      recordPendingHistoryEntryIfEnabled({
+        historyMap: groupPendingHistories,
+        historyKey: groupHistoryKey ?? "",
+        limit: historyLimit,
+        entry: groupHistoryKey && pendingBody ? {
+          sender: pendingHistorySender,
+          body: pendingBody,
+          timestamp: messageTimestamp || Date.now(),
+          messageId: String(msg.id)
+        } : null
+      });
+      await answerCallbackIfNeeded().catch((error48) => {
+        runtime2.error?.(`inline callback answer failed: ${String(error48)}`);
+      });
+      return;
+    }
+    const parseMarkdown = account.config.parseMarkdown ?? true;
+    const nativeCommandMenu = resolveInlineNativeCommandMenu({
+      commandBody: normalizedCommandBody,
+      cfg
+    });
+    if (nativeCommandMenu) {
+      const menuActions = resolveInlineReplyActions({
+        channelData: {
+          inline: {
+            buttons: nativeCommandMenu.buttons
           }
-        });
-        const mentionRegexes = core3.channel.mentions.buildMentionRegexes(cfg, route.agentId);
-        const nativeMentioned = typeof msg.mentioned === "boolean" ? msg.mentioned : false;
-        const patternMentioned = mentionRegexes.length ? core3.channel.mentions.matchesMentionPatterns(rawBody, mentionRegexes) : false;
-        const wasMentioned = nativeMentioned || patternMentioned;
-        const messageTimestamp = Number(msg.date) * 1000;
-        const groupHistoryKey = isGroup ? replyThreadContext ? `${route.sessionKey}:thread:${String(replyThreadContext.childChatId)}` : route.sessionKey : null;
-        const pendingHistorySender = senderUsername ? `@${senderUsername}` : senderName ?? `user:${senderId}`;
-        const historyLimit = resolveHistoryLimit({
-          cfg,
-          isGroup,
-          historyLimit: account.config.historyLimit,
-          dmHistoryLimit: account.config.dmHistoryLimit
-        });
-        const historyContext = await buildHistoryContext2({
-          client,
-          chatId,
-          currentMessageId: msg.id,
-          replyToMsgId: msg.replyToMsgId,
-          senderProfilesById,
-          meId,
-          historyLimit,
-          botMessageIdsByChat
-        }).catch((err) => {
-          statusSink?.({ lastError: `getChatHistory failed: ${String(err)}` });
-          return {
-            historyText: null,
-            attachmentText: null,
-            entityText: null,
-            inboundHistory: [],
-            repliedToBot: false,
-            replyToSenderId: null
-          };
-        });
-        const effectiveHistoryContext = replyThreadContext?.anchorMessage != null ? prependInlineReplyThreadAnchor({
-          historyContext,
-          anchorMessage: replyThreadContext.anchorMessage,
-          parentChatId: replyThreadContext.parentChatId,
-          senderProfilesById,
-          meId
-        }) : historyContext;
-        const implicitMention = (reactionEvent != null || callbackActionEvent != null) && isGroup || isGroup && (account.config.replyToBotWithoutMention ?? false) && msg.replyToMsgId != null && effectiveHistoryContext.repliedToBot;
-        const requireMention = isGroup ? resolveInlineGroupRequireMention({
-          cfg,
-          groupId: String(effectiveChatId),
-          accountId: account.accountId,
-          requireMentionDefault: account.config.requireMention ?? false
-        }) : false;
-        const mentionGate = resolveMentionGatingWithBypass({
-          isGroup,
-          requireMention,
-          canDetectMention: typeof msg.mentioned === "boolean" || mentionRegexes.length > 0,
-          wasMentioned,
-          implicitMention,
-          allowTextCommands,
-          hasControlCommand,
-          commandAuthorized
-        });
-        if (isGroup && mentionGate.shouldSkip) {
-          runtime2.log?.(`inline: drop group chat ${String(chatId)} (no mention)`);
-          const pendingBody = normalizeHistoryText(currentContent?.text) ?? normalizeHistoryText(rawBody);
-          recordPendingHistoryEntryIfEnabled({
-            historyMap: groupPendingHistories,
-            historyKey: groupHistoryKey ?? "",
-            limit: historyLimit,
-            entry: groupHistoryKey && pendingBody ? {
-              sender: pendingHistorySender,
-              body: pendingBody,
-              timestamp: messageTimestamp || Date.now(),
-              messageId: String(msg.id)
-            } : null
-          });
-          await answerCallbackIfNeeded().catch((error48) => {
-            runtime2.error?.(`inline callback answer failed: ${String(error48)}`);
-          });
-          continue;
         }
-        const parseMarkdown = account.config.parseMarkdown ?? true;
-        const nativeCommandMenu = resolveInlineNativeCommandMenu({
-          commandBody: normalizedCommandBody,
-          cfg
-        });
-        if (nativeCommandMenu) {
-          const menuActions = resolveInlineReplyActions({
-            channelData: {
-              inline: {
-                buttons: nativeCommandMenu.buttons
-              }
+      });
+      let deliveredNativeMenu = false;
+      if (shouldEditCallbackTargetInPlace && callbackActionEvent) {
+        try {
+          const result = await client.invokeRaw(Method.EDIT_MESSAGE, {
+            oneofKind: "editMessage",
+            editMessage: {
+              messageId: callbackActionEvent.targetMessageId,
+              peerId: buildChatPeer2(chatId),
+              text: nativeCommandMenu.title,
+              ...menuActions ? { actions: menuActions } : {},
+              parseMarkdown
             }
           });
-          let deliveredNativeMenu = false;
-          if (shouldEditCallbackTargetInPlace && callbackActionEvent) {
-            try {
-              const result = await client.invokeRaw(Method.EDIT_MESSAGE, {
-                oneofKind: "editMessage",
-                editMessage: {
-                  messageId: callbackActionEvent.targetMessageId,
-                  peerId: buildChatPeer2(chatId),
-                  text: nativeCommandMenu.title,
-                  ...menuActions ? { actions: menuActions } : {},
-                  parseMarkdown
-                }
-              });
-              if (result.oneofKind !== "editMessage") {
-                throw new Error(`inline native command menu: expected editMessage result, got ${String(result.oneofKind)}`);
-              }
-              deliveredNativeMenu = true;
-            } catch (error48) {
-              runtime2.error?.(`inline native command menu edit failed; falling back to send (${String(error48)})`);
+          if (result.oneofKind !== "editMessage") {
+            throw new Error(`inline native command menu: expected editMessage result, got ${String(result.oneofKind)}`);
+          }
+          deliveredNativeMenu = true;
+        } catch (error48) {
+          runtime2.error?.(`inline native command menu edit failed; falling back to send (${String(error48)})`);
+        }
+      }
+      if (!deliveredNativeMenu) {
+        const sent = await client.sendMessage({
+          chatId,
+          text: nativeCommandMenu.title,
+          ...menuActions ? { actions: menuActions } : {}
+        });
+        if (sent.messageId != null) {
+          rememberBotMessageId(botMessageIdsByChat, chatId, sent.messageId);
+        }
+      }
+      statusSink?.({ lastOutboundAt: Date.now() });
+      await answerCallbackIfNeeded().catch((error48) => {
+        runtime2.error?.(`inline callback answer failed: ${String(error48)}`);
+      });
+      return;
+    }
+    const modelPickerCallbackData = callbackActionEvent ? callbackDataToUtf8(callbackActionEvent.data) : undefined;
+    const modelPickerCallback = modelPickerCallbackData ? parseInlineModelPickerCallback(modelPickerCallbackData) : null;
+    if (shouldEditCallbackTargetInPlace && callbackActionEvent && modelPickerCallback?.type === "select") {
+      const deliverModelPickerEdit = async (text, buttons) => {
+        const actions = resolveInlineReplyActions({
+          channelData: {
+            inline: {
+              buttons
             }
           }
-          if (!deliveredNativeMenu) {
-            const sent = await client.sendMessage({
-              chatId,
-              text: nativeCommandMenu.title,
-              ...menuActions ? { actions: menuActions } : {}
-            });
-            if (sent.messageId != null) {
-              rememberBotMessageId(botMessageIdsByChat, chatId, sent.messageId);
+        }) ?? { rows: [] };
+        try {
+          const result = await client.invokeRaw(Method.EDIT_MESSAGE, {
+            oneofKind: "editMessage",
+            editMessage: {
+              messageId: callbackActionEvent.targetMessageId,
+              peerId: buildChatPeer2(chatId),
+              text,
+              actions,
+              parseMarkdown
             }
+          });
+          if (result.oneofKind !== "editMessage") {
+            throw new Error(`inline model picker edit: expected editMessage result, got ${String(result.oneofKind)}`);
           }
-          statusSink?.({ lastOutboundAt: Date.now() });
-          await answerCallbackIfNeeded().catch((error48) => {
-            runtime2.error?.(`inline callback answer failed: ${String(error48)}`);
+        } catch (error48) {
+          runtime2.error?.(`inline model picker edit failed; falling back to send (${String(error48)})`);
+          const sent = await client.sendMessage({
+            chatId,
+            text,
+            actions,
+            parseMarkdown
           });
-          continue;
+          if (sent.messageId != null) {
+            rememberBotMessageId(botMessageIdsByChat, chatId, sent.messageId);
+          }
         }
-        const modelPickerCallbackData = callbackActionEvent ? callbackDataToUtf8(callbackActionEvent.data) : undefined;
-        const modelPickerCallback = modelPickerCallbackData ? parseInlineModelPickerCallback(modelPickerCallbackData) : null;
-        if (shouldEditCallbackTargetInPlace && callbackActionEvent && modelPickerCallback?.type === "select") {
-          const deliverModelPickerEdit = async (text, buttons) => {
-            const actions = resolveInlineReplyActions({
-              channelData: {
-                inline: {
-                  buttons
-                }
-              }
-            }) ?? { rows: [] };
-            try {
-              const result = await client.invokeRaw(Method.EDIT_MESSAGE, {
-                oneofKind: "editMessage",
-                editMessage: {
-                  messageId: callbackActionEvent.targetMessageId,
-                  peerId: buildChatPeer2(chatId),
-                  text,
-                  actions,
-                  parseMarkdown
-                }
-              });
-              if (result.oneofKind !== "editMessage") {
-                throw new Error(`inline model picker edit: expected editMessage result, got ${String(result.oneofKind)}`);
-              }
-            } catch (error48) {
-              runtime2.error?.(`inline model picker edit failed; falling back to send (${String(error48)})`);
-              const sent = await client.sendMessage({
-                chatId,
-                text,
-                actions,
-                parseMarkdown
-              });
-              if (sent.messageId != null) {
-                rememberBotMessageId(botMessageIdsByChat, chatId, sent.messageId);
-              }
-            }
-          };
-          const { byProvider, providers } = await buildModelsProviderData(cfg, route.agentId);
-          const providerButtons = buildInlineModelProviderButtons(providers.map((provider) => ({
-            id: provider,
-            count: byProvider.get(provider)?.size ?? 0
-          })));
-          const selection = resolveInlineModelPickerSelection({
-            callback: modelPickerCallback,
-            providers,
-            byProvider
-          });
-          if (selection.kind !== "resolved") {
-            await deliverModelPickerEdit(`Could not resolve model "${selection.model}".
+      };
+      const { byProvider, providers } = await buildModelsProviderData(cfg, route.agentId);
+      const providerButtons = buildInlineModelProviderButtons(providers.map((provider) => ({
+        id: provider,
+        count: byProvider.get(provider)?.size ?? 0
+      })));
+      const selection = resolveInlineModelPickerSelection({
+        callback: modelPickerCallback,
+        providers,
+        byProvider
+      });
+      if (selection.kind !== "resolved") {
+        await deliverModelPickerEdit(`Could not resolve model "${selection.model}".
 
 Select a provider:`, providerButtons);
-          } else {
-            const modelSet = byProvider.get(selection.provider);
-            if (!modelSet?.has(selection.model)) {
-              await deliverModelPickerEdit(`❌ Model "${selection.provider}/${selection.model}" is not allowed.`, []);
-            } else {
-              try {
-                const storePath2 = core3.channel.session.resolveStorePath(cfg.session?.store, {
-                  agentId: route.agentId
-                });
-                const resolvedDefault = resolveDefaultModelForAgent({
-                  cfg,
-                  agentId: route.agentId
-                });
-                const isDefaultSelection = selection.provider === resolvedDefault.provider && selection.model === resolvedDefault.model;
-                await updateSessionStore(storePath2, (store) => {
-                  const entry = store[route.sessionKey] ?? {
-                    sessionId: route.sessionKey,
-                    updatedAt: Date.now()
-                  };
-                  store[route.sessionKey] = entry;
-                  applyModelOverrideToSessionEntry({
-                    entry,
-                    selection: {
-                      provider: selection.provider,
-                      model: selection.model,
-                      isDefault: isDefaultSelection
-                    }
-                  });
-                });
-                const actionText = isDefaultSelection ? "reset to default" : `changed to **${selection.provider}/${selection.model}**`;
-                await deliverModelPickerEdit(`✅ Model ${actionText}
+      } else {
+        const modelSet = byProvider.get(selection.provider);
+        if (!modelSet?.has(selection.model)) {
+          await deliverModelPickerEdit(`❌ Model "${selection.provider}/${selection.model}" is not allowed.`, []);
+        } else {
+          try {
+            const storePath2 = core3.channel.session.resolveStorePath(cfg.session?.store, {
+              agentId: route.agentId
+            });
+            const resolvedDefault = resolveDefaultModelForAgent({
+              cfg,
+              agentId: route.agentId
+            });
+            const isDefaultSelection = selection.provider === resolvedDefault.provider && selection.model === resolvedDefault.model;
+            await updateSessionStore(storePath2, (store) => {
+              const entry = store[route.sessionKey] ?? {
+                sessionId: route.sessionKey,
+                updatedAt: Date.now()
+              };
+              store[route.sessionKey] = entry;
+              applyModelOverrideToSessionEntry({
+                entry,
+                selection: {
+                  provider: selection.provider,
+                  model: selection.model,
+                  isDefault: isDefaultSelection
+                }
+              });
+            });
+            const actionText = isDefaultSelection ? "reset to default" : `changed to **${selection.provider}/${selection.model}**`;
+            await deliverModelPickerEdit(`✅ Model ${actionText}
 
 This model will be used for your next message.`, []);
-              } catch (error48) {
-                await deliverModelPickerEdit(`❌ Failed to change model: ${String(error48)}`, []);
-              }
-            }
+          } catch (error48) {
+            await deliverModelPickerEdit(`❌ Failed to change model: ${String(error48)}`, []);
           }
-          statusSink?.({ lastOutboundAt: Date.now() });
-          await answerCallbackIfNeeded().catch((error48) => {
-            runtime2.error?.(`inline callback answer failed: ${String(error48)}`);
-          });
-          continue;
         }
-        const inboundMedia = reactionEvent ? [] : await resolveInlineInboundMedia({
-          core: core3,
-          message: msg,
-          maxBytes: inboundMediaMaxBytes,
-          ...log ? { log } : {}
-        });
-        const timestamp = messageTimestamp;
-        const fromLabel = isGroup ? `chat:${effectiveGroupTitle ?? String(effectiveChatId)}` : `user:${senderId}`;
-        const storePath = core3.channel.session.resolveStorePath(cfg.session?.store, { agentId: route.agentId });
-        const envelopeOptions = core3.channel.reply.resolveEnvelopeFormatOptions(cfg);
-        const previousTimestamp = core3.channel.session.readSessionUpdatedAt({ storePath, sessionKey: route.sessionKey });
-        const combinedBody = [
-          effectiveHistoryContext.historyText,
-          effectiveHistoryContext.attachmentText,
-          effectiveHistoryContext.entityText,
-          INLINE_FORMATTING_NOTE,
-          `Current message:
+      }
+      statusSink?.({ lastOutboundAt: Date.now() });
+      await answerCallbackIfNeeded().catch((error48) => {
+        runtime2.error?.(`inline callback answer failed: ${String(error48)}`);
+      });
+      return;
+    }
+    const inboundMedia = reactionEvent ? [] : await resolveInlineInboundMedia({
+      core: core3,
+      message: msg,
+      maxBytes: inboundMediaMaxBytes,
+      ...log ? { log } : {}
+    });
+    const timestamp = messageTimestamp;
+    const fromLabel = isGroup ? `chat:${effectiveGroupTitle ?? String(effectiveChatId)}` : `user:${senderId}`;
+    const storePath = core3.channel.session.resolveStorePath(cfg.session?.store, { agentId: route.agentId });
+    const envelopeOptions = core3.channel.reply.resolveEnvelopeFormatOptions(cfg);
+    const previousTimestamp = core3.channel.session.readSessionUpdatedAt({ storePath, sessionKey: route.sessionKey });
+    const combinedBody = [
+      effectiveHistoryContext.historyText,
+      effectiveHistoryContext.attachmentText,
+      effectiveHistoryContext.entityText,
+      INLINE_FORMATTING_NOTE,
+      `Current message:
 ${rawBody}`,
-          currentAttachmentText && currentAttachmentText !== rawBody ? `Current media/attachments:
+      currentAttachmentText && currentAttachmentText !== rawBody ? `Current media/attachments:
 ${currentAttachmentText}` : null,
-          currentEntityText ? `Current message entities:
+      currentEntityText ? `Current message entities:
 ${currentEntityText}` : null
-        ].filter(Boolean).join(`
+    ].filter(Boolean).join(`
 
 `);
-        let body = core3.channel.reply.formatAgentEnvelope({
+    let body = core3.channel.reply.formatAgentEnvelope({
+      channel: "Inline",
+      from: fromLabel,
+      timestamp,
+      ...previousTimestamp != null ? { previousTimestamp } : {},
+      envelope: envelopeOptions,
+      body: combinedBody || rawBody
+    });
+    if (isGroup && groupHistoryKey) {
+      body = buildPendingHistoryContextFromMap({
+        historyMap: groupPendingHistories,
+        historyKey: groupHistoryKey,
+        limit: historyLimit,
+        currentMessage: body,
+        formatEntry: (entry) => core3.channel.reply.formatAgentEnvelope({
           channel: "Inline",
           from: fromLabel,
-          timestamp,
-          ...previousTimestamp != null ? { previousTimestamp } : {},
+          ...entry.timestamp != null ? { timestamp: entry.timestamp } : {},
           envelope: envelopeOptions,
-          body: combinedBody || rawBody
-        });
-        if (isGroup && groupHistoryKey) {
-          body = buildPendingHistoryContextFromMap({
-            historyMap: groupPendingHistories,
-            historyKey: groupHistoryKey,
-            limit: historyLimit,
-            currentMessage: body,
-            formatEntry: (entry) => core3.channel.reply.formatAgentEnvelope({
-              channel: "Inline",
-              from: fromLabel,
-              ...entry.timestamp != null ? { timestamp: entry.timestamp } : {},
-              envelope: envelopeOptions,
-              body: `${entry.body}${entry.messageId ? ` [id:${entry.messageId} chat:${String(chatId)}]` : ""}`
-            })
-          });
+          body: `${entry.body}${entry.messageId ? ` [id:${entry.messageId} chat:${String(chatId)}]` : ""}`
+        })
+      });
+    }
+    const inboundHistory = isGroup && groupHistoryKey ? mergeInboundHistoryEntries({
+      historyContextEntries: effectiveHistoryContext.inboundHistory,
+      pendingEntries: groupPendingHistories.get(groupHistoryKey) ?? [],
+      limit: historyLimit
+    }) : [];
+    const bodyForAgent = buildInlineBodyForAgent({
+      rawBody,
+      currentAttachmentText,
+      currentEntityText
+    });
+    const effectiveSurface = shouldUseTelegramSurfaceForModelCommands(normalizedCommandBody) ? "telegram" : CHANNEL_ID;
+    const systemPrompt = resolveInlineSystemPrompt({
+      account,
+      ...isGroup ? { groupId: String(effectiveChatId) } : {}
+    });
+    const ctxPayload = core3.channel.reply.finalizeInboundContext({
+      Body: body,
+      BodyForAgent: bodyForAgent,
+      ...isGroup ? { InboundHistory: inboundHistory } : {},
+      RawBody: rawBody,
+      CommandBody: normalizedCommandBody,
+      From: isGroup ? `inline:chat:${String(effectiveChatId)}` : `inline:${senderId}`,
+      To: `inline:${String(effectiveChatId)}`,
+      SessionKey: route.sessionKey,
+      ...replyThreadContext ? { ParentSessionKey: route.sessionKey } : {},
+      AccountId: route.accountId,
+      ChatType: isGroup ? "group" : "direct",
+      ConversationLabel: fromLabel,
+      ...isGroup ? { GroupSubject: effectiveGroupTitle ?? String(effectiveChatId) } : {},
+      SenderId: senderId,
+      ...senderName ? { SenderName: senderName } : {},
+      ...senderUsername ? { SenderUsername: senderUsername } : {},
+      Provider: CHANNEL_ID,
+      Surface: effectiveSurface,
+      MessageSid: buildInlineInboundMessageSid({
+        msgId: msg.id,
+        ...callbackActionEvent ? { callbackActionEvent } : {}
+      }),
+      ...replyThreadContext ? { MessageThreadId: String(replyThreadContext.childChatId) } : {},
+      ...replyThreadContext?.threadLabel ? { ThreadLabel: replyThreadContext.threadLabel } : {},
+      ...msg.replyToMsgId != null ? { ReplyToId: String(msg.replyToMsgId) } : {},
+      ...effectiveHistoryContext.replyToSenderId != null ? { ReplyToSenderId: effectiveHistoryContext.replyToSenderId } : {},
+      ...msg.replyToMsgId != null ? { ReplyToWasBot: effectiveHistoryContext.repliedToBot } : {},
+      ...callbackActionEvent ? {
+        MessageActionInteractionId: String(callbackActionEvent.interactionId),
+        MessageActionId: callbackActionEvent.actionId,
+        MessageActionDataBase64: callbackDataToBase64(callbackActionEvent.data),
+        ...callbackDataToUtf8(callbackActionEvent.data) ? { MessageActionDataUtf8: callbackDataToUtf8(callbackActionEvent.data) } : {}
+      } : {},
+      ...buildInlineInboundMediaPayload(inboundMedia),
+      Timestamp: timestamp || Date.now(),
+      WasMentioned: mentionGate.effectiveWasMentioned,
+      CommandAuthorized: commandAuthorized,
+      GroupSystemPrompt: systemPrompt,
+      OriginatingChannel: CHANNEL_ID,
+      OriginatingTo: `inline:${String(effectiveChatId)}`
+    });
+    await core3.channel.session.recordInboundSession({
+      storePath,
+      sessionKey: ctxPayload.SessionKey ?? route.sessionKey,
+      ctx: ctxPayload,
+      ...!isGroup ? {
+        updateLastRoute: {
+          sessionKey: route.mainSessionKey,
+          channel: CHANNEL_ID,
+          to: `inline:${String(effectiveChatId)}`,
+          accountId: route.accountId
         }
-        const inboundHistory = isGroup && groupHistoryKey ? mergeInboundHistoryEntries({
-          historyContextEntries: effectiveHistoryContext.inboundHistory,
-          pendingEntries: groupPendingHistories.get(groupHistoryKey) ?? [],
-          limit: historyLimit
-        }) : [];
-        const bodyForAgent = buildInlineBodyForAgent({
-          rawBody,
-          currentAttachmentText,
-          currentEntityText
-        });
-        const effectiveSurface = shouldUseTelegramSurfaceForModelCommands(normalizedCommandBody) ? "telegram" : CHANNEL_ID;
-        const systemPrompt = resolveInlineSystemPrompt({
-          account,
-          ...isGroup ? { groupId: String(effectiveChatId) } : {}
-        });
-        const ctxPayload = core3.channel.reply.finalizeInboundContext({
-          Body: body,
-          BodyForAgent: bodyForAgent,
-          ...isGroup ? { InboundHistory: inboundHistory } : {},
-          RawBody: rawBody,
-          CommandBody: normalizedCommandBody,
-          From: isGroup ? `inline:chat:${String(effectiveChatId)}` : `inline:${senderId}`,
-          To: `inline:${String(effectiveChatId)}`,
-          SessionKey: route.sessionKey,
-          ...replyThreadContext ? { ParentSessionKey: route.sessionKey } : {},
-          AccountId: route.accountId,
-          ChatType: isGroup ? "group" : "direct",
-          ConversationLabel: fromLabel,
-          ...isGroup ? { GroupSubject: effectiveGroupTitle ?? String(effectiveChatId) } : {},
-          SenderId: senderId,
-          ...senderName ? { SenderName: senderName } : {},
-          ...senderUsername ? { SenderUsername: senderUsername } : {},
-          Provider: CHANNEL_ID,
-          Surface: effectiveSurface,
-          MessageSid: buildInlineInboundMessageSid({
-            msgId: msg.id,
-            ...callbackActionEvent ? { callbackActionEvent } : {}
-          }),
-          ...replyThreadContext ? { MessageThreadId: String(replyThreadContext.childChatId) } : {},
-          ...replyThreadContext?.threadLabel ? { ThreadLabel: replyThreadContext.threadLabel } : {},
-          ...msg.replyToMsgId != null ? { ReplyToId: String(msg.replyToMsgId) } : {},
-          ...effectiveHistoryContext.replyToSenderId != null ? { ReplyToSenderId: effectiveHistoryContext.replyToSenderId } : {},
-          ...msg.replyToMsgId != null ? { ReplyToWasBot: effectiveHistoryContext.repliedToBot } : {},
-          ...callbackActionEvent ? {
-            MessageActionInteractionId: String(callbackActionEvent.interactionId),
-            MessageActionId: callbackActionEvent.actionId,
-            MessageActionDataBase64: callbackDataToBase64(callbackActionEvent.data),
-            ...callbackDataToUtf8(callbackActionEvent.data) ? { MessageActionDataUtf8: callbackDataToUtf8(callbackActionEvent.data) } : {}
-          } : {},
-          ...buildInlineInboundMediaPayload(inboundMedia),
-          Timestamp: timestamp || Date.now(),
-          WasMentioned: mentionGate.effectiveWasMentioned,
-          CommandAuthorized: commandAuthorized,
-          GroupSystemPrompt: systemPrompt,
-          OriginatingChannel: CHANNEL_ID,
-          OriginatingTo: `inline:${String(effectiveChatId)}`
-        });
-        await core3.channel.session.recordInboundSession({
-          storePath,
-          sessionKey: ctxPayload.SessionKey ?? route.sessionKey,
-          ctx: ctxPayload,
-          ...!isGroup ? {
-            updateLastRoute: {
-              sessionKey: route.mainSessionKey,
-              channel: CHANNEL_ID,
-              to: `inline:${String(effectiveChatId)}`,
-              accountId: route.accountId
+      } : {},
+      onRecordError: (err) => runtime2.error?.(`inline: failed updating session meta: ${String(err)}`)
+    });
+    const replyPipeline = await createChannelReplyPipelineCompat({
+      cfg,
+      agentId: route.agentId,
+      channel: CHANNEL_ID,
+      accountId: account.accountId,
+      typing: {
+        start: () => client.sendTyping({ chatId, typing: true }),
+        stop: () => client.sendTyping({ chatId, typing: false }),
+        onStartError: (err) => runtime2.error?.(`inline typing start failed: ${String(err)}`),
+        onStopError: (err) => runtime2.error?.(`inline typing stop failed: ${String(err)}`)
+      }
+    });
+    const onModelSelected = replyPipeline.onModelSelected;
+    const typingCallbacks = replyPipeline.typingCallbacks;
+    const prefixOptions = {
+      ...replyPipeline.responsePrefix !== undefined ? { responsePrefix: replyPipeline.responsePrefix } : {},
+      ...replyPipeline.enableSlackInteractiveReplies !== undefined ? { enableSlackInteractiveReplies: replyPipeline.enableSlackInteractiveReplies } : {},
+      ...replyPipeline.responsePrefixContextProvider ? {
+        responsePrefixContextProvider: replyPipeline.responsePrefixContextProvider
+      } : {}
+    };
+    const callbackTargetMessage = shouldEditCallbackTargetInPlace && callbackActionEvent ? await findChatMessageById({
+      client,
+      chatId,
+      messageId: callbackActionEvent.targetMessageId,
+      limit: REPLY_TARGET_LOOKUP_LIMIT,
+      meId,
+      botMessageIdsByChat
+    }).catch(() => null) : null;
+    const streamViaEditMessage = account.config.streamViaEditMessage === true && !shouldEditCallbackTargetInPlace;
+    const defaultReplyToMsgId = isGroup && msg.replyToMsgId != null ? msg.id : undefined;
+    const disableBlockStreaming = streamViaEditMessage ? true : typeof account.config.blockStreaming === "boolean" ? !account.config.blockStreaming : undefined;
+    const editStreamState = {
+      messageId: shouldEditCallbackTargetInPlace ? callbackActionEvent?.targetMessageId ?? null : null,
+      accumulatedText: callbackTargetMessage?.message ?? "",
+      lastPartialText: "",
+      finalTextAccumulator: "",
+      failed: false,
+      opChain: Promise.resolve()
+    };
+    let finalDeliveredForCurrentAssistantMessage = false;
+    const resetEditStreamForAssistantMessage = async () => {
+      await editStreamState.opChain;
+      const hasActiveState = editStreamState.messageId != null || editStreamState.accumulatedText.length > 0 || editStreamState.lastPartialText.length > 0 || editStreamState.finalTextAccumulator.length > 0;
+      if (!hasActiveState)
+        return;
+      editStreamState.messageId = null;
+      editStreamState.accumulatedText = "";
+      editStreamState.lastPartialText = "";
+      editStreamState.finalTextAccumulator = "";
+      editStreamState.failed = false;
+      finalDeliveredForCurrentAssistantMessage = false;
+    };
+    const resetEditStreamOnBoundary = async () => {
+      if (!streamViaEditMessage)
+        return;
+      await resetEditStreamForAssistantMessage();
+    };
+    const handlePartialStreamPayload = async (payload) => {
+      if (editStreamState.failed)
+        return;
+      if ((payload.mediaUrls?.length ?? 0) > 0)
+        return;
+      const partialText = typeof payload.text === "string" ? payload.text : "";
+      if (!partialText || partialText === editStreamState.lastPartialText)
+        return;
+      editStreamState.lastPartialText = partialText;
+      const nextText = rewriteNumericMentionsToUsernames(extractCompleteParagraphText(partialText), senderProfilesById).trim();
+      if (!nextText || nextText === editStreamState.accumulatedText)
+        return;
+      editStreamState.opChain = editStreamState.opChain.then(async () => {
+        if (editStreamState.failed)
+          return;
+        if (!nextText || nextText === editStreamState.accumulatedText)
+          return;
+        try {
+          if (editStreamState.messageId == null) {
+            const sent = await client.sendMessage({
+              chatId,
+              text: nextText,
+              ...defaultReplyToMsgId != null ? { replyToMsgId: defaultReplyToMsgId } : {},
+              parseMarkdown
+            });
+            if (sent.messageId == null) {
+              throw new Error("inline edit stream: sendMessage returned no messageId");
+            }
+            editStreamState.messageId = sent.messageId;
+            rememberBotMessageId(botMessageIdsByChat, chatId, sent.messageId);
+          } else {
+            const result = await client.invokeRaw(Method.EDIT_MESSAGE, {
+              oneofKind: "editMessage",
+              editMessage: {
+                messageId: editStreamState.messageId,
+                peerId: buildChatPeer2(chatId),
+                text: nextText,
+                parseMarkdown
+              }
+            });
+            if (result.oneofKind !== "editMessage") {
+              throw new Error(`inline edit stream: expected editMessage result, got ${String(result.oneofKind)}`);
             }
-          } : {},
-          onRecordError: (err) => runtime2.error?.(`inline: failed updating session meta: ${String(err)}`)
-        });
-        const replyPipeline = await createChannelReplyPipelineCompat({
-          cfg,
-          agentId: route.agentId,
-          channel: CHANNEL_ID,
-          accountId: account.accountId,
-          typing: {
-            start: () => client.sendTyping({ chatId, typing: true }),
-            stop: () => client.sendTyping({ chatId, typing: false }),
-            onStartError: (err) => runtime2.error?.(`inline typing start failed: ${String(err)}`),
-            onStopError: (err) => runtime2.error?.(`inline typing stop failed: ${String(err)}`)
           }
-        });
-        const onModelSelected = replyPipeline.onModelSelected;
-        const typingCallbacks = replyPipeline.typingCallbacks;
-        const prefixOptions = {
-          ...replyPipeline.responsePrefix !== undefined ? { responsePrefix: replyPipeline.responsePrefix } : {},
-          ...replyPipeline.enableSlackInteractiveReplies !== undefined ? { enableSlackInteractiveReplies: replyPipeline.enableSlackInteractiveReplies } : {},
-          ...replyPipeline.responsePrefixContextProvider ? {
-            responsePrefixContextProvider: replyPipeline.responsePrefixContextProvider
-          } : {}
-        };
-        const callbackTargetMessage = shouldEditCallbackTargetInPlace && callbackActionEvent ? await findChatMessageById({
-          client,
-          chatId,
-          messageId: callbackActionEvent.targetMessageId,
-          limit: REPLY_TARGET_LOOKUP_LIMIT,
-          meId,
-          botMessageIdsByChat
-        }).catch(() => null) : null;
-        const streamViaEditMessage = account.config.streamViaEditMessage === true && !shouldEditCallbackTargetInPlace;
-        const defaultReplyToMsgId = isGroup && msg.replyToMsgId != null ? msg.id : undefined;
-        const disableBlockStreaming = streamViaEditMessage ? true : typeof account.config.blockStreaming === "boolean" ? !account.config.blockStreaming : undefined;
-        const editStreamState = {
-          messageId: shouldEditCallbackTargetInPlace ? callbackActionEvent?.targetMessageId ?? null : null,
-          accumulatedText: callbackTargetMessage?.message ?? "",
-          lastPartialText: "",
-          finalTextAccumulator: "",
-          failed: false,
-          opChain: Promise.resolve()
-        };
-        let finalDeliveredForCurrentAssistantMessage = false;
-        const resetEditStreamForAssistantMessage = async () => {
+          editStreamState.accumulatedText = nextText;
+          statusSink?.({ lastOutboundAt: Date.now() });
+        } catch (error48) {
+          editStreamState.failed = true;
+          runtime2.error?.(`inline edit stream failed: ${String(error48)}`);
+        }
+      });
+      await editStreamState.opChain;
+    };
+    const replyOptions = {
+      ...onModelSelected ? { onModelSelected } : {},
+      blockReplyTimeoutMs: 25000,
+      ...streamViaEditMessage ? {
+        onAssistantMessageStart: async () => {
+          await resetEditStreamOnBoundary();
+        }
+      } : {},
+      ...streamViaEditMessage ? {
+        onPartialReply: async (payload) => {
+          await handlePartialStreamPayload(payload);
+        }
+      } : {},
+      ...streamViaEditMessage ? {
+        onReasoningStream: async (payload) => {
+          await handlePartialStreamPayload(payload);
+        }
+      } : {},
+      ...streamViaEditMessage ? {
+        onReasoningEnd: async () => {
           await editStreamState.opChain;
-          const hasActiveState = editStreamState.messageId != null || editStreamState.accumulatedText.length > 0 || editStreamState.lastPartialText.length > 0 || editStreamState.finalTextAccumulator.length > 0;
-          if (!hasActiveState)
-            return;
-          editStreamState.messageId = null;
-          editStreamState.accumulatedText = "";
-          editStreamState.lastPartialText = "";
-          editStreamState.finalTextAccumulator = "";
-          editStreamState.failed = false;
-          finalDeliveredForCurrentAssistantMessage = false;
-        };
-        const resetEditStreamOnBoundary = async () => {
-          if (!streamViaEditMessage)
-            return;
-          await resetEditStreamForAssistantMessage();
-        };
-        const handlePartialStreamPayload = async (payload) => {
-          if (editStreamState.failed)
-            return;
-          if ((payload.mediaUrls?.length ?? 0) > 0)
-            return;
-          const partialText = typeof payload.text === "string" ? payload.text : "";
-          if (!partialText || partialText === editStreamState.lastPartialText)
-            return;
-          editStreamState.lastPartialText = partialText;
-          const nextText = rewriteNumericMentionsToUsernames(extractCompleteParagraphText(partialText), senderProfilesById).trim();
-          if (!nextText || nextText === editStreamState.accumulatedText)
-            return;
-          editStreamState.opChain = editStreamState.opChain.then(async () => {
-            if (editStreamState.failed)
-              return;
-            if (!nextText || nextText === editStreamState.accumulatedText)
-              return;
-            try {
-              if (editStreamState.messageId == null) {
+        }
+      } : {},
+      ...streamViaEditMessage ? {
+        onToolStart: async () => {
+          await resetEditStreamOnBoundary();
+        }
+      } : {},
+      ...streamViaEditMessage ? {
+        onCompactionStart: async () => {
+          await resetEditStreamOnBoundary();
+        }
+      } : {},
+      ...streamViaEditMessage ? {
+        onCompactionEnd: async () => {
+          await resetEditStreamOnBoundary();
+        }
+      } : {},
+      ...typeof disableBlockStreaming === "boolean" ? { disableBlockStreaming } : {}
+    };
+    try {
+      let delivered = false;
+      let skippedNonSilent = false;
+      let failedNonSilent = false;
+      let dispatchError = null;
+      try {
+        await core3.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
+          ctx: ctxPayload,
+          cfg,
+          dispatcherOptions: {
+            ...prefixOptions,
+            ...typingCallbacks ? { typingCallbacks } : {},
+            deliver: async (payload, info) => {
+              const rawText = payload.text ?? "";
+              const mediaList = payload.mediaUrls?.length ? payload.mediaUrls : payload.mediaUrl ? [payload.mediaUrl] : [];
+              const outboundText = rewriteNumericMentionsToUsernames(rawText, senderProfilesById);
+              const outboundActions = resolveInlineReplyActions(payload);
+              const infoKind = typeof info?.kind === "string" ? info.kind : undefined;
+              let replyToMsgId;
+              if (payload.replyToId != null) {
+                try {
+                  replyToMsgId = BigInt(payload.replyToId);
+                } catch {}
+              }
+              if (replyToMsgId == null && isGroup && msg.replyToMsgId != null) {
+                replyToMsgId = msg.id;
+              }
+              const rememberSent = (messageId) => {
+                if (messageId != null) {
+                  rememberBotMessageId(botMessageIdsByChat, chatId, messageId);
+                }
+              };
+              const sendTextFallback = async (text, includeReplyTo, includeActions) => {
+                if (!text.trim())
+                  return;
                 const sent = await client.sendMessage({
                   chatId,
-                  text: nextText,
-                  ...defaultReplyToMsgId != null ? { replyToMsgId: defaultReplyToMsgId } : {},
+                  text,
+                  ...includeReplyTo && replyToMsgId != null ? { replyToMsgId } : {},
+                  ...includeActions && outboundActions !== undefined ? { actions: outboundActions } : {},
                   parseMarkdown
                 });
-                if (sent.messageId == null) {
-                  throw new Error("inline edit stream: sendMessage returned no messageId");
-                }
-                editStreamState.messageId = sent.messageId;
-                rememberBotMessageId(botMessageIdsByChat, chatId, sent.messageId);
-              } else {
+                rememberSent(sent.messageId);
+                delivered = true;
+              };
+              const updateStreamedMessage = async (text, actions) => {
+                await editStreamState.opChain;
+                if (editStreamState.messageId == null)
+                  return false;
+                const nextText = text.trim();
+                const textForEdit = nextText || editStreamState.accumulatedText;
+                if (!textForEdit && actions === undefined)
+                  return true;
+                const shouldSkipTextUpdate = !editStreamState.failed && textForEdit === editStreamState.accumulatedText;
+                if (shouldSkipTextUpdate && actions === undefined)
+                  return true;
                 const result = await client.invokeRaw(Method.EDIT_MESSAGE, {
                   oneofKind: "editMessage",
                   editMessage: {
                     messageId: editStreamState.messageId,
                     peerId: buildChatPeer2(chatId),
-                    text: nextText,
-                    parseMarkdown
+                    text: textForEdit,
+                    parseMarkdown,
+                    ...actions !== undefined ? { actions } : {}
                   }
                 });
                 if (result.oneofKind !== "editMessage") {
                   throw new Error(`inline edit stream: expected editMessage result, got ${String(result.oneofKind)}`);
                 }
-              }
-              editStreamState.accumulatedText = nextText;
-              statusSink?.({ lastOutboundAt: Date.now() });
-            } catch (error48) {
-              editStreamState.failed = true;
-              runtime2.error?.(`inline edit stream failed: ${String(error48)}`);
-            }
-          });
-          await editStreamState.opChain;
-        };
-        const replyOptions = {
-          ...onModelSelected ? { onModelSelected } : {},
-          blockReplyTimeoutMs: 25000,
-          ...streamViaEditMessage ? {
-            onAssistantMessageStart: async () => {
-              await resetEditStreamOnBoundary();
-            }
-          } : {},
-          ...streamViaEditMessage ? {
-            onPartialReply: async (payload) => {
-              await handlePartialStreamPayload(payload);
-            }
-          } : {},
-          ...streamViaEditMessage ? {
-            onReasoningStream: async (payload) => {
-              await handlePartialStreamPayload(payload);
-            }
-          } : {},
-          ...streamViaEditMessage ? {
-            onReasoningEnd: async () => {
-              await editStreamState.opChain;
-            }
-          } : {},
-          ...streamViaEditMessage ? {
-            onToolStart: async () => {
-              await resetEditStreamOnBoundary();
-            }
-          } : {},
-          ...streamViaEditMessage ? {
-            onCompactionStart: async () => {
-              await resetEditStreamOnBoundary();
-            }
-          } : {},
-          ...streamViaEditMessage ? {
-            onCompactionEnd: async () => {
-              await resetEditStreamOnBoundary();
-            }
-          } : {},
-          ...typeof disableBlockStreaming === "boolean" ? { disableBlockStreaming } : {}
-        };
-        try {
-          let delivered = false;
-          let skippedNonSilent = false;
-          let failedNonSilent = false;
-          let dispatchError = null;
-          try {
-            await core3.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
-              ctx: ctxPayload,
-              cfg,
-              dispatcherOptions: {
-                ...prefixOptions,
-                ...typingCallbacks ? { typingCallbacks } : {},
-                deliver: async (payload, info) => {
-                  const rawText = payload.text ?? "";
-                  const mediaList = payload.mediaUrls?.length ? payload.mediaUrls : payload.mediaUrl ? [payload.mediaUrl] : [];
-                  const outboundText = rewriteNumericMentionsToUsernames(rawText, senderProfilesById);
-                  const outboundActions = resolveInlineReplyActions(payload);
-                  const infoKind = typeof info?.kind === "string" ? info.kind : undefined;
-                  let replyToMsgId;
-                  if (payload.replyToId != null) {
-                    try {
-                      replyToMsgId = BigInt(payload.replyToId);
-                    } catch {}
+                if (!shouldSkipTextUpdate) {
+                  editStreamState.accumulatedText = textForEdit;
+                  editStreamState.lastPartialText = textForEdit;
+                }
+                editStreamState.failed = false;
+                return true;
+              };
+              if (mediaList.length === 0) {
+                if (shouldEditCallbackTargetInPlace && editStreamState.messageId != null) {
+                  const callbackEditActions = outboundActions ?? { rows: [] };
+                  if (!outboundText.trim() && outboundActions === undefined) {
+                    return;
                   }
-                  if (replyToMsgId == null && isGroup && msg.replyToMsgId != null) {
-                    replyToMsgId = msg.id;
+                  await updateStreamedMessage(outboundText, callbackEditActions);
+                  delivered = true;
+                  statusSink?.({ lastOutboundAt: Date.now() });
+                  return;
+                }
+                if (streamViaEditMessage && infoKind === "final" && finalDeliveredForCurrentAssistantMessage && editStreamState.messageId != null) {
+                  await resetEditStreamForAssistantMessage();
+                }
+                if (streamViaEditMessage && editStreamState.messageId != null) {
+                  if (outboundText.trim()) {
+                    editStreamState.finalTextAccumulator += outboundText;
                   }
-                  const rememberSent = (messageId) => {
-                    if (messageId != null) {
-                      rememberBotMessageId(botMessageIdsByChat, chatId, messageId);
-                    }
-                  };
-                  const sendTextFallback = async (text, includeReplyTo, includeActions) => {
-                    if (!text.trim())
-                      return;
-                    const sent = await client.sendMessage({
-                      chatId,
-                      text,
-                      ...includeReplyTo && replyToMsgId != null ? { replyToMsgId } : {},
-                      ...includeActions && outboundActions !== undefined ? { actions: outboundActions } : {},
-                      parseMarkdown
-                    });
-                    rememberSent(sent.messageId);
-                    delivered = true;
-                  };
-                  const updateStreamedMessage = async (text, actions) => {
-                    await editStreamState.opChain;
-                    if (editStreamState.messageId == null)
-                      return false;
-                    const nextText = text.trim();
-                    const textForEdit = nextText || editStreamState.accumulatedText;
-                    if (!textForEdit && actions === undefined)
-                      return true;
-                    const shouldSkipTextUpdate = !editStreamState.failed && textForEdit === editStreamState.accumulatedText;
-                    if (shouldSkipTextUpdate && actions === undefined)
-                      return true;
-                    const result = await client.invokeRaw(Method.EDIT_MESSAGE, {
-                      oneofKind: "editMessage",
-                      editMessage: {
-                        messageId: editStreamState.messageId,
-                        peerId: buildChatPeer2(chatId),
-                        text: textForEdit,
-                        parseMarkdown,
-                        ...actions !== undefined ? { actions } : {}
-                      }
-                    });
-                    if (result.oneofKind !== "editMessage") {
-                      throw new Error(`inline edit stream: expected editMessage result, got ${String(result.oneofKind)}`);
-                    }
-                    if (!shouldSkipTextUpdate) {
-                      editStreamState.accumulatedText = textForEdit;
-                      editStreamState.lastPartialText = textForEdit;
-                    }
-                    editStreamState.failed = false;
-                    return true;
-                  };
-                  if (mediaList.length === 0) {
-                    if (shouldEditCallbackTargetInPlace && editStreamState.messageId != null) {
-                      const callbackEditActions = outboundActions ?? { rows: [] };
-                      if (!outboundText.trim() && outboundActions === undefined) {
-                        return;
-                      }
-                      await updateStreamedMessage(outboundText, callbackEditActions);
-                      delivered = true;
-                      statusSink?.({ lastOutboundAt: Date.now() });
-                      return;
-                    }
-                    if (streamViaEditMessage && infoKind === "final" && finalDeliveredForCurrentAssistantMessage && editStreamState.messageId != null) {
-                      await resetEditStreamForAssistantMessage();
-                    }
-                    if (streamViaEditMessage && editStreamState.messageId != null) {
-                      if (outboundText.trim()) {
-                        editStreamState.finalTextAccumulator += outboundText;
-                      }
-                      if (!editStreamState.finalTextAccumulator.trim() && outboundActions === undefined) {
-                        return;
-                      }
-                      await updateStreamedMessage(editStreamState.finalTextAccumulator, outboundActions);
-                      delivered = true;
-                      if (infoKind === "final") {
-                        finalDeliveredForCurrentAssistantMessage = true;
-                      }
-                      statusSink?.({ lastOutboundAt: Date.now() });
-                      return;
-                    }
-                    if (!outboundText.trim())
-                      return;
-                    await sendTextFallback(outboundText, true, true);
-                    statusSink?.({ lastOutboundAt: Date.now() });
+                  if (!editStreamState.finalTextAccumulator.trim() && outboundActions === undefined) {
                     return;
                   }
-                  if (streamViaEditMessage && editStreamState.messageId != null && outboundText.trim()) {
-                    await updateStreamedMessage(outboundText, outboundActions);
+                  await updateStreamedMessage(editStreamState.finalTextAccumulator, outboundActions);
+                  delivered = true;
+                  if (infoKind === "final") {
+                    finalDeliveredForCurrentAssistantMessage = true;
                   }
-                  for (let index = 0;index < mediaList.length; index++) {
-                    const mediaUrl = mediaList[index];
-                    if (!mediaUrl?.trim())
-                      continue;
-                    const isFirst = index === 0;
-                    const shouldAttachActionsToMedia = isFirst && (!(streamViaEditMessage && editStreamState.messageId != null) || !outboundText.trim());
-                    const caption = isFirst && !(streamViaEditMessage && editStreamState.messageId != null) ? outboundText : "";
-                    try {
-                      const media = await uploadInlineMediaFromUrl({
-                        client,
-                        cfg,
-                        accountId: account.accountId,
-                        mediaUrl
-                      });
-                      const sent = await client.sendMessage({
-                        chatId,
-                        ...caption ? { text: caption } : {},
-                        media,
-                        ...isFirst && replyToMsgId != null ? { replyToMsgId } : {},
-                        ...shouldAttachActionsToMedia && outboundActions !== undefined ? { actions: outboundActions } : {},
-                        ...caption ? { parseMarkdown } : {}
-                      });
-                      rememberSent(sent.messageId);
-                      delivered = true;
-                    } catch (error48) {
-                      runtime2.error?.(`inline media upload failed; falling back to url text (${String(error48)})`);
-                      const fallbackText = caption ? `${caption}
+                  statusSink?.({ lastOutboundAt: Date.now() });
+                  return;
+                }
+                if (!outboundText.trim())
+                  return;
+                await sendTextFallback(outboundText, true, true);
+                statusSink?.({ lastOutboundAt: Date.now() });
+                return;
+              }
+              if (streamViaEditMessage && editStreamState.messageId != null && outboundText.trim()) {
+                await updateStreamedMessage(outboundText, outboundActions);
+              }
+              for (let index = 0;index < mediaList.length; index++) {
+                const mediaUrl = mediaList[index];
+                if (!mediaUrl?.trim())
+                  continue;
+                const isFirst = index === 0;
+                const shouldAttachActionsToMedia = isFirst && (!(streamViaEditMessage && editStreamState.messageId != null) || !outboundText.trim());
+                const caption = isFirst && !(streamViaEditMessage && editStreamState.messageId != null) ? outboundText : "";
+                try {
+                  const media = await uploadInlineMediaFromUrl({
+                    client,
+                    cfg,
+                    accountId: account.accountId,
+                    mediaUrl
+                  });
+                  const sent = await client.sendMessage({
+                    chatId,
+                    ...caption ? { text: caption } : {},
+                    media,
+                    ...isFirst && replyToMsgId != null ? { replyToMsgId } : {},
+                    ...shouldAttachActionsToMedia && outboundActions !== undefined ? { actions: outboundActions } : {},
+                    ...caption ? { parseMarkdown } : {}
+                  });
+                  rememberSent(sent.messageId);
+                  delivered = true;
+                } catch (error48) {
+                  runtime2.error?.(`inline media upload failed; falling back to url text (${String(error48)})`);
+                  const fallbackText = caption ? `${caption}
 
 Attachment: ${mediaUrl}` : `Attachment: ${mediaUrl}`;
-                      await sendTextFallback(fallbackText, isFirst, isFirst);
-                    }
-                  }
-                  statusSink?.({ lastOutboundAt: Date.now() });
-                },
-                onSkip: (_payload, info) => {
-                  if (info?.reason !== "silent") {
-                    skippedNonSilent = true;
-                  }
-                },
-                onError: (err, info) => {
-                  failedNonSilent = true;
-                  runtime2.error?.(`inline ${info?.kind ?? "final"} reply failed: ${String(err)}`);
+                  await sendTextFallback(fallbackText, isFirst, isFirst);
                 }
-              },
-              replyOptions
-            });
-          } catch (error48) {
-            dispatchError = error48;
-            runtime2.error?.(`inline dispatch failed: ${String(error48)}`);
-          }
-          if (!delivered && streamViaEditMessage && editStreamState.messageId != null) {
-            delivered = true;
-          }
-          if (!delivered && (dispatchError != null || skippedNonSilent || failedNonSilent)) {
-            const fallbackText = dispatchError != null ? "Something went wrong while processing your request. Please try again." : EMPTY_RESPONSE_FALLBACK;
-            const sent = await client.sendMessage({
-              chatId,
-              text: fallbackText,
-              ...defaultReplyToMsgId != null ? { replyToMsgId: defaultReplyToMsgId } : {},
-              parseMarkdown
-            });
-            if (sent.messageId != null) {
-              rememberBotMessageId(botMessageIdsByChat, chatId, sent.messageId);
+              }
+              statusSink?.({ lastOutboundAt: Date.now() });
+            },
+            onSkip: (_payload, info) => {
+              if (info?.reason !== "silent") {
+                skippedNonSilent = true;
+              }
+            },
+            onError: (err, info) => {
+              failedNonSilent = true;
+              runtime2.error?.(`inline ${info?.kind ?? "final"} reply failed: ${String(err)}`);
             }
-            statusSink?.({ lastOutboundAt: Date.now() });
-          }
-        } finally {
-          if (callbackActionEvent && !callbackActionAnswered) {
-            try {
-              await answerCallbackIfNeeded();
-            } catch (error48) {
-              runtime2.error?.(`inline callback answer failed: ${String(error48)}`);
+          },
+          replyOptions
+        });
+      } catch (error48) {
+        dispatchError = error48;
+        runtime2.error?.(`inline dispatch failed: ${String(error48)}`);
+      }
+      if (!delivered && streamViaEditMessage && editStreamState.messageId != null) {
+        delivered = true;
+      }
+      if (!delivered && (dispatchError != null || skippedNonSilent || failedNonSilent)) {
+        const fallbackText = dispatchError != null ? "Something went wrong while processing your request. Please try again." : EMPTY_RESPONSE_FALLBACK;
+        const sent = await client.sendMessage({
+          chatId,
+          text: fallbackText,
+          ...defaultReplyToMsgId != null ? { replyToMsgId: defaultReplyToMsgId } : {},
+          parseMarkdown
+        });
+        if (sent.messageId != null) {
+          rememberBotMessageId(botMessageIdsByChat, chatId, sent.messageId);
+        }
+        statusSink?.({ lastOutboundAt: Date.now() });
+      }
+    } finally {
+      if (callbackActionEvent && !callbackActionAnswered) {
+        try {
+          await answerCallbackIfNeeded();
+        } catch (error48) {
+          runtime2.error?.(`inline callback answer failed: ${String(error48)}`);
+        }
+      }
+    }
+    if (isGroup && groupHistoryKey) {
+      clearHistoryEntriesIfEnabled({
+        historyMap: groupPendingHistories,
+        historyKey: groupHistoryKey,
+        limit: historyLimit
+      });
+    }
+  };
+  const { debouncer: inboundDebouncer } = createChannelInboundDebouncer({
+    cfg,
+    channel: CHANNEL_ID,
+    buildKey: (entry) => buildInlineDebounceKey({
+      accountId: account.accountId,
+      chatId: entry.chatId,
+      senderId: entry.msg.fromId
+    }),
+    shouldDebounce: (entry) => {
+      const content = summarizeInlineMessageContent(entry.msg);
+      return shouldDebounceTextInbound({
+        text: buildInlineInboundBodyText(content),
+        cfg,
+        hasMedia: Boolean(content.media || content.attachments.length > 0),
+        ...botUsername ? { commandOptions: { botUsername } } : {}
+      });
+    },
+    onFlush: async (entries) => {
+      const last = entries.at(-1);
+      if (!last)
+        return;
+      if (entries.length === 1) {
+        await handleInboundNow({
+          chatId: last.chatId,
+          msg: last.msg
+        });
+        return;
+      }
+      const combinedText = entries.map((entry) => buildInlineInboundBodyText(summarizeInlineMessageContent(entry.msg))).filter(Boolean).join(`
+`);
+      if (!combinedText.trim()) {
+        return;
+      }
+      await handleInboundNow({
+        chatId: last.chatId,
+        msg: buildSyntheticInlineTextMessage({
+          base: last.msg,
+          text: combinedText,
+          mentioned: entries.some((entry) => entry.msg.mentioned === true)
+        }),
+        rawBodyOverride: combinedText
+      });
+    },
+    onError: (err, items) => {
+      runtime2.error?.(`inline debounce flush failed: ${String(err)}`);
+      const chatId = items[0]?.chatId;
+      if (chatId == null)
+        return;
+      client.sendMessage({
+        chatId,
+        text: "Something went wrong while processing your message. Please try again."
+      }).then(() => {
+        statusSink?.({ lastOutboundAt: Date.now() });
+      }).catch((sendErr) => {
+        runtime2.error?.(`inline debounce fallback send failed: ${String(sendErr)}`);
+      });
+    }
+  });
+  const loop = (async () => {
+    try {
+      for await (const event of client.events()) {
+        if (abortSignal.aborted)
+          break;
+        const rawEvent = event;
+        if (event.kind === "message.new") {
+          const msg = {
+            ...event.message,
+            chatId: event.chatId
+          };
+          if (msg.out || msg.fromId === meId)
+            continue;
+          await inboundDebouncer.enqueue({
+            chatId: event.chatId,
+            msg
+          });
+          continue;
+        }
+        if (event.kind === "reaction.add") {
+          if (event.reaction.userId === meId)
+            continue;
+          const onBotMessage = await isReactionTargetBotMessage({
+            client,
+            chatId: event.chatId,
+            messageId: event.reaction.messageId,
+            meId,
+            botMessageIdsByChat
+          }).catch((err) => {
+            statusSink?.({ lastError: `getChatHistory (reaction target) failed: ${String(err)}` });
+            return false;
+          });
+          if (!onBotMessage)
+            continue;
+          await handleInboundNow({
+            chatId: event.chatId,
+            msg: {
+              id: event.reaction.messageId,
+              chatId: event.chatId,
+              date: event.date,
+              fromId: event.reaction.userId,
+              message: "",
+              out: false,
+              mentioned: false,
+              replyToMsgId: event.reaction.messageId
+            },
+            reactionEvent: {
+              action: "added",
+              emoji: event.reaction.emoji,
+              targetMessageId: event.reaction.messageId
             }
-          }
+          });
+          continue;
+        }
+        if (event.kind === "reaction.delete") {
+          if (event.userId === meId)
+            continue;
+          const onBotMessage = await isReactionTargetBotMessage({
+            client,
+            chatId: event.chatId,
+            messageId: event.messageId,
+            meId,
+            botMessageIdsByChat
+          }).catch((err) => {
+            statusSink?.({ lastError: `getChatHistory (reaction target) failed: ${String(err)}` });
+            return false;
+          });
+          if (!onBotMessage)
+            continue;
+          await handleInboundNow({
+            chatId: event.chatId,
+            msg: {
+              id: event.messageId,
+              chatId: event.chatId,
+              date: event.date,
+              fromId: event.userId,
+              message: "",
+              out: false,
+              mentioned: false,
+              replyToMsgId: event.messageId
+            },
+            reactionEvent: {
+              action: "removed",
+              emoji: event.emoji,
+              targetMessageId: event.messageId
+            }
+          });
+          continue;
         }
-        if (isGroup && groupHistoryKey) {
-          clearHistoryEntriesIfEnabled({
-            historyMap: groupPendingHistories,
-            historyKey: groupHistoryKey,
-            limit: historyLimit
+        if (rawEvent["kind"] === "message.action.invoke") {
+          const actorUserId = rawEvent["actorUserId"];
+          const interactionId = rawEvent["interactionId"];
+          const actionId = rawEvent["actionId"];
+          const targetMessageId = rawEvent["messageId"];
+          const data = rawEvent["data"];
+          const eventChatId = rawEvent["chatId"];
+          const eventDate = rawEvent["date"];
+          if (!actorUserId || !interactionId || !actionId || !targetMessageId || !eventChatId || !eventDate || !data) {
+            continue;
+          }
+          if (actorUserId === meId)
+            continue;
+          await handleInboundNow({
+            chatId: eventChatId,
+            msg: {
+              id: targetMessageId,
+              chatId: eventChatId,
+              date: eventDate,
+              fromId: actorUserId,
+              message: "",
+              out: false,
+              mentioned: false,
+              replyToMsgId: targetMessageId
+            },
+            callbackActionEvent: {
+              interactionId,
+              actionId,
+              targetMessageId,
+              data
+            }
           });
+          continue;
         }
       }
     } catch (err) {
@@ -41217,5 +41311,5 @@ export {
   src_default as default
 };
 
-//# debugId=3B7100874DF4D61664756E2164756E21
+//# debugId=1C8239561365068664756E2164756E21
 //# sourceMappingURL=index.js.map