@ihazz/bitrix24 1.1.12 → 1.1.13

package/dist/src/channel.js

@@ -16,6 +16,7 @@ import { getBitrix24Runtime } from './runtime.js';
 import { OPENCLAW_COMMANDS, buildCommandsHelpText, formatModelsCommandReply, getCommandRegistrationPayload, } from './commands.js';
 import { accessApproved, accessDenied, commandKeyboardLabels, groupPairingPending, mediaDownloadFailed, groupChatUnsupported, newSessionReplyTexts, onboardingDisclaimerMessage, onboardingMessage, normalizeNewSessionReply, ownerAndAllowedUsersOnly, personalBotOwnerOnly, welcomeKeyboardLabels, watchOwnerDmNotice, } from './i18n.js';
 import { HistoryCache } from './history-cache.js';
+import { markdownToBbCode } from './message-utils.js';
 const PHASE_STATUS_DURATION_SECONDS = 8;
 const PHASE_STATUS_REFRESH_GRACE_MS = 1000;
 const THINKING_STATUS_DURATION_SECONDS = 30;
@@ -37,7 +38,15 @@ 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();
+const pendingNativeReactionAcks = new Map();
+const recentInboundMessagesByDialog = new Map();
+const inboundMessageContextById = new Map();
 // ─── Emoji → B24 reaction code mapping ──────────────────────────────────
 // B24 uses named reaction codes, not Unicode emoji.
 // Map common Unicode emoji to their B24 equivalents.
@@ -109,6 +118,424 @@ function toMessageId(value) {
     const parsed = Number(value);
     return Number.isFinite(parsed) && parsed > 0 ? parsed : undefined;
 }
+function resolveStateAccountId(accountId) {
+    const normalizedAccountId = typeof accountId === 'string'
+        ? accountId.trim()
+        : '';
+    if (normalizedAccountId) {
+        return normalizedAccountId;
+    }
+    const gatewayAccountId = gatewayState?.accountId?.trim();
+    return gatewayAccountId || 'default';
+}
+function buildAccountDialogScopeKey(accountId, dialogId) {
+    const normalizedDialogId = dialogId.trim();
+    if (!normalizedDialogId) {
+        return undefined;
+    }
+    return `${resolveStateAccountId(accountId)}:${normalizedDialogId}`;
+}
+function buildAccountMessageScopeKey(accountId, currentMessageId) {
+    const normalizedMessageId = toMessageId(currentMessageId);
+    if (!normalizedMessageId) {
+        return undefined;
+    }
+    return `${resolveStateAccountId(accountId)}:${normalizedMessageId}`;
+}
+function buildPendingNativeForwardAckKey(dialogId, currentMessageId, accountId) {
+    const dialogKey = buildAccountDialogScopeKey(accountId, dialogId);
+    const normalizedMessageId = toMessageId(currentMessageId);
+    if (!dialogKey || !normalizedMessageId) {
+        return undefined;
+    }
+    return `${dialogKey}:${normalizedMessageId}`;
+}
+function prunePendingNativeForwardAcks(now = Date.now()) {
+    for (const [key, expiresAt] of pendingNativeForwardAcks.entries()) {
+        if (!Number.isFinite(expiresAt) || expiresAt <= now) {
+            pendingNativeForwardAcks.delete(key);
+        }
+    }
+}
+function markPendingNativeForwardAck(dialogId, currentMessageId, accountId) {
+    const key = buildPendingNativeForwardAckKey(dialogId, currentMessageId, accountId);
+    if (!key) {
+        return;
+    }
+    prunePendingNativeForwardAcks();
+    pendingNativeForwardAcks.set(key, Date.now() + NATIVE_FORWARD_ACK_TTL_MS);
+}
+function consumePendingNativeForwardAck(dialogId, currentMessageId, accountId) {
+    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, fallbackDialogId, accountId) {
+    const messageKey = buildAccountMessageScopeKey(accountId, currentMessageId);
+    if (!messageKey) {
+        return fallbackDialogId;
+    }
+    return inboundMessageContextById.get(messageKey)?.dialogId ?? fallbackDialogId;
+}
+function buildPendingNativeReactionAckKey(currentMessageId, accountId) {
+    return buildAccountMessageScopeKey(accountId, currentMessageId);
+}
+function prunePendingNativeReactionAcks(now = Date.now()) {
+    for (const [key, entry] of pendingNativeReactionAcks.entries()) {
+        if (!entry || !Number.isFinite(entry.expiresAt) || entry.expiresAt <= now) {
+            pendingNativeReactionAcks.delete(key);
+        }
+    }
+}
+function markPendingNativeReactionAck(currentMessageId, emoji, accountId) {
+    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, text, accountId) {
+    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()) {
+    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, messageId, body, timestamp = Date.now(), accountId) {
+    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, accountId) {
+    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) {
+    return value
+        .replace(/\s+/g, ' ')
+        .trim();
+}
+function normalizeBitrix24DialogTarget(raw) {
+    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) {
+    const normalized = normalizeBitrix24DialogTarget(raw);
+    return /^\d+$/.test(normalized) || /^chat\d+$/iu.test(normalized);
+}
+function extractBitrix24DialogTargetsFromText(text) {
+    const targets = new Set();
+    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) {
+    return extractBitrix24DialogTargetsFromText(text).length > 0;
+}
+function extractReplyDirective(params) {
+    let wantsCurrentReply = false;
+    let inlineReplyToId;
+    const cleanText = cleanupTextAfterInlineMediaExtraction(params.text.replace(INLINE_REPLY_DIRECTIVE_RE, (_match, _rawDirective, explicitId) => {
+        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) {
+    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) {
+    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) {
+    // 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) {
+    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) {
+    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() {
+    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) {
+    return parseActionMessageIds(rawParams.forwardMessageIds
+        ?? rawParams.forwardIds);
+}
+function resolveActionForwardMessageIds(params) {
+    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) {
+    const normalizedText = typeof text === 'string' ? text.trim() : '';
+    if (!normalizedText || FORWARD_MARKER_RE.test(normalizedText)) {
+        return '';
+    }
+    return normalizedText;
+}
 function escapeBbCodeText(value) {
     return value
         .replace(/\[/g, '(')
@@ -741,6 +1168,15 @@ class BufferedDirectMessageCoalescer {
 let gatewayState = null;
 export function __setGatewayStateForTests(state) {
     gatewayState = state;
+    if (state === null) {
+        pendingNativeForwardAcks.clear();
+        pendingNativeReactionAcks.clear();
+        recentInboundMessagesByDialog.clear();
+        inboundMessageContextById.clear();
+    }
+}
+export function __rememberRecentInboundMessageForTests(params) {
+    rememberRecentInboundMessage(params.dialogId, params.messageId, params.body, params.timestamp, params.accountId);
 }
 // ─── Keyboard layouts ────────────────────────────────────────────────────────
 export function buildWelcomeKeyboard(language) {
@@ -768,6 +1204,341 @@ export function buildDefaultCommandKeyboard(language) {
 }
 export const DEFAULT_COMMAND_KEYBOARD = buildDefaultCommandKeyboard();
 export const DEFAULT_WELCOME_KEYBOARD = buildWelcomeKeyboard();
+const BITRIX24_ACTION_NAMES = ['send', 'reply', 'react', 'edit', 'delete'];
+const BITRIX24_DISCOVERY_ACTION_NAMES = ['send', 'reply', 'react', 'edit', 'delete'];
+function buildMessageToolButtonsSchema() {
+    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() {
+    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) {
+    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, accountId) {
+    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) {
+    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) {
+    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) {
+    const rawText = params.message ?? params.text ?? params.content;
+    return typeof rawText === 'string' ? rawText : null;
+}
+function isPlainObject(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+function isAttachColorToken(value) {
+    return value === 'primary'
+        || value === 'secondary'
+        || value === 'alert'
+        || value === 'base';
+}
+function isAttachBlock(value) {
+    return isPlainObject(value) && Object.keys(value).length > 0;
+}
+function isBitrix24Attach(value) {
+    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) {
+    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) {
+    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, fallbackTarget) {
+    const rawTarget = params.to ?? params.target ?? fallbackTarget;
+    return typeof rawTarget === 'string' ? normalizeBitrix24DialogTarget(rawTarget) : '';
+}
+function parseActionMessageIds(rawValue) {
+    const ids = [];
+    const seen = new Set();
+    const append = (value) => {
+        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) {
+    if (rawButtons == null) {
+        return undefined;
+    }
+    try {
+        const parsed = typeof rawButtons === 'string' ? JSON.parse(rawButtons) : rawButtons;
+        if (Array.isArray(parsed)) {
+            const keyboard = convertButtonsToKeyboard(parsed);
+            return keyboard.length > 0 ? keyboard : undefined;
+        }
+    }
+    catch {
+        // Ignore invalid buttons payload and send without keyboard.
+    }
+    return undefined;
+}
+function collectActionMediaUrls(params) {
+    const mediaUrls = [];
+    const seen = new Set();
+    const append = (value) => {
+        if (Array.isArray(value)) {
+            value.forEach(append);
+            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 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;
+}
+function buildActionMessageText(params) {
+    const normalizedText = typeof params.text === 'string'
+        ? markdownToBbCode(params.text.trim())
+        : '';
+    if (normalizedText) {
+        return normalizedText;
+    }
+    if (params.attach) {
+        return null;
+    }
+    return params.keyboard ? ' ' : null;
+}
 function parseRegisteredCommandTrigger(callbackData) {
     const trimmed = callbackData.trim();
     const isSlashCommand = trimmed.startsWith('/');
@@ -844,6 +1615,13 @@ export function extractKeyboardFromPayload(payload) {
     }
     return undefined;
 }
+export function extractAttachFromPayload(payload) {
+    const cd = payload.channelData;
+    if (!cd)
+        return undefined;
+    const b24Data = cd.bitrix24;
+    return parseActionAttach(b24Data?.attach ?? b24Data?.attachments);
+}
 /**
  * Extract inline button JSON embedded in message text by the agent.
  *
@@ -874,6 +1652,13 @@ export function extractInlineButtonsFromText(text) {
         return undefined;
     }
 }
+function cleanupTextAfterInlineMediaExtraction(text) {
+    return text
+        .replace(/[ \t]+\n/g, '\n')
+        .replace(/\n{3,}/g, '\n\n')
+        .replace(/[ \t]{2,}/g, ' ')
+        .trim();
+}
 function normalizeCommandReplyPayload(params) {
     const { commandName, commandParams, text, language } = params;
     if (commandName === 'models' && commandParams.trim() === '') {
@@ -1130,12 +1915,13 @@ export async function handleWebhookRequest(req, res) {
 // ─── Outbound adapter helpers ────────────────────────────────────────────────
 function resolveOutboundSendCtx(params) {
     const { config } = resolveAccount(params.cfg, params.accountId);
-    if (!config.webhookUrl || !gatewayState)
+    const dialogId = normalizeBitrix24DialogTarget(params.to);
+    if (!config.webhookUrl || !gatewayState || !dialogId)
         return null;
     return {
         webhookUrl: config.webhookUrl,
         bot: gatewayState.bot,
-        dialogId: params.to,
+        dialogId,
     };
 }
 function collectOutboundMediaUrls(input) {
@@ -1196,13 +1982,10 @@ export const bitrix24Plugin = {
         inlineButtons: 'all',
     },
     messaging: {
-        normalizeTarget: (raw) => raw.trim().replace(CHANNEL_PREFIX_RE, ''),
+        normalizeTarget: (raw) => normalizeBitrix24DialogTarget(raw),
         targetResolver: {
-            hint: 'Use a numeric chat/dialog ID, e.g. "1" or "chat42".',
-            looksLikeId: (raw, _normalized) => {
-                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, _normalized) => looksLikeBitrix24DialogTarget(raw),
         },
     },
     config: {
@@ -1286,27 +2069,47 @@ 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,
             });
             if (mediaUrls.length > 0) {
+                const initialMessage = !keyboard && !attach ? text || undefined : undefined;
                 const uploadedMessageId = await uploadOutboundMedia({
                     mediaService: gatewayState.mediaService,
                     sendCtx,
                     mediaUrls,
+                    initialMessage,
                 });
-                if (ctx.text) {
-                    const result = await gatewayState.sendService.sendText(sendCtx, ctx.text, keyboard ? { keyboard } : undefined);
+                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, text || '', keyboard ? { keyboard } : undefined);
                     return { messageId: String(result.messageId ?? uploadedMessageId) };
                 }
                 return { messageId: uploadedMessageId };
             }
-            if (ctx.text) {
-                const result = await gatewayState.sendService.sendText(sendCtx, ctx.text, keyboard ? { keyboard } : undefined);
+            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, text || '', keyboard ? { keyboard } : undefined);
                 return { messageId: String(result.messageId ?? '') };
             }
             return { messageId: '' };
@@ -1314,11 +2117,13 @@ export const bitrix24Plugin = {
     },
     // ─── Actions (agent-driven: reactions, etc.) ────────────────────────────
     actions: {
+        describeMessageTool: (params) => describeBitrix24MessageTool(params),
+        extractToolSend: (params) => extractBitrix24ToolSend(params.args),
         listActions: (_params) => {
-            return ['react', 'send'];
+            return [...BITRIX24_DISCOVERY_ACTION_NAMES];
         },
         supportsAction: (params) => {
-            return params.action === 'react' || params.action === 'send';
+            return BITRIX24_ACTION_NAMES.includes(params.action);
         },
         handleAction: async (ctx) => {
             // Helper: wrap payload as gateway-compatible tool result
@@ -1328,33 +2133,196 @@ 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 = { webhookUrl: config.webhookUrl, bot, dialogId: to };
-                const message = String(ctx.params.message ?? '').trim();
-                // Parse buttons: may be array or JSON string
-                let buttons;
-                try {
-                    const parsed = typeof rawButtons === 'string' ? JSON.parse(rawButtons) : rawButtons;
-                    if (Array.isArray(parsed))
-                        buttons = parsed;
+                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.toolContext;
+                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.',
+                    });
                 }
-                catch {
-                    // invalid buttons JSON — send without keyboard
+                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.',
+                    });
                 }
-                const keyboard = buttons?.length ? convertButtonsToKeyboard(buttons) : undefined;
                 try {
+                    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 ?? '') },
+                        });
+                    }
+                    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 ?? '') },
+                        });
+                    }
                     const result = await gatewayState.sendService.sendText(sendCtx, message || ' ', keyboard ? { keyboard } : undefined);
                     return toolResult({
                         channel: 'bitrix24',
@@ -1369,6 +2337,153 @@ export const bitrix24Plugin = {
                     return toolResult({ ok: false, error: errMsg });
                 }
             }
+            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.toolContext;
+                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.toolContext;
+                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;
+                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);
+                        }
+                    }
+                    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.toolContext;
+                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;
@@ -1418,12 +2533,14 @@ 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.` });
@@ -1723,9 +2840,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,
@@ -1733,6 +2863,7 @@ 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({
                         cfg,
@@ -1793,7 +2924,30 @@ 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.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 [[{...}]]
                                         if (!keyboard) {
@@ -1803,8 +2957,52 @@ export const bitrix24Plugin = {
                                                 keyboard = extracted.keyboard;
                                             }
                                         }
+                                        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.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 () => {
@@ -2339,10 +3537,17 @@ 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,
@@ -2380,20 +3585,29 @@ export const bitrix24Plugin = {
                                 deliver: async (payload) => {
                                     await replyStatusHeartbeat.stopAndWait();
                                     if (payload.text) {
+                                        const replyDirective = extractReplyDirective({
+                                            text: payload.text,
+                                            currentMessageId: commandMessageId,
+                                            explicitReplyToId: payload.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 {
@@ -2406,10 +3620,7 @@ export const bitrix24Plugin = {
                                             return;
                                         }
                                         commandReplyDelivered = true;
-                                        await sendService.sendText(sendCtx, formattedPayload.text, {
-                                            keyboard,
-                                            convertMarkdown: formattedPayload.convertMarkdown,
-                                        });
+                                        await sendService.sendText(sendCtx, formattedPayload.text, sendOptions);
                                     }
                                 },
                                 onReplyStart: async () => {