@ihazz/bitrix24 1.1.12 → 1.1.13

package/src/channel.ts

@@ -52,8 +52,11 @@ import {
   watchOwnerDmNotice,
 } from './i18n.js';
 import { HistoryCache } from './history-cache.js';
-import type { ConversationMeta } from './history-cache.js';
+import type { ConversationMeta, HistoryEntry } from './history-cache.js';
 import type {
+  B24Attach,
+  B24AttachBlock,
+  B24AttachColorToken,
   B24MsgContext,
   B24InputActionStatusCode,
   B24V2FetchEventItem,
@@ -68,9 +71,12 @@ import type {
   B24V2GetMessageResult,
   B24V2User,
   B24Keyboard,
+  ChannelMessageToolDiscovery,
+  ExtractedToolSendTarget,
   KeyboardButton,
   Logger,
 } from './types.js';
+import { markdownToBbCode } from './message-utils.js';
 
 const PHASE_STATUS_DURATION_SECONDS = 8;
 const PHASE_STATUS_REFRESH_GRACE_MS = 1000;
@@ -93,7 +99,24 @@ const FORWARDED_CONTEXT_RANGE = 5;
 const ACTIVE_SESSION_NAMESPACE_TTL_MS = 180 * 24 * 60 * 60 * 1000;
 const ACTIVE_SESSION_NAMESPACE_MAX_KEYS = 1000;
 const ACTIVE_SESSION_NAMESPACE_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+const NATIVE_FORWARD_ACK_TTL_MS = 60 * 1000;
+const NATIVE_REACTION_ACK_TTL_MS = 60 * 1000;
+const RECENT_INBOUND_MESSAGE_TTL_MS = 30 * 60 * 1000;
+const RECENT_INBOUND_MESSAGE_LIMIT = 20;
 const REGISTERED_COMMANDS = new Set(OPENCLAW_COMMANDS.map((command) => command.command));
+const pendingNativeForwardAcks = new Map<string, number>();
+const pendingNativeReactionAcks = new Map<string, { emoji: string; expiresAt: number }>();
+const recentInboundMessagesByDialog = new Map<string, Array<{
+  messageId: string;
+  body: string;
+  timestamp: number;
+}>>();
+const inboundMessageContextById = new Map<string, {
+  dialogId: string;
+  dialogKey: string;
+  body: string;
+  timestamp: number;
+}>();
 
 // ─── Emoji → B24 reaction code mapping ──────────────────────────────────
 // B24 uses named reaction codes, not Unicode emoji.
@@ -169,6 +192,606 @@ function toMessageId(value: string | number | undefined): number | undefined {
   return Number.isFinite(parsed) && parsed > 0 ? parsed : undefined;
 }
 
+function resolveStateAccountId(accountId?: string): string {
+  const normalizedAccountId = typeof accountId === 'string'
+    ? accountId.trim()
+    : '';
+  if (normalizedAccountId) {
+    return normalizedAccountId;
+  }
+
+  const gatewayAccountId = gatewayState?.accountId?.trim();
+  return gatewayAccountId || 'default';
+}
+
+function buildAccountDialogScopeKey(accountId: string | undefined, dialogId: string): string | undefined {
+  const normalizedDialogId = dialogId.trim();
+  if (!normalizedDialogId) {
+    return undefined;
+  }
+
+  return `${resolveStateAccountId(accountId)}:${normalizedDialogId}`;
+}
+
+function buildAccountMessageScopeKey(
+  accountId: string | undefined,
+  currentMessageId: string | number | undefined,
+): string | undefined {
+  const normalizedMessageId = toMessageId(currentMessageId);
+  if (!normalizedMessageId) {
+    return undefined;
+  }
+
+  return `${resolveStateAccountId(accountId)}:${normalizedMessageId}`;
+}
+
+function buildPendingNativeForwardAckKey(
+  dialogId: string,
+  currentMessageId: string | number | undefined,
+  accountId?: string,
+): string | undefined {
+  const dialogKey = buildAccountDialogScopeKey(accountId, dialogId);
+  const normalizedMessageId = toMessageId(currentMessageId);
+  if (!dialogKey || !normalizedMessageId) {
+    return undefined;
+  }
+
+  return `${dialogKey}:${normalizedMessageId}`;
+}
+
+function prunePendingNativeForwardAcks(now = Date.now()): void {
+  for (const [key, expiresAt] of pendingNativeForwardAcks.entries()) {
+    if (!Number.isFinite(expiresAt) || expiresAt <= now) {
+      pendingNativeForwardAcks.delete(key);
+    }
+  }
+}
+
+function markPendingNativeForwardAck(
+  dialogId: string,
+  currentMessageId: string | number | undefined,
+  accountId?: string,
+): void {
+  const key = buildPendingNativeForwardAckKey(dialogId, currentMessageId, accountId);
+  if (!key) {
+    return;
+  }
+
+  prunePendingNativeForwardAcks();
+  pendingNativeForwardAcks.set(key, Date.now() + NATIVE_FORWARD_ACK_TTL_MS);
+}
+
+function consumePendingNativeForwardAck(
+  dialogId: string,
+  currentMessageId: string | number | undefined,
+  accountId?: string,
+): boolean {
+  const key = buildPendingNativeForwardAckKey(dialogId, currentMessageId, accountId);
+  if (!key) {
+    return false;
+  }
+
+  prunePendingNativeForwardAcks();
+  const expiresAt = pendingNativeForwardAcks.get(key);
+  if (!expiresAt) {
+    return false;
+  }
+
+  pendingNativeForwardAcks.delete(key);
+  return true;
+}
+
+function resolvePendingNativeForwardAckDialogId(
+  currentMessageId: string | number | undefined,
+  fallbackDialogId: string,
+  accountId?: string,
+): string {
+  const messageKey = buildAccountMessageScopeKey(accountId, currentMessageId);
+  if (!messageKey) {
+    return fallbackDialogId;
+  }
+
+  return inboundMessageContextById.get(messageKey)?.dialogId ?? fallbackDialogId;
+}
+
+function buildPendingNativeReactionAckKey(
+  currentMessageId: string | number | undefined,
+  accountId?: string,
+): string | undefined {
+  return buildAccountMessageScopeKey(accountId, currentMessageId);
+}
+
+function prunePendingNativeReactionAcks(now = Date.now()): void {
+  for (const [key, entry] of pendingNativeReactionAcks.entries()) {
+    if (!entry || !Number.isFinite(entry.expiresAt) || entry.expiresAt <= now) {
+      pendingNativeReactionAcks.delete(key);
+    }
+  }
+}
+
+function markPendingNativeReactionAck(
+  currentMessageId: string | number | undefined,
+  emoji: string,
+  accountId?: string,
+): void {
+  const key = buildPendingNativeReactionAckKey(currentMessageId, accountId);
+  const normalizedEmoji = emoji.trim();
+  if (!key || !normalizedEmoji) {
+    return;
+  }
+
+  prunePendingNativeReactionAcks();
+  pendingNativeReactionAcks.set(key, {
+    emoji: normalizedEmoji,
+    expiresAt: Date.now() + NATIVE_REACTION_ACK_TTL_MS,
+  });
+}
+
+function consumePendingNativeReactionAck(
+  currentMessageId: string | number | undefined,
+  text: string,
+  accountId?: string,
+): boolean {
+  const key = buildPendingNativeReactionAckKey(currentMessageId, accountId);
+  if (!key) {
+    return false;
+  }
+
+  prunePendingNativeReactionAcks();
+  const pendingAck = pendingNativeReactionAcks.get(key);
+  if (!pendingAck) {
+    return false;
+  }
+
+  if (normalizeComparableMessageText(text) !== pendingAck.emoji) {
+    return false;
+  }
+
+  pendingNativeReactionAcks.delete(key);
+  return true;
+}
+
+function pruneRecentInboundMessages(now = Date.now()): void {
+  for (const [dialogKey, entries] of recentInboundMessagesByDialog.entries()) {
+    const nextEntries = entries.filter((entry) => Number.isFinite(entry.timestamp) && entry.timestamp > now - RECENT_INBOUND_MESSAGE_TTL_MS);
+    if (nextEntries.length === 0) {
+      recentInboundMessagesByDialog.delete(dialogKey);
+    } else if (nextEntries.length !== entries.length) {
+      recentInboundMessagesByDialog.set(dialogKey, nextEntries);
+    }
+  }
+
+  for (const [messageId, entry] of inboundMessageContextById.entries()) {
+    if (!Number.isFinite(entry.timestamp) || entry.timestamp <= now - RECENT_INBOUND_MESSAGE_TTL_MS) {
+      inboundMessageContextById.delete(messageId);
+    }
+  }
+}
+
+function rememberRecentInboundMessage(
+  dialogId: string,
+  messageId: string | number | undefined,
+  body: string,
+  timestamp = Date.now(),
+  accountId?: string,
+): void {
+  const normalizedMessageId = toMessageId(messageId);
+  const normalizedBody = body.trim();
+  const dialogKey = buildAccountDialogScopeKey(accountId, dialogId);
+  const messageKey = buildAccountMessageScopeKey(accountId, normalizedMessageId);
+  if (!dialogKey || !messageKey || !normalizedBody) {
+    return;
+  }
+
+  pruneRecentInboundMessages(timestamp);
+
+  const id = String(normalizedMessageId);
+  const currentEntries = recentInboundMessagesByDialog.get(dialogKey) ?? [];
+  const nextEntries = currentEntries
+    .filter((entry) => entry.messageId !== id)
+    .concat({ messageId: id, body: normalizedBody, timestamp })
+    .slice(-RECENT_INBOUND_MESSAGE_LIMIT);
+
+  recentInboundMessagesByDialog.set(dialogKey, nextEntries);
+  inboundMessageContextById.set(messageKey, {
+    dialogId,
+    dialogKey,
+    body: normalizedBody,
+    timestamp,
+  });
+}
+
+function findPreviousRecentInboundMessage(
+  currentMessageId: string | number | undefined,
+  accountId?: string,
+): { messageId: string; body: string } | undefined {
+  const messageKey = buildAccountMessageScopeKey(accountId, currentMessageId);
+  const normalizedMessageId = toMessageId(currentMessageId);
+  if (!messageKey || !normalizedMessageId) {
+    return undefined;
+  }
+
+  pruneRecentInboundMessages();
+
+  const currentEntry = inboundMessageContextById.get(messageKey);
+  if (!currentEntry) {
+    return undefined;
+  }
+
+  const dialogEntries = recentInboundMessagesByDialog.get(currentEntry.dialogKey);
+  if (!dialogEntries || dialogEntries.length === 0) {
+    return undefined;
+  }
+
+  const currentIndex = dialogEntries.findIndex((entry) => entry.messageId === String(normalizedMessageId));
+  if (currentIndex <= 0) {
+    return undefined;
+  }
+
+  for (let index = currentIndex - 1; index >= 0; index -= 1) {
+    const entry = dialogEntries[index];
+    if (entry.body.trim()) {
+      return entry;
+    }
+  }
+
+  return undefined;
+}
+
+const INLINE_REPLY_DIRECTIVE_RE = /\[\[\s*(reply_to_current|reply_to\s*:\s*([^\]\n]+))\s*\]\]/gi;
+
+function normalizeComparableMessageText(value: string): string {
+  return value
+    .replace(/\s+/g, ' ')
+    .trim();
+}
+
+function normalizeBitrix24DialogTarget(raw: string): string {
+  const stripped = raw.trim().replace(CHANNEL_PREFIX_RE, '');
+  if (!stripped) {
+    return '';
+  }
+
+  const bracketedUserMatch = stripped.match(/^\[USER=(\d+)(?:[^\]]*)\][\s\S]*?\[\/USER\]$/iu);
+  if (bracketedUserMatch?.[1]) {
+    return bracketedUserMatch[1];
+  }
+
+  const bracketedChatMatch = stripped.match(/^\[CHAT=(?:chat)?(\d+)(?:[^\]]*)\][\s\S]*?\[\/CHAT\]$/iu);
+  if (bracketedChatMatch?.[1]) {
+    return `chat${bracketedChatMatch[1]}`;
+  }
+
+  const plainUserMatch = stripped.match(/^USER=(\d+)$/iu);
+  if (plainUserMatch?.[1]) {
+    return plainUserMatch[1];
+  }
+
+  const plainChatMatch = stripped.match(/^CHAT=(?:chat)?(\d+)$/iu);
+  if (plainChatMatch?.[1]) {
+    return `chat${plainChatMatch[1]}`;
+  }
+
+  const prefixedChatMatch = stripped.match(/^chat(\d+)$/iu);
+  if (prefixedChatMatch?.[1]) {
+    return `chat${prefixedChatMatch[1]}`;
+  }
+
+  return stripped;
+}
+
+function looksLikeBitrix24DialogTarget(raw: string): boolean {
+  const normalized = normalizeBitrix24DialogTarget(raw);
+  return /^\d+$/.test(normalized) || /^chat\d+$/iu.test(normalized);
+}
+
+function extractBitrix24DialogTargetsFromText(text: string): string[] {
+  const targets = new Set<string>();
+
+  for (const match of text.matchAll(/\[CHAT=(?:chat)?(\d+)(?:[^\]]*)\][\s\S]*?\[\/CHAT\]/giu)) {
+    if (match[1]) {
+      targets.add(`chat${match[1]}`);
+    }
+  }
+
+  for (const match of text.matchAll(/\[USER=(\d+)(?:[^\]]*)\][\s\S]*?\[\/USER\]/giu)) {
+    if (match[1]) {
+      targets.add(match[1]);
+    }
+  }
+
+  for (const match of text.matchAll(/\bCHAT=(?:chat)?(\d+)\b/giu)) {
+    if (match[1]) {
+      targets.add(`chat${match[1]}`);
+    }
+  }
+
+  for (const match of text.matchAll(/\bUSER=(\d+)\b/giu)) {
+    if (match[1]) {
+      targets.add(match[1]);
+    }
+  }
+
+  return [...targets];
+}
+
+function isLikelyForwardControlMessage(text: string): boolean {
+  return extractBitrix24DialogTargetsFromText(text).length > 0;
+}
+
+function extractReplyDirective(params: {
+  text: string;
+  currentMessageId?: string | number;
+  explicitReplyToId?: unknown;
+}): { cleanText: string; replyToMessageId?: number } {
+  let wantsCurrentReply = false;
+  let inlineReplyToId: string | undefined;
+
+  const cleanText = cleanupTextAfterInlineMediaExtraction(
+    params.text.replace(INLINE_REPLY_DIRECTIVE_RE, (_match: string, _rawDirective: string, explicitId?: string) => {
+      if (typeof explicitId === 'string' && explicitId.trim()) {
+        inlineReplyToId = explicitId.trim();
+      } else {
+        wantsCurrentReply = true;
+      }
+      return ' ';
+    }),
+  );
+
+  const explicitReplyToMessageId = parseActionMessageIds(params.explicitReplyToId)[0];
+  if (explicitReplyToMessageId) {
+    return { cleanText, replyToMessageId: explicitReplyToMessageId };
+  }
+
+  const inlineReplyToMessageId = parseActionMessageIds(inlineReplyToId)[0];
+  if (inlineReplyToMessageId) {
+    return { cleanText, replyToMessageId: inlineReplyToMessageId };
+  }
+
+  if (wantsCurrentReply) {
+    const currentReplyToMessageId = parseActionMessageIds(params.currentMessageId)[0];
+    if (currentReplyToMessageId) {
+      return { cleanText, replyToMessageId: currentReplyToMessageId };
+    }
+  }
+
+  return { cleanText };
+}
+
+function findNativeForwardTarget(params: {
+  accountId?: string;
+  requestText: string;
+  deliveredText: string;
+  historyEntries: HistoryEntry[];
+  currentMessageId?: string | number;
+}): number | undefined {
+  const deliveredText = normalizeComparableMessageText(params.deliveredText);
+  if (!deliveredText) {
+    return undefined;
+  }
+
+  if (deliveredText === normalizeComparableMessageText(params.requestText)) {
+    return undefined;
+  }
+
+  const currentMessageId = toMessageId(params.currentMessageId);
+
+  const matchedEntry = [...params.historyEntries]
+    .reverse()
+    .find((entry) => {
+      if (normalizeComparableMessageText(entry.body) !== deliveredText) {
+        return false;
+      }
+
+      return currentMessageId === undefined || toMessageId(entry.messageId) !== currentMessageId;
+    });
+
+  if (!matchedEntry) {
+    return undefined;
+  }
+
+  return toMessageId(matchedEntry.messageId);
+}
+
+function findImplicitForwardTargetFromRecentInbound(params: {
+  accountId?: string;
+  requestText: string;
+  deliveredText: string;
+  currentMessageId?: string | number;
+  historyEntries?: HistoryEntry[];
+}): number | undefined {
+  const normalizedDeliveredText = normalizeComparableMessageText(params.deliveredText);
+  const normalizedRequestText = normalizeComparableMessageText(params.requestText);
+  const targetDialogIds = extractBitrix24DialogTargetsFromText(params.requestText);
+  const isForwardMarkerOnly = Boolean(normalizedDeliveredText) && FORWARD_MARKER_RE.test(normalizedDeliveredText);
+
+  if (
+    !normalizedDeliveredText
+    || (
+      !isForwardMarkerOnly
+      && (
+        targetDialogIds.length === 0
+        || normalizedDeliveredText !== normalizedRequestText
+      )
+    )
+  ) {
+    return undefined;
+  }
+
+  const previousInboundMessage = findPreviousRecentInboundMessage(
+    params.currentMessageId,
+    params.accountId,
+  );
+  if (previousInboundMessage) {
+    return Number(previousInboundMessage.messageId);
+  }
+
+  const previousHistoryEntry = [...(params.historyEntries ?? [])]
+    .reverse()
+    .find((entry) => toMessageId(entry.messageId));
+  return toMessageId(previousHistoryEntry?.messageId);
+}
+
+function findPreviousForwardableMessageId(params: {
+  accountId?: string;
+  currentBody: string;
+  currentMessageId?: string | number;
+  replyToMessageId?: string | number;
+  historyEntries?: HistoryEntry[];
+}): number | undefined {
+  // If the user replied to a specific message, that's the source to forward
+  const replyToId = toMessageId(params.replyToMessageId);
+  if (replyToId) {
+    return replyToId;
+  }
+
+  const normalizedCurrentBody = normalizeComparableMessageText(params.currentBody);
+  const previousHistoryEntry = [...(params.historyEntries ?? [])]
+    .reverse()
+    .find((entry) => {
+      const messageId = toMessageId(entry.messageId);
+      const normalizedBody = normalizeComparableMessageText(entry.body);
+      if (!messageId || !normalizedBody) {
+        return false;
+      }
+
+      if (normalizedCurrentBody && normalizedBody === normalizedCurrentBody) {
+        return false;
+      }
+
+      return !isLikelyForwardControlMessage(entry.body);
+    });
+  if (previousHistoryEntry) {
+    return toMessageId(previousHistoryEntry.messageId);
+  }
+
+  const previousInboundMessage = findPreviousRecentInboundMessage(
+    params.currentMessageId,
+    params.accountId,
+  );
+  if (previousInboundMessage) {
+    if (
+      normalizeComparableMessageText(previousInboundMessage.body) !== normalizedCurrentBody
+      && !isLikelyForwardControlMessage(previousInboundMessage.body)
+    ) {
+      return Number(previousInboundMessage.messageId);
+    }
+  }
+
+  return undefined;
+}
+
+function buildBitrix24NativeForwardAgentHint(params: {
+  accountId?: string;
+  currentBody: string;
+  currentMessageId?: string | number;
+  replyToMessageId?: string | number;
+  historyEntries?: HistoryEntry[];
+}): string | undefined {
+  const targetDialogIds = extractBitrix24DialogTargetsFromText(params.currentBody);
+  const sourceMessageId = findPreviousForwardableMessageId(params);
+  if (!sourceMessageId) {
+    return undefined;
+  }
+
+  const formattedTargets = targetDialogIds
+    .map((dialogId) => (dialogId.startsWith('chat') ? `${dialogId} (chat)` : `${dialogId} (user)`))
+    .join(', ');
+
+  const lines = [
+    '[Bitrix24 native forward instruction]',
+    'Use this only if you intentionally want a native Bitrix24 forward instead of repeating visible text.',
+    `Previous Bitrix24 message id available for forwarding: ${sourceMessageId}.`,
+    'Use action "send" with "forwardMessageIds" set to that source message id.',
+    'If the tool requires a non-empty message field for a pure forward, use "↩️".',
+    'Do not repeat the source message text or the user instruction text when doing a native forward.',
+  ];
+
+  if (formattedTargets) {
+    lines.push(`Explicit target dialog ids mentioned in the current message: ${formattedTargets}.`);
+    lines.push('If you forward to those explicit targets, send one message-tool call per target dialog id and set "to" to the exact dialog id shown above.');
+    lines.push('Do not use CHAT=xxx or USER=xxx format for "to" — use "chat520" or "77" directly.');
+  } else {
+    lines.push('If you forward in the current dialog, do not set "to" to another dialog id.');
+  }
+
+  lines.push('[/Bitrix24 native forward instruction]');
+  return lines.join('\n');
+}
+
+function buildBitrix24NativeReplyAgentHint(currentMessageId: string | number | undefined): string | undefined {
+  const normalizedMessageId = toMessageId(currentMessageId);
+  if (!normalizedMessageId) {
+    return undefined;
+  }
+
+  return [
+    '[Bitrix24 native reply instruction]',
+    `Current Bitrix24 message id: ${normalizedMessageId}.`,
+    'If you intentionally want a native Bitrix24 reply to the current inbound message, set "replyToMessageId" to that id.',
+    'For text-only payloads you can also prepend [[reply_to_current]] to the reply text.',
+    'Do not use a native reply unless you actually want reply threading.',
+    '[/Bitrix24 native reply instruction]',
+  ].join('\n');
+}
+
+function buildBitrix24FileDeliveryAgentHint(): string {
+  return [
+    '[Bitrix24 file delivery instruction]',
+    'When you need to deliver a real file or document to the user, use structured reply payload field "mediaUrl" or "mediaUrls".',
+    'Set "mediaUrl" to the local path of the generated file in the OpenClaw workspace or managed media directory.',
+    'Use "text" only for an optional short caption.',
+    'Do not place local file paths inside markdown links or plain text, because that only sends text to the user and does not upload the file.',
+    '[/Bitrix24 file delivery instruction]',
+  ].join('\n');
+}
+
+function readExplicitForwardMessageIds(rawParams: Record<string, unknown>): number[] {
+  return parseActionMessageIds(
+    rawParams.forwardMessageIds
+    ?? rawParams.forwardIds,
+  );
+}
+
+function resolveActionForwardMessageIds(params: {
+  accountId?: string;
+  rawParams: Record<string, unknown>;
+  toolContext?: { currentMessageId?: string | number };
+}): number[] {
+  const explicitForwardMessages = readExplicitForwardMessageIds(params.rawParams);
+  if (explicitForwardMessages.length > 0) {
+    return explicitForwardMessages;
+  }
+
+  const aliasedForwardMessages = parseActionMessageIds(
+    params.rawParams.messageIds
+    ?? params.rawParams.message_ids
+    ?? params.rawParams.messageId
+    ?? params.rawParams.message_id
+    ?? params.rawParams.replyToMessageId
+    ?? params.rawParams.replyToId,
+  );
+  if (aliasedForwardMessages.length > 0) {
+    return aliasedForwardMessages;
+  }
+
+  const previousInboundMessage = findPreviousRecentInboundMessage(
+    params.toolContext?.currentMessageId,
+    params.accountId,
+  );
+  return previousInboundMessage ? [Number(previousInboundMessage.messageId)] : [];
+}
+
+const FORWARD_MARKER_RE = /^[\s↩️➡️→⤵️🔄📨]+$/u;
+
+function normalizeForwardActionText(text: string | null): string {
+  const normalizedText = typeof text === 'string' ? text.trim() : '';
+  if (!normalizedText || FORWARD_MARKER_RE.test(normalizedText)) {
+    return '';
+  }
+  return normalizedText;
+}
+
 function escapeBbCodeText(value: string): string {
   return value
     .replace(/\[/g, '(')
@@ -1050,51 +1673,484 @@ interface GatewayState {
   eventMode: 'fetch' | 'webhook';
 }
 
-let gatewayState: GatewayState | null = null;
+let gatewayState: GatewayState | null = null;
+
+export function __setGatewayStateForTests(state: GatewayState | null): void {
+  gatewayState = state;
+  if (state === null) {
+    pendingNativeForwardAcks.clear();
+    pendingNativeReactionAcks.clear();
+    recentInboundMessagesByDialog.clear();
+    inboundMessageContextById.clear();
+  }
+}
+
+export function __rememberRecentInboundMessageForTests(params: {
+  accountId?: string;
+  dialogId: string;
+  messageId: string | number;
+  body: string;
+  timestamp?: number;
+}): void {
+  rememberRecentInboundMessage(
+    params.dialogId,
+    params.messageId,
+    params.body,
+    params.timestamp,
+    params.accountId,
+  );
+}
+
+// ─── Keyboard layouts ────────────────────────────────────────────────────────
+
+export function buildWelcomeKeyboard(language?: string): B24Keyboard {
+  const labels = welcomeKeyboardLabels(language);
+
+  return [
+    { TEXT: labels.todayTasks, ACTION: 'SEND', ACTION_VALUE: labels.todayTasks, DISPLAY: 'LINE' },
+    { TEXT: labels.stalledDeals, ACTION: 'SEND', ACTION_VALUE: labels.stalledDeals, DISPLAY: 'LINE' },
+    { TYPE: 'NEWLINE' },
+    { TEXT: labels.newSession, COMMAND: 'new', DISPLAY: 'LINE' },
+    { TEXT: labels.commands, COMMAND: 'commands', DISPLAY: 'LINE' },
+    { TEXT: labels.help, COMMAND: 'help', BG_COLOR_TOKEN: 'primary', DISPLAY: 'LINE' },
+  ];
+}
+
+/** Default keyboard shown with command responses and welcome messages. */
+export function buildDefaultCommandKeyboard(language?: string): B24Keyboard {
+  const labels = commandKeyboardLabels(language);
+
+  return [
+    { TEXT: labels.help, COMMAND: 'help', BG_COLOR_TOKEN: 'primary', DISPLAY: 'LINE' },
+    { TEXT: labels.status, COMMAND: 'status', DISPLAY: 'LINE' },
+    { TEXT: labels.commands, COMMAND: 'commands', DISPLAY: 'LINE' },
+    { TYPE: 'NEWLINE' },
+    { TEXT: labels.newSession, COMMAND: 'new', DISPLAY: 'LINE' },
+    { TEXT: labels.models, COMMAND: 'models', DISPLAY: 'LINE' },
+  ];
+}
+
+export const DEFAULT_COMMAND_KEYBOARD: B24Keyboard = buildDefaultCommandKeyboard();
+export const DEFAULT_WELCOME_KEYBOARD: B24Keyboard = buildWelcomeKeyboard();
+
+// ─── Keyboard / Button conversion ────────────────────────────────────────────
+
+/** Generic button format used by OpenClaw channelData. */
+export interface ChannelButton {
+  text: string;
+  callback_data?: string;
+  style?: string;
+}
+
+const BITRIX24_ACTION_NAMES = ['send', 'reply', 'react', 'edit', 'delete'] as const;
+const BITRIX24_DISCOVERY_ACTION_NAMES = ['send', 'reply', 'react', 'edit', 'delete'] as const;
+
+function buildMessageToolButtonsSchema(): Record<string, unknown> {
+  return {
+    type: 'array',
+    description: 'Optional Bitrix24 message buttons as rows of button objects.',
+    items: {
+      type: 'array',
+      items: {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+          text: {
+            type: 'string',
+            description: 'Visible button label.',
+          },
+          callback_data: {
+            type: 'string',
+            description: 'Registered command like /help, or any plain text payload to send when tapped.',
+          },
+          style: {
+            type: 'string',
+            enum: ['primary', 'attention', 'danger'],
+            description: 'Optional Bitrix24 button accent.',
+          },
+        },
+        required: ['text'],
+      },
+    },
+  };
+}
+
+function buildMessageToolAttachSchema(): Record<string, unknown> {
+  const blockSchema = {
+    type: 'object',
+    description: 'Single Bitrix24 ATTACH rich block. Supported top-level keys are MESSAGE, LINK, IMAGE, FILE, DELIMITER, GRID or USER.',
+  };
+
+  return {
+    description: 'Bitrix24 ATTACH rich layout blocks. Use this for rich cards, not for binary file uploads. For a status-owner-link card, prefer blocks like USER, LINK and GRID. Example: [{"USER":{"NAME":"Alice"}},{"LINK":{"NAME":"Open","LINK":"https://example.com"}},{"GRID":[{"NAME":"Status","VALUE":"In progress","DISPLAY":"LINE"},{"NAME":"Owner","VALUE":"Alice","DISPLAY":"LINE"}]}]. Use mediaUrl/mediaUrls for actual files and media.',
+    anyOf: [
+      {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+          ID: { type: 'integer' },
+          COLOR_TOKEN: {
+            type: 'string',
+            enum: ['primary', 'secondary', 'alert', 'base'],
+          },
+          COLOR: { type: 'string' },
+          BLOCKS: {
+            type: 'array',
+            items: blockSchema,
+          },
+        },
+        required: ['BLOCKS'],
+      },
+      {
+        type: 'array',
+        items: blockSchema,
+      },
+    ],
+  };
+}
+
+function buildMessageToolIdListSchema(description: string): Record<string, unknown> {
+  return {
+    anyOf: [
+      {
+        type: 'integer',
+        description,
+      },
+      {
+        type: 'string',
+        description: `${description} Can also be a comma-separated list or JSON array string.`,
+      },
+      {
+        type: 'array',
+        description,
+        items: {
+          type: 'integer',
+        },
+      },
+    ],
+  };
+}
+
+function resolveConfiguredBitrix24ActionAccounts(
+  cfg: Record<string, unknown>,
+  accountId?: string,
+): string[] {
+  if (accountId) {
+    const account = resolveAccount(cfg, accountId);
+    return account.enabled && account.configured ? [account.accountId] : [];
+  }
+
+  return listAccountIds(cfg).filter((candidateId) => {
+    const account = resolveAccount(cfg, candidateId);
+    return account.enabled && account.configured;
+  });
+}
+
+function describeBitrix24MessageTool(params: {
+  cfg: Record<string, unknown>;
+  accountId?: string;
+}): ChannelMessageToolDiscovery {
+  const configuredAccounts = resolveConfiguredBitrix24ActionAccounts(
+    params.cfg,
+    params.accountId,
+  );
+
+  if (configuredAccounts.length === 0) {
+    return {
+      actions: [],
+      capabilities: [],
+      schema: null,
+    };
+  }
+
+  return {
+    actions: [...BITRIX24_DISCOVERY_ACTION_NAMES],
+    capabilities: ['interactive', 'buttons', 'cards'],
+    schema: [
+      {
+        properties: {
+          buttons: buildMessageToolButtonsSchema(),
+        },
+      },
+      {
+        properties: {
+          attach: buildMessageToolAttachSchema(),
+          forwardMessageIds: buildMessageToolIdListSchema(
+            'Bitrix24 source message id(s) to forward natively. Use with action="send" plus to/target. Prefer the referenced message id, not the current instruction message id. The message field must be non-empty — use "↩️" (emoji) for a pure forward without extra text.',
+          ),
+          forwardIds: buildMessageToolIdListSchema(
+            'Alias for forwardMessageIds. Use with action="send".',
+          ),
+          replyToId: buildMessageToolIdListSchema(
+            'Bitrix24 message id to reply to natively inside the current dialog.',
+          ),
+          replyToMessageId: buildMessageToolIdListSchema(
+            'Alias for replyToId.',
+          ),
+        },
+      },
+    ],
+  };
+}
+
+function extractBitrix24ToolSend(args: Record<string, unknown>): ExtractedToolSendTarget | null {
+  if ((typeof args.action === 'string' ? args.action.trim() : '') !== 'sendMessage') {
+    return null;
+  }
+
+  const to = typeof args.to === 'string' ? normalizeBitrix24DialogTarget(args.to) : '';
+  if (!to) {
+    return null;
+  }
+
+  const accountId = typeof args.accountId === 'string'
+    ? args.accountId.trim()
+    : undefined;
+  const threadId = typeof args.threadId === 'number'
+    ? String(args.threadId)
+    : typeof args.threadId === 'string'
+      ? args.threadId.trim()
+      : '';
+
+  return {
+    to,
+    ...(accountId ? { accountId } : {}),
+    ...(threadId ? { threadId } : {}),
+  };
+}
+
+function readActionTextParam(params: Record<string, unknown>): string | null {
+  const rawText = params.message ?? params.text ?? params.content;
+  return typeof rawText === 'string' ? rawText : null;
+}
+
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+
+function isAttachColorToken(value: unknown): value is B24AttachColorToken {
+  return value === 'primary'
+    || value === 'secondary'
+    || value === 'alert'
+    || value === 'base';
+}
+
+function isAttachBlock(value: unknown): value is B24AttachBlock {
+  return isPlainObject(value) && Object.keys(value).length > 0;
+}
+
+function isBitrix24Attach(value: unknown): value is B24Attach {
+  if (Array.isArray(value)) {
+    return value.length > 0 && value.every(isAttachBlock);
+  }
+
+  if (!isPlainObject(value) || !Array.isArray(value.BLOCKS) || value.BLOCKS.length === 0) {
+    return false;
+  }
+
+  if (value.COLOR_TOKEN !== undefined && !isAttachColorToken(value.COLOR_TOKEN)) {
+    return false;
+  }
+
+  return value.BLOCKS.every(isAttachBlock);
+}
+
+function parseActionAttach(rawValue: unknown): B24Attach | undefined {
+  if (rawValue == null) {
+    return undefined;
+  }
+
+  let parsed = rawValue;
+  if (typeof rawValue === 'string') {
+    const trimmed = rawValue.trim();
+    if (!trimmed) {
+      return undefined;
+    }
+
+    try {
+      parsed = JSON.parse(trimmed);
+    } catch {
+      return undefined;
+    }
+  }
+
+  return isBitrix24Attach(parsed) ? parsed : undefined;
+}
+
+function hasMeaningfulAttachInput(rawValue: unknown): boolean {
+  if (rawValue == null) {
+    return false;
+  }
+
+  if (typeof rawValue === 'string') {
+    const trimmed = rawValue.trim();
+    if (!trimmed) {
+      return false;
+    }
+
+    try {
+      return hasMeaningfulAttachInput(JSON.parse(trimmed));
+    } catch {
+      return true;
+    }
+  }
+
+  if (Array.isArray(rawValue)) {
+    return rawValue.length > 0;
+  }
+
+  if (isPlainObject(rawValue)) {
+    if (Array.isArray(rawValue.BLOCKS)) {
+      return rawValue.BLOCKS.length > 0;
+    }
+
+    return Object.keys(rawValue).length > 0;
+  }
+
+  return true;
+}
+
+function readActionTargetParam(
+  params: Record<string, unknown>,
+  fallbackTarget?: unknown,
+): string {
+  const rawTarget = params.to ?? params.target ?? fallbackTarget;
+  return typeof rawTarget === 'string' ? normalizeBitrix24DialogTarget(rawTarget) : '';
+}
+
+function parseActionMessageIds(rawValue: unknown): number[] {
+  const ids: number[] = [];
+  const seen = new Set<number>();
+
+  const append = (value: unknown) => {
+    if (Array.isArray(value)) {
+      value.forEach(append);
+      return;
+    }
+
+    if (typeof value === 'number') {
+      const normalizedId = Math.trunc(value);
+      if (Number.isFinite(normalizedId) && normalizedId > 0 && !seen.has(normalizedId)) {
+        seen.add(normalizedId);
+        ids.push(normalizedId);
+      }
+      return;
+    }
+
+    if (typeof value !== 'string') {
+      return;
+    }
+
+    const trimmed = value.trim();
+    if (!trimmed) {
+      return;
+    }
+
+    if (trimmed.startsWith('[')) {
+      try {
+        append(JSON.parse(trimmed));
+        return;
+      } catch {
+        // Fall through to scalar / CSV parsing.
+      }
+    }
+
+    trimmed
+      .split(/[,\s]+/)
+      .forEach((part) => {
+        if (!part) {
+          return;
+        }
+        const normalizedId = Number(part);
+        if (Number.isFinite(normalizedId) && normalizedId > 0 && !seen.has(normalizedId)) {
+          seen.add(normalizedId);
+          ids.push(normalizedId);
+        }
+      });
+  };
+
+  append(rawValue);
+  return ids;
+}
+
+function parseActionKeyboard(rawButtons: unknown): B24Keyboard | undefined {
+  if (rawButtons == null) {
+    return undefined;
+  }
+
+  try {
+    const parsed = typeof rawButtons === 'string' ? JSON.parse(rawButtons) : rawButtons;
+    if (Array.isArray(parsed)) {
+      const keyboard = convertButtonsToKeyboard(parsed as ChannelButton[][] | ChannelButton[]);
+      return keyboard.length > 0 ? keyboard : undefined;
+    }
+  } catch {
+    // Ignore invalid buttons payload and send without keyboard.
+  }
 
-export function __setGatewayStateForTests(state: GatewayState | null): void {
-  gatewayState = state;
+  return undefined;
 }
 
-// ─── Keyboard layouts ────────────────────────────────────────────────────────
+function collectActionMediaUrls(params: Record<string, unknown>): string[] {
+  const mediaUrls: string[] = [];
+  const seen = new Set<string>();
 
-export function buildWelcomeKeyboard(language?: string): B24Keyboard {
-  const labels = welcomeKeyboardLabels(language);
+  const append = (value: unknown) => {
+    if (Array.isArray(value)) {
+      value.forEach(append);
+      return;
+    }
 
-  return [
-    { TEXT: labels.todayTasks, ACTION: 'SEND', ACTION_VALUE: labels.todayTasks, DISPLAY: 'LINE' },
-    { TEXT: labels.stalledDeals, ACTION: 'SEND', ACTION_VALUE: labels.stalledDeals, DISPLAY: 'LINE' },
-    { TYPE: 'NEWLINE' },
-    { TEXT: labels.newSession, COMMAND: 'new', DISPLAY: 'LINE' },
-    { TEXT: labels.commands, COMMAND: 'commands', DISPLAY: 'LINE' },
-    { TEXT: labels.help, COMMAND: 'help', BG_COLOR_TOKEN: 'primary', DISPLAY: 'LINE' },
-  ];
-}
+    if (typeof value !== 'string') {
+      return;
+    }
 
-/** Default keyboard shown with command responses and welcome messages. */
-export function buildDefaultCommandKeyboard(language?: string): B24Keyboard {
-  const labels = commandKeyboardLabels(language);
+    const trimmed = value.trim();
+    if (!trimmed) {
+      return;
+    }
 
-  return [
-    { TEXT: labels.help, COMMAND: 'help', BG_COLOR_TOKEN: 'primary', DISPLAY: 'LINE' },
-    { TEXT: labels.status, COMMAND: 'status', DISPLAY: 'LINE' },
-    { TEXT: labels.commands, COMMAND: 'commands', DISPLAY: 'LINE' },
-    { TYPE: 'NEWLINE' },
-    { TEXT: labels.newSession, COMMAND: 'new', DISPLAY: 'LINE' },
-    { TEXT: labels.models, COMMAND: 'models', DISPLAY: 'LINE' },
-  ];
+    if (trimmed.startsWith('[')) {
+      try {
+        append(JSON.parse(trimmed));
+        return;
+      } catch {
+        // Fall through to scalar handling.
+      }
+    }
+
+    if (!seen.has(trimmed)) {
+      seen.add(trimmed);
+      mediaUrls.push(trimmed);
+    }
+  };
+
+  append(params.mediaUrl);
+  append(params.mediaUrls);
+  append(params.filePath);
+  append(params.filePaths);
+
+  return mediaUrls;
 }
 
-export const DEFAULT_COMMAND_KEYBOARD: B24Keyboard = buildDefaultCommandKeyboard();
-export const DEFAULT_WELCOME_KEYBOARD: B24Keyboard = buildWelcomeKeyboard();
+function buildActionMessageText(params: {
+  text: string | null;
+  keyboard?: B24Keyboard;
+  attach?: B24Attach;
+}): string | null {
+  const normalizedText = typeof params.text === 'string'
+    ? markdownToBbCode(params.text.trim())
+    : '';
+
+  if (normalizedText) {
+    return normalizedText;
+  }
 
-// ─── Keyboard / Button conversion ────────────────────────────────────────────
+  if (params.attach) {
+    return null;
+  }
 
-/** Generic button format used by OpenClaw channelData. */
-export interface ChannelButton {
-  text: string;
-  callback_data?: string;
-  style?: string;
+  return params.keyboard ? ' ' : null;
 }
 
 function parseRegisteredCommandTrigger(callbackData: string): { command: string; commandParams?: string } | undefined {
@@ -1187,6 +2243,16 @@ export function extractKeyboardFromPayload(
   return undefined;
 }
 
+export function extractAttachFromPayload(
+  payload: { channelData?: Record<string, unknown> },
+): B24Attach | undefined {
+  const cd = payload.channelData;
+  if (!cd) return undefined;
+
+  const b24Data = cd.bitrix24 as { attach?: unknown; attachments?: unknown } | undefined;
+  return parseActionAttach(b24Data?.attach ?? b24Data?.attachments);
+}
+
 /**
  * Extract inline button JSON embedded in message text by the agent.
  *
@@ -1220,6 +2286,14 @@ export function extractInlineButtonsFromText(
   }
 }
 
+function cleanupTextAfterInlineMediaExtraction(text: string): string {
+  return text
+    .replace(/[ \t]+\n/g, '\n')
+    .replace(/\n{3,}/g, '\n\n')
+    .replace(/[ \t]{2,}/g, ' ')
+    .trim();
+}
+
 function normalizeCommandReplyPayload(params: {
   commandName: string;
   commandParams: string;
@@ -1577,11 +2651,12 @@ function resolveOutboundSendCtx(params: {
   accountId?: string;
 }): SendContext | null {
   const { config } = resolveAccount(params.cfg, params.accountId);
-  if (!config.webhookUrl || !gatewayState) return null;
+  const dialogId = normalizeBitrix24DialogTarget(params.to);
+  if (!config.webhookUrl || !gatewayState || !dialogId) return null;
   return {
     webhookUrl: config.webhookUrl,
     bot: gatewayState.bot,
-    dialogId: params.to,
+    dialogId,
   };
 }
 
@@ -1665,13 +2740,10 @@ export const bitrix24Plugin = {
   },
 
   messaging: {
-    normalizeTarget: (raw: string) => raw.trim().replace(CHANNEL_PREFIX_RE, ''),
+    normalizeTarget: (raw: string) => normalizeBitrix24DialogTarget(raw),
     targetResolver: {
-      hint: 'Use a numeric chat/dialog ID, e.g. "1" or "chat42".',
-      looksLikeId: (raw: string, _normalized: string) => {
-        const stripped = raw.trim().replace(CHANNEL_PREFIX_RE, '');
-        return /^\d+$/.test(stripped);
-      },
+      hint: 'Use a numeric dialog ID like "1", a group dialog like "chat42", or Bitrix mentions like "[USER=1]John[/USER]" / "[CHAT=42]Team[/CHAT]".',
+      looksLikeId: (raw: string, _normalized: string) => looksLikeBitrix24DialogTarget(raw),
     },
   },
 
@@ -1786,25 +2858,46 @@ export const bitrix24Plugin = {
       const sendCtx = resolveOutboundSendCtx(ctx);
       if (!sendCtx || !gatewayState) throw new Error('Bitrix24 gateway not started');
 
+      const text = ctx.text;
+
       const keyboard = ctx.payload?.channelData
         ? extractKeyboardFromPayload({ channelData: ctx.payload.channelData })
         : undefined;
+      const attach = ctx.payload?.channelData
+        ? extractAttachFromPayload({ channelData: ctx.payload.channelData })
+        : undefined;
       const mediaUrls = collectOutboundMediaUrls({
         mediaUrl: ctx.mediaUrl,
         payload: ctx.payload as { mediaUrl?: string; mediaUrls?: string[] } | undefined,
       });
 
       if (mediaUrls.length > 0) {
+        const initialMessage = !keyboard && !attach ? text || undefined : undefined;
         const uploadedMessageId = await uploadOutboundMedia({
           mediaService: gatewayState.mediaService,
           sendCtx,
           mediaUrls,
+          initialMessage,
         });
 
-        if (ctx.text) {
+        if ((text && !initialMessage) || keyboard || attach) {
+          if (attach) {
+            const messageId = await gatewayState.api.sendMessage(
+              sendCtx.webhookUrl,
+              sendCtx.bot,
+              sendCtx.dialogId,
+              buildActionMessageText({ text, keyboard, attach }),
+              {
+                ...(keyboard ? { keyboard } : {}),
+                attach,
+              },
+            );
+            return { messageId: String(messageId || uploadedMessageId) };
+          }
+
           const result = await gatewayState.sendService.sendText(
             sendCtx,
-            ctx.text,
+            text || '',
             keyboard ? { keyboard } : undefined,
           );
           return { messageId: String(result.messageId ?? uploadedMessageId) };
@@ -1813,10 +2906,24 @@ export const bitrix24Plugin = {
         return { messageId: uploadedMessageId };
       }
 
-      if (ctx.text) {
+      if (text || keyboard || attach) {
+        if (attach) {
+          const messageId = await gatewayState.api.sendMessage(
+            sendCtx.webhookUrl,
+            sendCtx.bot,
+            sendCtx.dialogId,
+            buildActionMessageText({ text, keyboard, attach }),
+            {
+              ...(keyboard ? { keyboard } : {}),
+              attach,
+            },
+          );
+          return { messageId: String(messageId ?? '') };
+        }
+
         const result = await gatewayState.sendService.sendText(
           sendCtx,
-          ctx.text,
+          text || '',
           keyboard ? { keyboard } : undefined,
         );
         return { messageId: String(result.messageId ?? '') };
@@ -1828,12 +2935,23 @@ export const bitrix24Plugin = {
   // ─── Actions (agent-driven: reactions, etc.) ────────────────────────────
 
   actions: {
+    describeMessageTool: (params: {
+      cfg: Record<string, unknown>;
+      accountId?: string;
+    }): ChannelMessageToolDiscovery => describeBitrix24MessageTool(params),
+
+    extractToolSend: (params: {
+      args: Record<string, unknown>;
+    }): ExtractedToolSendTarget | null => extractBitrix24ToolSend(params.args),
+
     listActions: (_params: { cfg: Record<string, unknown> }): string[] => {
-      return ['react', 'send'];
+      return [...BITRIX24_DISCOVERY_ACTION_NAMES];
     },
 
     supportsAction: (params: { action: string }): boolean => {
-      return params.action === 'react' || params.action === 'send';
+      return BITRIX24_ACTION_NAMES.includes(
+        params.action as typeof BITRIX24_ACTION_NAMES[number],
+      );
     },
 
     handleAction: async (ctx: {
@@ -1852,35 +2970,270 @@ export const bitrix24Plugin = {
 
       // ─── Send with buttons ──────────────────────────────────────────────
       if (ctx.action === 'send') {
-        // Only intercept send when buttons are present; otherwise let gateway handle normally
         const rawButtons = ctx.params.buttons;
-        if (!rawButtons) return null;
+        const rawAttach = ctx.params.attach ?? ctx.params.attachments;
 
         const { config } = resolveAccount(ctx.cfg, ctx.accountId);
         if (!config.webhookUrl || !gatewayState) return null;
 
         const bot = gatewayState.bot;
-        const to = String(ctx.params.to ?? ctx.to ?? '').trim();
+        const to = readActionTargetParam(ctx.params, ctx.to);
         if (!to) {
           defaultLogger.warn('handleAction send: no "to" in params or ctx, falling back to gateway');
           return null;
         }
 
         const sendCtx: SendContext = { webhookUrl: config.webhookUrl, bot, dialogId: to };
-        const message = String(ctx.params.message ?? '').trim();
+        const messageText = readActionTextParam(ctx.params);
+        const message = typeof messageText === 'string' ? messageText.trim() : '';
+        const keyboard = parseActionKeyboard(rawButtons);
+        const attach = parseActionAttach(rawAttach);
+        const mediaUrls = collectActionMediaUrls(ctx.params);
+        const toolContext = (ctx as Record<string, unknown>).toolContext as
+          | { currentMessageId?: string | number } | undefined;
+        const currentToolMessageId = toolContext?.currentMessageId;
+        const currentInboundContextKey = buildAccountMessageScopeKey(
+          ctx.accountId,
+          currentToolMessageId,
+        );
+        const currentInboundContext = currentInboundContextKey
+          ? inboundMessageContextById.get(currentInboundContextKey)
+          : undefined;
+        const forwardAckDialogId = resolvePendingNativeForwardAckDialogId(
+          currentToolMessageId,
+          to,
+          ctx.accountId,
+        );
+        const explicitForwardMessages = readExplicitForwardMessageIds(ctx.params);
+        const referencedReplyMessageId = parseActionMessageIds(
+          ctx.params.replyToMessageId ?? ctx.params.replyToId,
+        )[0];
+        if (hasMeaningfulAttachInput(rawAttach) && !attach) {
+          return toolResult({ ok: false, reason: 'invalid_attach', hint: 'Bitrix24 attach must use ATTACH rich blocks. Do not pass uploaded files here; use mediaUrl/mediaUrls for file uploads.' });
+        }
+        if (explicitForwardMessages.length > 0 && mediaUrls.length > 0) {
+          return toolResult({
+            ok: false,
+            reason: 'unsupported_payload_combo',
+            hint: 'Bitrix24 native forward cannot be combined with mediaUrl/mediaUrls uploads in one send action. Send the forward separately.',
+          });
+        }
+        if (!message && !keyboard && !attach && mediaUrls.length === 0 && explicitForwardMessages.length === 0) {
+          return toolResult({
+            ok: false,
+            reason: 'missing_payload',
+            hint: 'Provide message text, buttons, rich attach blocks or mediaUrl/mediaUrls for Bitrix24 send.',
+          });
+        }
 
-        // Parse buttons: may be array or JSON string
-        let buttons: ChannelButton[][] | undefined;
         try {
-          const parsed = typeof rawButtons === 'string' ? JSON.parse(rawButtons) : rawButtons;
-          if (Array.isArray(parsed)) buttons = parsed;
-        } catch {
-          // invalid buttons JSON — send without keyboard
-        }
+          if (explicitForwardMessages.length > 0) {
+            const normalizedForwardText = normalizeForwardActionText(messageText);
+
+            if (attach) {
+              const messageId = await gatewayState.api.sendMessage(
+                config.webhookUrl,
+                bot,
+                to,
+                buildActionMessageText({ text: normalizedForwardText, keyboard, attach }),
+                {
+                  ...(keyboard ? { keyboard } : {}),
+                  attach,
+                  forwardMessages: explicitForwardMessages,
+                },
+              );
+              markPendingNativeForwardAck(forwardAckDialogId, currentToolMessageId, ctx.accountId);
+              return toolResult({
+                channel: 'bitrix24',
+                to,
+                via: 'direct',
+                mediaUrl: null,
+                forwarded: true,
+                forwardMessages: explicitForwardMessages,
+                result: { messageId: String(messageId ?? '') },
+              });
+            }
+
+            const result = await gatewayState.sendService.sendText(
+              sendCtx,
+              normalizedForwardText || (keyboard ? ' ' : ''),
+              {
+                ...(keyboard ? { keyboard } : {}),
+                forwardMessages: explicitForwardMessages,
+              },
+            );
+            markPendingNativeForwardAck(forwardAckDialogId, currentToolMessageId, ctx.accountId);
+            return toolResult({
+              channel: 'bitrix24',
+              to,
+              via: 'direct',
+              mediaUrl: null,
+              forwarded: true,
+              forwardMessages: explicitForwardMessages,
+              result: { messageId: String(result.messageId ?? '') },
+            });
+          }
 
-        const keyboard = buttons?.length ? convertButtonsToKeyboard(buttons) : undefined;
+          if (referencedReplyMessageId && !attach && mediaUrls.length === 0) {
+            let referencedMessageText = '';
+
+            try {
+              const referencedMessage = await gatewayState.api.getMessage(
+                config.webhookUrl,
+                bot,
+                referencedReplyMessageId,
+              );
+              referencedMessageText = resolveFetchedMessageBody(referencedMessage.message?.text ?? '');
+            } catch (err) {
+              defaultLogger.debug('Failed to hydrate referenced Bitrix24 message for send action', err);
+            }
+
+            const normalizedReferencedMessage = normalizeComparableMessageText(referencedMessageText);
+            const normalizedMessage = normalizeComparableMessageText(message);
+
+            if (normalizedReferencedMessage && normalizedReferencedMessage === normalizedMessage) {
+              const result = await gatewayState.sendService.sendText(
+                sendCtx,
+                '',
+                { forwardMessages: [referencedReplyMessageId] },
+              );
+              markPendingNativeForwardAck(forwardAckDialogId, currentToolMessageId, ctx.accountId);
+              return toolResult({
+                channel: 'bitrix24',
+                to,
+                via: 'direct',
+                mediaUrl: null,
+                forwarded: true,
+                forwardMessages: [referencedReplyMessageId],
+                result: { messageId: String(result.messageId ?? '') },
+              });
+            }
+
+            const result = await gatewayState.sendService.sendText(
+              sendCtx,
+              message || ' ',
+              {
+                ...(keyboard ? { keyboard } : {}),
+                replyToMessageId: referencedReplyMessageId,
+              },
+            );
+            return toolResult({
+              channel: 'bitrix24',
+              to,
+              via: 'direct',
+              mediaUrl: null,
+              replied: true,
+              replyToMessageId: referencedReplyMessageId,
+              result: { messageId: String(result.messageId ?? '') },
+            });
+          }
+
+          const previousInboundMessage = findPreviousRecentInboundMessage(
+            currentToolMessageId,
+            ctx.accountId,
+          );
+
+          if (
+            !referencedReplyMessageId
+            && !attach
+            && mediaUrls.length === 0
+            && !keyboard
+            && previousInboundMessage
+            && currentInboundContext
+            && normalizeComparableMessageText(message)
+            && normalizeComparableMessageText(message) === normalizeComparableMessageText(previousInboundMessage.body)
+            && normalizeComparableMessageText(currentInboundContext.body) !== normalizeComparableMessageText(message)
+          ) {
+            const result = await gatewayState.sendService.sendText(
+              sendCtx,
+              '',
+              { forwardMessages: [Number(previousInboundMessage.messageId)] },
+            );
+            markPendingNativeForwardAck(forwardAckDialogId, currentToolMessageId, ctx.accountId);
+            return toolResult({
+              channel: 'bitrix24',
+              to,
+              via: 'direct',
+              mediaUrl: null,
+              forwarded: true,
+              forwardMessages: [Number(previousInboundMessage.messageId)],
+              result: { messageId: String(result.messageId ?? '') },
+            });
+          }
+
+          if (mediaUrls.length > 0) {
+            const initialMessage = !keyboard && !attach ? message || undefined : undefined;
+            const uploadedMessageId = await uploadOutboundMedia({
+              mediaService: gatewayState.mediaService,
+              sendCtx,
+              mediaUrls,
+              initialMessage,
+            });
+
+            if ((message && !initialMessage) || keyboard || attach) {
+              if (attach) {
+                const messageId = await gatewayState.api.sendMessage(
+                  config.webhookUrl,
+                  bot,
+                  to,
+                  buildActionMessageText({ text: message, keyboard, attach }),
+                  {
+                    ...(keyboard ? { keyboard } : {}),
+                    attach,
+                  },
+                );
+                return toolResult({
+                  channel: 'bitrix24',
+                  to,
+                  via: 'direct',
+                  mediaUrl: mediaUrls[0] ?? null,
+                  result: { messageId: String(messageId ?? uploadedMessageId) },
+                });
+              }
+
+              const result = await gatewayState.sendService.sendText(
+                sendCtx,
+                message || '',
+                keyboard ? { keyboard } : undefined,
+              );
+              return toolResult({
+                channel: 'bitrix24',
+                to,
+                via: 'direct',
+                mediaUrl: mediaUrls[0] ?? null,
+                result: { messageId: String(result.messageId ?? uploadedMessageId) },
+              });
+            }
+
+            return toolResult({
+              channel: 'bitrix24',
+              to,
+              via: 'direct',
+              mediaUrl: mediaUrls[0] ?? null,
+              result: { messageId: uploadedMessageId },
+            });
+          }
+
+          if (attach) {
+            const messageId = await gatewayState.api.sendMessage(
+              config.webhookUrl,
+              bot,
+              to,
+              buildActionMessageText({ text: message, keyboard, attach }),
+              {
+                ...(keyboard ? { keyboard } : {}),
+                attach,
+              },
+            );
+            return toolResult({
+              channel: 'bitrix24',
+              to,
+              via: 'direct',
+              mediaUrl: null,
+              result: { messageId: String(messageId ?? '') },
+            });
+          }
 
-        try {
           const result = await gatewayState.sendService.sendText(
             sendCtx, message || ' ', keyboard ? { keyboard } : undefined,
           );
@@ -1897,6 +3250,192 @@ export const bitrix24Plugin = {
         }
       }
 
+      if (ctx.action === 'reply') {
+        const { config } = resolveAccount(ctx.cfg, ctx.accountId);
+        if (!config.webhookUrl || !gatewayState) {
+          return toolResult({ ok: false, reason: 'not_started', hint: 'Bitrix24 gateway not started. Do not retry.' });
+        }
+
+        const params = ctx.params;
+        const bot = gatewayState.bot;
+        const to = readActionTargetParam(params, ctx.to);
+        if (!to) {
+          return toolResult({ ok: false, reason: 'missing_target', hint: 'Bitrix24 reply requires a target dialog id in "to" or "target". Do not retry.' });
+        }
+
+        const toolContext = (ctx as Record<string, unknown>).toolContext as
+          | { currentMessageId?: string | number } | undefined;
+        const replyToMessageId = parseActionMessageIds(
+          params.replyToMessageId
+          ?? params.replyToId
+          ?? params.messageId
+          ?? params.message_id
+          ?? toolContext?.currentMessageId,
+        )[0];
+
+        if (!replyToMessageId) {
+          return toolResult({ ok: false, reason: 'missing_message_id', hint: 'Bitrix24 reply requires a valid target messageId. Do not retry.' });
+        }
+
+        const text = readActionTextParam(params);
+        const normalizedText = typeof text === 'string' ? text.trim() : '';
+        const keyboard = parseActionKeyboard(params.buttons);
+        const rawAttach = params.attach ?? params.attachments;
+        const attach = parseActionAttach(rawAttach);
+        if (hasMeaningfulAttachInput(rawAttach) && !attach) {
+          return toolResult({ ok: false, reason: 'invalid_attach', hint: 'Bitrix24 attach must use ATTACH rich blocks. Do not pass uploaded files here; use mediaUrl/mediaUrls for file uploads.' });
+        }
+
+        if (!normalizedText && !keyboard && !attach) {
+          return toolResult({ ok: false, reason: 'missing_payload', hint: 'Provide reply text, buttons or rich attach blocks for Bitrix24 reply.' });
+        }
+
+        try {
+          if (attach) {
+            const messageId = await gatewayState.api.sendMessage(
+              config.webhookUrl,
+              bot,
+              to,
+              buildActionMessageText({ text: normalizedText, keyboard, attach }),
+              {
+                ...(keyboard ? { keyboard } : {}),
+                attach,
+                replyToMessageId,
+              },
+            );
+            return toolResult({
+              ok: true,
+              replied: true,
+              to,
+              replyToMessageId,
+              messageId: String(messageId ?? ''),
+            });
+          }
+
+          const result = await gatewayState.sendService.sendText(
+            { webhookUrl: config.webhookUrl, bot, dialogId: to },
+            normalizedText || ' ',
+            {
+              ...(keyboard ? { keyboard } : {}),
+              replyToMessageId,
+            },
+          );
+          return toolResult({
+            ok: true,
+            replied: true,
+            to,
+            replyToMessageId,
+            messageId: String(result.messageId ?? ''),
+          });
+        } catch (err) {
+          const errMsg = err instanceof Error ? err.message : String(err);
+          return toolResult({ ok: false, reason: 'error', hint: `Failed to send Bitrix24 reply: ${errMsg}. Do not retry.` });
+        }
+      }
+
+      // Note: "forward" action is not supported by OpenClaw runtime (not in
+      // MESSAGE_ACTION_TARGET_MODE), so the runtime blocks target before it
+      // reaches handleAction.  All forwarding goes through action "send" with
+      // forwardMessageIds parameter instead.
+
+      if (ctx.action === 'edit') {
+        const { config } = resolveAccount(ctx.cfg, ctx.accountId);
+        if (!config.webhookUrl || !gatewayState) {
+          return toolResult({ ok: false, reason: 'not_started', hint: 'Bitrix24 gateway not started. Do not retry.' });
+        }
+
+        const bot = gatewayState.bot;
+        const api = gatewayState.api;
+        const params = ctx.params;
+        const toolContext = (ctx as Record<string, unknown>).toolContext as
+          | { currentMessageId?: string | number } | undefined;
+        const rawMessageId = params.messageId ?? params.message_id ?? toolContext?.currentMessageId;
+        const messageId = Number(rawMessageId);
+
+        if (!Number.isFinite(messageId) || messageId <= 0) {
+          return toolResult({ ok: false, reason: 'missing_message_id', hint: 'Valid messageId is required for Bitrix24 edits. Do not retry.' });
+        }
+
+        let keyboard: B24Keyboard | 'N' | undefined;
+        if (params.buttons === 'N') {
+          keyboard = 'N';
+        } else if (params.buttons != null) {
+          try {
+            const parsed = typeof params.buttons === 'string'
+              ? JSON.parse(params.buttons)
+              : params.buttons;
+            if (Array.isArray(parsed)) {
+              keyboard = convertButtonsToKeyboard(parsed as ChannelButton[][] | ChannelButton[]);
+            }
+          } catch {
+            // Ignore invalid buttons payload and update text only.
+          }
+        }
+
+        const message = readActionTextParam(params);
+        const rawAttach = params.attach ?? params.attachments;
+        const attach = parseActionAttach(rawAttach);
+        if (hasMeaningfulAttachInput(rawAttach) && !attach) {
+          return toolResult({ ok: false, reason: 'invalid_attach', hint: 'Bitrix24 attach must use ATTACH rich blocks. Do not pass uploaded files here; use mediaUrl/mediaUrls for file uploads.' });
+        }
+
+        if (message == null && !keyboard && !attach) {
+          return toolResult({ ok: false, reason: 'missing_payload', hint: 'Provide message text, buttons or rich attach blocks for Bitrix24 edits.' });
+        }
+
+        try {
+          await api.updateMessage(
+            config.webhookUrl,
+            bot,
+            messageId,
+            message,
+            {
+              ...(keyboard ? { keyboard } : {}),
+              ...(attach ? { attach } : {}),
+            },
+          );
+          return toolResult({ ok: true, edited: true, messageId });
+        } catch (err) {
+          const errMsg = err instanceof Error ? err.message : String(err);
+          return toolResult({ ok: false, reason: 'error', hint: `Failed to edit message: ${errMsg}. Do not retry.` });
+        }
+      }
+
+      if (ctx.action === 'delete') {
+        const { config } = resolveAccount(ctx.cfg, ctx.accountId);
+        if (!config.webhookUrl || !gatewayState) {
+          return toolResult({ ok: false, reason: 'not_started', hint: 'Bitrix24 gateway not started. Do not retry.' });
+        }
+
+        const bot = gatewayState.bot;
+        const api = gatewayState.api;
+        const params = ctx.params;
+        const toolContext = (ctx as Record<string, unknown>).toolContext as
+          | { currentMessageId?: string | number } | undefined;
+        const rawMessageId = params.messageId ?? params.message_id ?? toolContext?.currentMessageId;
+        const messageId = Number(rawMessageId);
+
+        if (!Number.isFinite(messageId) || messageId <= 0) {
+          return toolResult({ ok: false, reason: 'missing_message_id', hint: 'Valid messageId is required for Bitrix24 deletes. Do not retry.' });
+        }
+
+        const complete = params.complete == null
+          ? undefined
+          : (
+            params.complete === true
+            || params.complete === 'true'
+            || params.complete === 'Y'
+          );
+
+        try {
+          await api.deleteMessage(config.webhookUrl, bot, messageId, complete);
+          return toolResult({ ok: true, deleted: true, messageId });
+        } catch (err) {
+          const errMsg = err instanceof Error ? err.message : String(err);
+          return toolResult({ ok: false, reason: 'error', hint: `Failed to delete message: ${errMsg}. Do not retry.` });
+        }
+      }
+
       // ─── React ────────────────────────────────────────────────────────────
       if (ctx.action !== 'react') return null;
 
@@ -1954,11 +3493,13 @@ export const bitrix24Plugin = {
 
       try {
         await api.addReaction(config.webhookUrl, bot, messageId, reactionCode);
+        markPendingNativeReactionAck(toolContext?.currentMessageId, emoji, ctx.accountId);
         return toolResult({ ok: true, added: emoji });
       } catch (err) {
         const errMsg = err instanceof Error ? err.message : String(err);
         const isAlreadySet = errMsg.includes('REACTION_ALREADY_SET');
         if (isAlreadySet) {
+          markPendingNativeReactionAck(toolContext?.currentMessageId, emoji, ctx.accountId);
           return toolResult({ ok: true, added: emoji, warning: 'Reaction already set.' });
         }
         return toolResult({ ok: false, reason: 'error', emoji, hint: `Reaction failed: ${errMsg}. Do not retry.` });
@@ -2326,9 +3867,22 @@ export const bitrix24Plugin = {
             query: bodyWithReply,
             historyCache,
           });
-          const bodyForAgent = crossChatContext
-            ? [crossChatContext, bodyWithReply].filter(Boolean).join('\n\n')
-            : bodyWithReply;
+          const fileDeliveryAgentHint = buildBitrix24FileDeliveryAgentHint();
+          const nativeReplyAgentHint = buildBitrix24NativeReplyAgentHint(msgCtx.messageId);
+          const nativeForwardAgentHint = buildBitrix24NativeForwardAgentHint({
+            accountId: ctx.accountId,
+            currentBody: body,
+            currentMessageId: msgCtx.messageId,
+            replyToMessageId: msgCtx.replyToMessageId,
+            historyEntries: previousEntries,
+          });
+          const bodyForAgent = [
+            fileDeliveryAgentHint,
+            nativeReplyAgentHint,
+            nativeForwardAgentHint,
+            crossChatContext,
+            bodyWithReply,
+          ].filter(Boolean).join('\n\n');
           const combinedBody = msgCtx.isGroup
             ? buildHistoryContext({
               entries: previousEntries,
@@ -2337,6 +3891,13 @@ export const bitrix24Plugin = {
             : bodyForAgent;
 
           recordHistory(body);
+          rememberRecentInboundMessage(
+            conversation.dialogId,
+            msgCtx.messageId,
+            body,
+            msgCtx.timestamp ?? Date.now(),
+            ctx.accountId,
+          );
 
           // Resolve which agent handles this conversation
           const route = runtime.channel.routing.resolveAgentRoute({
@@ -2401,7 +3962,31 @@ export const bitrix24Plugin = {
                     });
                   }
                   if (payload.text) {
-                    let text = payload.text;
+                    if (consumePendingNativeForwardAck(sendCtx.dialogId, msgCtx.messageId, ctx.accountId)) {
+                      replyDelivered = true;
+                      logger.debug('Suppressing trailing acknowledgement after native Bitrix24 forward', {
+                        senderId: msgCtx.senderId,
+                        chatId: msgCtx.chatId,
+                        messageId: msgCtx.messageId,
+                      });
+                      return;
+                    }
+
+                    const replyDirective = extractReplyDirective({
+                      text: payload.text,
+                      currentMessageId: msgCtx.messageId,
+                      explicitReplyToId: (payload as Record<string, unknown>).replyToId,
+                    });
+                    let text = replyDirective.cleanText;
+                    if (consumePendingNativeReactionAck(msgCtx.messageId, text, ctx.accountId)) {
+                      replyDelivered = true;
+                      logger.debug('Suppressing trailing acknowledgement after native Bitrix24 reaction', {
+                        senderId: msgCtx.senderId,
+                        chatId: msgCtx.chatId,
+                        messageId: msgCtx.messageId,
+                      });
+                      return;
+                    }
                     let keyboard = extractKeyboardFromPayload(payload);
 
                     // Fallback: agent may embed button JSON in text as [[{...}]]
@@ -2413,8 +3998,68 @@ export const bitrix24Plugin = {
                       }
                     }
 
+                    const nativeForwardMessageId = findNativeForwardTarget({
+                      accountId: ctx.accountId,
+                      requestText: body,
+                      deliveredText: text,
+                      historyEntries: previousEntries,
+                      currentMessageId: msgCtx.messageId,
+                    }) ?? findImplicitForwardTargetFromRecentInbound({
+                      accountId: ctx.accountId,
+                      requestText: body,
+                      deliveredText: text,
+                      currentMessageId: msgCtx.messageId,
+                      historyEntries: previousEntries,
+                    });
+                    const nativeForwardTargets = nativeForwardMessageId
+                      ? extractBitrix24DialogTargetsFromText(body)
+                      : [];
+                    const nativeReplyToMessageId = nativeForwardMessageId
+                      ? undefined
+                      : replyDirective.replyToMessageId;
+                    const sendOptions = {
+                      ...(keyboard ? { keyboard } : {}),
+                      ...(nativeReplyToMessageId ? { replyToMessageId: nativeReplyToMessageId } : {}),
+                      ...(nativeForwardMessageId ? { forwardMessages: [nativeForwardMessageId] } : {}),
+                    };
+
                     replyDelivered = true;
-                    await sendService.sendText(sendCtx, text, keyboard ? { keyboard } : undefined);
+                    if (nativeForwardMessageId && nativeForwardTargets.length > 0) {
+                      const forwardResults = await Promise.allSettled(
+                        nativeForwardTargets.map((dialogId) => sendService.sendText(
+                          { ...sendCtx, dialogId },
+                          '',
+                          { forwardMessages: [nativeForwardMessageId] },
+                        )),
+                      );
+                      const firstFailure = forwardResults.find(
+                        (result): result is PromiseRejectedResult => result.status === 'rejected',
+                      );
+                      const hasSuccess = forwardResults.some((result) => result.status === 'fulfilled');
+
+                      if (firstFailure && !hasSuccess) {
+                        throw firstFailure.reason;
+                      }
+
+                      if (firstFailure) {
+                        logger.warn('Failed to deliver Bitrix24 native forward to one or more explicit targets', {
+                          senderId: msgCtx.senderId,
+                          chatId: msgCtx.chatId,
+                          messageId: msgCtx.messageId,
+                          targets: nativeForwardTargets,
+                          error: firstFailure.reason instanceof Error
+                            ? firstFailure.reason.message
+                            : String(firstFailure.reason),
+                        });
+                      }
+                      return;
+                    }
+
+                    await sendService.sendText(
+                      sendCtx,
+                      nativeForwardMessageId ? '' : text,
+                      Object.keys(sendOptions).length > 0 ? sendOptions : undefined,
+                    );
                   }
                 },
                 onReplyStart: async () => {
@@ -3084,12 +4729,19 @@ export const bitrix24Plugin = {
             accountId: ctx.accountId,
             peer: conversation.peer,
           });
+          const fileDeliveryAgentHint = buildBitrix24FileDeliveryAgentHint();
+          const nativeReplyAgentHint = buildBitrix24NativeReplyAgentHint(commandMessageId);
+          const commandBodyForAgent = [
+            fileDeliveryAgentHint,
+            nativeReplyAgentHint,
+            commandText,
+          ].filter(Boolean).join('\n\n');
 
           const slashSessionKey = `bitrix24:slash:${senderId}:${Date.now()}`;
 
           const inboundCtx = runtime.channel.reply.finalizeInboundContext({
             Body: commandText,
-            BodyForAgent: commandText,
+            BodyForAgent: commandBodyForAgent,
             RawBody: commandText,
             CommandBody: commandText,
             CommandAuthorized: true,
@@ -3129,20 +4781,29 @@ export const bitrix24Plugin = {
                 deliver: async (payload) => {
                   await replyStatusHeartbeat.stopAndWait();
                   if (payload.text) {
+                    const replyDirective = extractReplyDirective({
+                      text: payload.text,
+                      currentMessageId: commandMessageId,
+                      explicitReplyToId: (payload as Record<string, unknown>).replyToId,
+                    });
                     const keyboard = extractKeyboardFromPayload(payload)
                       ?? defaultSessionKeyboard;
                     const formattedPayload = normalizeCommandReplyPayload({
                       commandName,
                       commandParams,
-                      text: payload.text,
+                      text: replyDirective.cleanText,
                       language: cmdCtx.language,
                     });
+                    const sendOptions = {
+                      keyboard,
+                      convertMarkdown: formattedPayload.convertMarkdown,
+                      ...(replyDirective.replyToMessageId ? { replyToMessageId: replyDirective.replyToMessageId } : {}),
+                    };
                     if (!commandReplyDelivered) {
-                      if (isDm) {
+                      if (isDm || replyDirective.replyToMessageId) {
                         commandReplyDelivered = true;
                         await sendService.sendText(sendCtx, formattedPayload.text, {
-                          keyboard,
-                          convertMarkdown: formattedPayload.convertMarkdown,
+                          ...sendOptions,
                         });
                       } else {
                         commandReplyDelivered = true;
@@ -3155,10 +4816,7 @@ export const bitrix24Plugin = {
                     }
 
                     commandReplyDelivered = true;
-                    await sendService.sendText(sendCtx, formattedPayload.text, {
-                      keyboard,
-                      convertMarkdown: formattedPayload.convertMarkdown,
-                    });
+                    await sendService.sendText(sendCtx, formattedPayload.text, sendOptions);
                   }
                 },
                 onReplyStart: async () => {