clawgram 2.23.0 → 2.24.0

package/dist/channel.js

@@ -54,22 +54,14 @@ const fetch_media_1 = require("./fetch-media");
 const channel_runtime_1 = require("openclaw/plugin-sdk/channel-runtime");
 const param_readers_1 = require("openclaw/plugin-sdk/param-readers");
 const tool_send_1 = require("openclaw/plugin-sdk/tool-send");
-const direct_dm_1 = require("openclaw/plugin-sdk/direct-dm");
-const channel_inbound_1 = require("openclaw/plugin-sdk/channel-inbound");
-const channel_reply_pipeline_1 = require("openclaw/plugin-sdk/channel-reply-pipeline");
-const inbound_envelope_1 = require("openclaw/plugin-sdk/inbound-envelope");
-const inbound_reply_dispatch_1 = require("openclaw/plugin-sdk/inbound-reply-dispatch");
 const channel_pairing_1 = require("openclaw/plugin-sdk/channel-pairing");
 const events_1 = require("telegram/events");
-const constants_1 = require("./constants");
 const gramjs_client_1 = require("./gramjs-client");
-const normalize_1 = require("./normalize");
 const history_1 = require("./history");
 const send_scope_1 = require("./send-scope");
 const joins_1 = require("./joins");
 const reactions_1 = require("./reactions");
 const manage_1 = require("./manage");
-const silent_reaction_1 = require("./silent-reaction");
 const system_notice_1 = require("./system-notice");
 const state_dir_1 = require("./state-dir");
 const chat_info_1 = require("./chat-info");
@@ -82,68 +74,8 @@ const group_reply_address_1 = require("./group-reply-address");
 const group_visible_reply_guard_1 = require("./group-visible-reply-guard");
 const helpers_1 = require("./helpers");
 const proxy_config_1 = require("./proxy-config");
-const constants_2 = require("./constants");
+const constants_1 = require("./constants");
 const actionLog = (0, core_1.createSubsystemLogger)("channels/clawgram");
-/** Reads the configured reaction level for an account, tolerating a missing config. */
-function readAccountReactionLevel(cfg, accountId) {
-    const resolvedAccountId = (0, helpers_1.resolveConfiguredAccountId)(cfg, accountId);
-    if (!resolvedAccountId) {
-        return undefined;
-    }
-    return cfg?.channels?.[constants_2.CHANNEL_ID]?.accounts?.[resolvedAccountId]?.reactionLevel;
-}
-/**
- * Model ref for the emoji pick, when the account names one.
- *
- * Picking one emoji out of a fixed list of 68 is the cheapest judgement this
- * channel makes and the only model call it makes on its own; running it on the
- * agent's own head spends the expensive quota on a decision a small model
- * makes just as well.
- */
-function readAccountReactionModel(cfg, accountId) {
-    const resolvedAccountId = (0, helpers_1.resolveConfiguredAccountId)(cfg, accountId);
-    if (!resolvedAccountId) {
-        return undefined;
-    }
-    const raw = cfg?.channels?.[constants_2.CHANNEL_ID]?.accounts?.[resolvedAccountId]?.reactionModel;
-    return typeof raw === "string" && raw.trim() ? raw.trim() : undefined;
-}
-/**
- * Wires `reactToSilentMention` to this account's runtime, config and log.
- *
- * The decision itself lives in `silent-reaction.ts`, testable without a
- * Telegram connection; everything here is lookup. Missing pieces — no
- * connected client, no model access — resolve to no reaction rather than to
- * an error, because by this point the agent has already declined to reply.
- */
-async function reactToSilentMentionForAccount(params) {
-    const gram = params.gram;
-    const llm = params.pluginRuntime?.llm;
-    if (!gram || typeof llm?.complete !== "function") {
-        return;
-    }
-    await (0, silent_reaction_1.reactToSilentMention)({
-        appetite: (0, reactions_1.resolveAgentReactionGuidance)(readAccountReactionLevel(params.cfg, params.accountId)),
-        model: readAccountReactionModel(params.cfg, params.accountId),
-        wasMentioned: params.wasMentioned,
-        chatId: params.chatId,
-        messageId: params.messageId,
-        messageText: params.messageText,
-        deps: {
-            // Bound rather than destructured: the SDK may implement this as a
-            // method that needs its receiver.
-            complete: (args) => llm.complete(args),
-            sendReaction: (args) => gram.sendReaction(args),
-            allowedReactions: gram.getAllowedReactions
-                ? () => gram.getAllowedReactions(params.chatId)
-                : undefined,
-            onDecision: (info) => actionLog.info("clawgram silent-mention reaction", {
-                accountId: params.accountId,
-                ...info,
-            }),
-        },
-    });
-}
 /**
  * Read scope as configured for the account. Left `undefined` when the key is
  * absent so `isChatReadable` can tell "not configured" from "configured empty" —
@@ -242,6 +174,7 @@ const actions_1 = require("./actions");
 Object.defineProperty(exports, "CORE_ACTION_SYNONYMS", { enumerable: true, get: function () { return actions_1.CORE_ACTION_SYNONYMS; } });
 Object.defineProperty(exports, "canonicalAction", { enumerable: true, get: function () { return actions_1.canonicalAction; } });
 const outbound_1 = require("./outbound");
+const inbound_pipeline_1 = require("./inbound-pipeline");
 /**
  * Turns an inbound attachment into text the agent can read.
  *
@@ -454,808 +387,10 @@ const createChannelPlugin = (runtimes, pluginRuntime) => {
                 });
                 const client = gram.getClient();
                 const eventBuilder = new events_1.NewMessage({});
-                const eventHandler = async (event) => {
-                    try {
-                        const rawMessage = event?.message;
-                        const rawPeerUserId = rawMessage?.peerId?.userId;
-                        const rawPeerChatId = rawMessage?.peerId?.chatId;
-                        const rawPeerChannelId = rawMessage?.peerId?.channelId;
-                        const directLike = rawPeerUserId !== undefined ||
-                            (typeof rawMessage?.chatId === "number" && rawMessage.chatId > 0);
-                        if (directLike) {
-                            log?.info?.("clawgram raw direct-like event", {
-                                accountId,
-                                messageId: String(rawMessage?.id ?? ""),
-                                chatId: String(rawMessage?.chatId ?? ""),
-                                peerUserId: String(rawPeerUserId ?? ""),
-                                peerChatId: String(rawPeerChatId ?? ""),
-                                peerChannelId: String(rawPeerChannelId ?? ""),
-                                senderId: String(rawMessage?.senderId ?? rawMessage?.fromId?.userId ?? ""),
-                                out: rawMessage?.out === true,
-                                textLength: typeof rawMessage?.message === "string" ? rawMessage.message.length : typeof rawMessage?.text === "string" ? rawMessage.text.length : 0,
-                            });
-                        }
-                        const normalized = (0, normalize_1.normalizeTelegramEvent)(event, accountId);
-                        if (!normalized) {
-                            if (directLike) {
-                                log?.info?.("clawgram normalize returned null", {
-                                    accountId,
-                                    messageId: String(rawMessage?.id ?? ""),
-                                    chatId: String(rawMessage?.chatId ?? ""),
-                                    peerUserId: String(rawPeerUserId ?? ""),
-                                });
-                            }
-                            return;
-                        }
-                        const directReplyTarget = normalized.chatType === "direct"
-                            ? undefined
-                            : await (0, helpers_1.resolveReplyTarget)(rawMessage);
-                        const senderProfile = normalized.chatType === "direct"
-                            ? await (0, helpers_1.resolveSenderProfileWithTimeout)(rawMessage, {
-                                senderId: normalized.senderId,
-                                client,
-                            }, 1500)
-                            : await (0, helpers_1.resolveSenderProfile)(rawMessage, {
-                                senderId: normalized.senderId,
-                                client,
-                            });
-                        const replyTarget = normalized.chatType === "direct"
-                            ? normalized.chatId
-                            : await (0, helpers_1.resolveChatTarget)(rawMessage);
-                        if (replyTarget) {
-                            normalized.replyTarget = replyTarget;
-                        }
-                        if (!normalized.senderUsername && senderProfile.username) {
-                            normalized.senderUsername = senderProfile.username;
-                        }
-                        if (!normalized.senderDisplay && senderProfile.display) {
-                            normalized.senderDisplay = senderProfile.display;
-                        }
-                        if (normalized.isOutgoing) {
-                            if (normalized.chatType === "direct") {
-                                log?.info?.("clawgram skipping outgoing direct event", {
-                                    accountId,
-                                    chatId: normalized.chatId,
-                                    messageId: normalized.messageId,
-                                    senderId: normalized.senderId,
-                                });
-                            }
-                            return;
-                        }
-                        if (normalized.chatType === "channel") {
-                            log?.info?.("clawgram skipping channel inbound", {
-                                accountId,
-                                chatId: normalized.chatId,
-                                chatType: normalized.chatType,
-                                messageId: normalized.messageId,
-                            });
-                            return;
-                        }
-                        let text = normalized.text?.trim();
-                        // Whether this sender may reach the agent at all — decided before
-                        // the attachment is fetched.
-                        //
-                        // Reading an attachment downloads up to 25 MB and then spends a
-                        // transcription or vision call on it. That used to happen for
-                        // every photo and voice note from anyone in any group the account
-                        // sits in, and only afterwards was the sender checked against
-                        // `allowFrom`. A stranger could therefore spend the owner's model
-                        // budget at will. None of these checks depend on the message text,
-                        // so they cost nothing to run first.
-                        const inboundSenderId = normalized.senderId ?? normalized.chatId;
-                        const inboundScopes = (0, helpers_1.resolveAccountScopes)(cfg, accountId);
-                        const inboundGroupConfig = normalized.chatType === "group"
-                            ? (0, helpers_1.resolveGroupConfig)(inboundScopes.groups, normalized.chatId)
-                            : undefined;
-                        const senderMayReachAgent = normalized.chatType === "group"
-                            ? Boolean(inboundGroupConfig
-                                && inboundGroupConfig.enabled !== false
-                                && (0, helpers_1.isSenderAllowed)({
-                                    allowFrom: inboundGroupConfig.allowFrom,
-                                    senderId: inboundSenderId,
-                                    senderUsername: normalized.senderUsername,
-                                }))
-                            : (0, helpers_1.isSenderAllowed)({
-                                allowFrom: inboundScopes.allowFrom,
-                                senderId: inboundSenderId,
-                                senderUsername: normalized.senderUsername,
-                            });
-                        // An attachment carries no text of its own, and dropping it as
-                        // "empty" is how the assistant used to go silent on being spoken
-                        // to or shown something. Read it into the body instead: for a
-                        // voice note and a screenshot alike, the attachment *is* the
-                        // message. A caption is kept and the reading appended, because
-                        // "look at this" plus the picture is one thought, not two.
-                        const attachment = senderMayReachAgent ? await (0, attachments_1.readInboundAttachment)({
-                            gram,
-                            event,
-                            cfg,
-                            runtime: pluginRuntime,
-                            log,
-                            accountId,
-                            chatId: normalized.chatId,
-                            messageId: normalized.messageId,
-                        }) : undefined;
-                        if (attachment) {
-                            const marker = attachment.understanding === "transcript" ? "голосовое" : "изображение";
-                            const read = `[${marker}] ${attachment.text}`;
-                            text = text ? `${text}\n\n${read}` : read;
-                        }
-                        // What the mention gate is allowed to read.
-                        //
-                        // A transcript is the sender's own speech, so "Тина, посмотри"
-                        // said aloud addresses the agent exactly as typing it would. A
-                        // description is not: it is a vision model reading somebody
-                        // else's content, and a screenshot of a chat where a third party
-                        // wrote "@tina_bot" is not an address to her. Feeding the whole
-                        // body to the gate made every such screenshot wake her up.
-                        const addressableText = (0, helpers_1.resolveAddressableText)({
-                            messageText: normalized.text,
-                            bodyText: text,
-                            understanding: attachment?.understanding,
-                        });
-                        if (!text) {
-                            log?.info?.("clawgram skipping empty inbound text", {
-                                accountId,
-                                chatId: normalized.chatId,
-                                messageId: normalized.messageId,
-                            });
-                            return;
-                        }
-                        const senderId = normalized.senderId ?? normalized.chatId;
-                        const isTelegramServiceDirect = normalized.chatType === "direct" &&
-                            (normalized.chatId === constants_1.TELEGRAM_SERVICE_CHAT_ID || senderId === constants_1.TELEGRAM_SERVICE_CHAT_ID);
-                        const isSavedMessagesDirect = normalized.chatType === "direct" &&
-                            Boolean(selfId) &&
-                            normalized.chatId === selfId &&
-                            senderId === selfId;
-                        if (isTelegramServiceDirect) {
-                            log?.info?.("clawgram skipping Telegram service direct chat", {
-                                accountId,
-                                chatId: normalized.chatId,
-                                messageId: normalized.messageId,
-                                senderId,
-                            });
-                            return;
-                        }
-                        if (isSavedMessagesDirect) {
-                            log?.info?.("clawgram skipping Saved Messages direct chat", {
-                                accountId,
-                                chatId: normalized.chatId,
-                                messageId: normalized.messageId,
-                                senderId,
-                                selfId,
-                            });
-                            return;
-                        }
-                        const senderUsername = normalized.senderUsername;
-                        const senderLabel = normalized.senderDisplay || normalized.senderUsername || senderId;
-                        const conversationTarget = normalized.chatType === "direct"
-                            ? normalized.chatId
-                            : normalized.replyTarget ?? normalized.chatId;
-                        const conversationFallbackTargets = [
-                            normalized.chatType === "direct" ? directReplyTarget : undefined,
-                            normalized.chatType === "direct" ? normalized.replyTarget : undefined,
-                            normalized.chatType === "direct" && normalized.senderUsername ? `@${normalized.senderUsername}` : undefined,
-                            normalized.chatId,
-                        ].filter((target, index, items) => {
-                            if (!target || target === conversationTarget) {
-                                return false;
-                            }
-                            return items.findIndex((candidate) => candidate === target) === index;
-                        });
-                        const sendTextToConversation = async (args) => {
-                            const targets = [conversationTarget, ...conversationFallbackTargets];
-                            // Replies have no per-call parseMode slot — the format is an
-                            // account setting (2.3.1); absent keeps the GramJS default
-                            // (its markdown parser — not plain text, see 2.15.0 notes).
-                            const replyParseMode = gram.replyParseMode;
-                            let lastError;
-                            for (const target of targets) {
-                                try {
-                                    return await gram.sendText({
-                                        target,
-                                        text: args.text,
-                                        replyToMessageId: args.replyToMessageId,
-                                        messageThreadId: args.messageThreadId,
-                                        parseMode: replyParseMode,
-                                    });
-                                }
-                                catch (error) {
-                                    lastError = error;
-                                }
-                            }
-                            throw lastError;
-                        };
-                        // Resolved once, above, before the attachment fetch that depends on
-                        // the answer — and by the same resolver `resolveAccount` uses, so the
-                        // gate applied here is the one the account was started with.
-                        const { allowFrom: directAllowFrom } = inboundScopes;
-                        const dmPolicy = "open";
-                        if (normalized.chatType === "group") {
-                            const groupConfig = inboundGroupConfig;
-                            if (!groupConfig) {
-                                log?.info?.("clawgram skipping group not present in groups config", {
-                                    accountId,
-                                    chatId: normalized.chatId,
-                                    messageId: normalized.messageId,
-                                });
-                                return;
-                            }
-                            if (groupConfig.enabled === false) {
-                                log?.info?.("clawgram skipping disabled group", {
-                                    accountId,
-                                    chatId: normalized.chatId,
-                                    messageId: normalized.messageId,
-                                });
-                                return;
-                            }
-                            if (!(0, helpers_1.isSenderAllowed)({
-                                allowFrom: groupConfig.allowFrom,
-                                senderId,
-                                senderUsername: normalized.senderUsername,
-                            })) {
-                                log?.info?.("clawgram blocking inbound group sender by allowFrom", {
-                                    accountId,
-                                    chatId: normalized.chatId,
-                                    messageId: normalized.messageId,
-                                    senderId,
-                                    username: normalized.senderUsername,
-                                    allowFrom: groupConfig.allowFrom,
-                                });
-                                return;
-                            }
-                            const scopedGroupPeerId = (0, helpers_1.buildScopedGroupPeerId)(accountId, normalized.chatId);
-                            const { route: inboundRoute, buildEnvelope } = (0, inbound_envelope_1.resolveInboundRouteEnvelopeBuilderWithRuntime)({
-                                cfg,
-                                channel: "clawgram",
-                                accountId,
-                                peer: {
-                                    kind: "group",
-                                    id: scopedGroupPeerId,
-                                },
-                                runtime: channelRuntime,
-                                sessionStore: cfg?.session?.store,
-                            });
-                            // channelRuntime comes from the untyped ctx, so the generic route type falls
-                            // back to the minimal RouteLike. The runtime value is a ResolvedAgentRoute.
-                            const route = inboundRoute;
-                            // Under `tag` the name is not an address: in a chat of a thousand
-                            // people it occurs in conversation constantly and is aimed at her
-                            // almost never. Only the `@` counts, and it is the same fact the
-                            // stricter rung of the ladder is named after.
-                            const wasMentioned = groupConfig.groupPolicy === "tag"
-                                ? (0, helpers_1.hasExplicitTelegramMention)({ selfUsername, text: addressableText, message: rawMessage })
-                                : (0, helpers_1.hasTelegramMention)({
-                                    cfg,
-                                    agentId: route.agentId,
-                                    selfUsername,
-                                    text: addressableText,
-                                    message: rawMessage,
-                                });
-                            // One fetch serves two needs: the reply-to-self gate below and
-                            // the parent's text for the agent (ReplyToBody), which a plain
-                            // reply does not carry on its own.
-                            const replyParent = await (0, helpers_1.resolveReplyParent)(rawMessage, { selfId, selfLabel });
-                            const wasReplyToSelf = replyParent.isSelf;
-                            const mentionDecision = (0, channel_inbound_1.resolveInboundMentionDecision)({
-                                facts: {
-                                    canDetectMention: true,
-                                    wasMentioned,
-                                    hasAnyMention: /(^|\s)@[a-zA-Z0-9_]{5,}\b/.test(addressableText),
-                                },
-                                policy: {
-                                    isGroup: true,
-                                    requireMention: groupConfig.groupPolicy !== "open",
-                                    allowTextCommands: false,
-                                    hasControlCommand: false,
-                                    commandAuthorized: true,
-                                },
-                            });
-                            log?.info?.("clawgram group mention gate", {
-                                accountId,
-                                chatId: normalized.chatId,
-                                messageId: normalized.messageId,
-                                selfUsername,
-                                groupPolicy: groupConfig.groupPolicy,
-                                mentionedFlag: rawMessage?.mentioned === true,
-                                hasEntities: Array.isArray(rawMessage?.entities) ? rawMessage.entities.length : 0,
-                                wasMentioned,
-                                wasReplyToSelf,
-                                shouldSkip: mentionDecision.shouldSkip,
-                                textLength: text.length,
-                            });
-                            if (groupConfig.groupPolicy !== "open" && mentionDecision.shouldSkip && !wasReplyToSelf) {
-                                log?.info?.("clawgram skipping group message without mention", {
-                                    accountId,
-                                    chatId: normalized.chatId,
-                                    messageId: normalized.messageId,
-                                    senderId,
-                                });
-                                return;
-                            }
-                            const { storePath, body } = buildEnvelope({
-                                channel: "Telegram",
-                                from: senderLabel,
-                                body: text,
-                                timestamp: normalized.timestamp,
-                            });
-                            const conversationRouteTarget = (0, helpers_1.buildConversationTarget)(normalized.chatId);
-                            const ctxPayload = channelRuntime.reply.finalizeInboundContext({
-                                Body: body,
-                                BodyForAgent: text,
-                                RawBody: text,
-                                CommandBody: text,
-                                From: conversationRouteTarget,
-                                To: conversationRouteTarget,
-                                SessionKey: route.sessionKey,
-                                AccountId: route.accountId ?? accountId,
-                                ChatType: "group",
-                                ConversationLabel: senderLabel,
-                                SenderId: senderId,
-                                SenderUsername: normalized.senderUsername,
-                                SenderName: normalized.senderDisplay,
-                                GroupId: normalized.chatId,
-                                GroupSubject: normalized.chatId,
-                                WasMentioned: mentionDecision.effectiveWasMentioned || wasReplyToSelf,
-                                WasReplyToSelf: wasReplyToSelf,
-                                Provider: "telegram",
-                                Surface: "clawgram",
-                                MessageSid: normalized.messageId,
-                                MessageSidFull: normalized.messageId,
-                                Timestamp: normalized.timestamp,
-                                ReplyToId: normalized.replyToMessageId,
-                                // Core renders these itself as `[Replying to: "…"]` ahead of the
-                                // user body — it keys off Provider being "telegram", which is set
-                                // below. Without them a highlighted reply reaches the agent as
-                                // bare text, and the fragment the person pointed at is lost.
-                                ReplyToQuoteText: normalized.replyQuoteText,
-                                ReplyToIsQuote: normalized.replyIsQuote,
-                                // A plain reply has no highlight; core then falls back to the
-                                // parent's body, which only exists if the channel fetched it.
-                                ReplyToBody: replyParent.body,
-                                ReplyToSender: replyParent.sender,
-                                MessageThreadId: normalized.messageThreadId,
-                                NativeChannelId: normalized.chatId,
-                                // Trusted per-group prompt block from `groups.<id>.systemPrompt`.
-                                // Core normalizes it (`normalizeTrustedTextField`) and appends
-                                // it to the system prompt for this turn. Undefined = no block.
-                                GroupSystemPrompt: groupConfig.systemPrompt,
-                                OriginatingChannel: "clawgram",
-                                OriginatingTo: conversationRouteTarget,
-                            });
-                            const groupReplyAddress = (0, group_reply_address_1.buildGroupReplyAddress)({
-                                senderUsername: normalized.senderUsername,
-                                senderDisplay: normalized.senderDisplay,
-                                senderId,
-                            });
-                            (0, group_reply_address_1.rememberGroupReplyAddress)({
-                                accountId: route.accountId ?? accountId,
-                                chatId: normalized.chatId,
-                                replyToId: normalized.messageId,
-                                address: groupReplyAddress,
-                            });
-                            const messageThreadId = (0, helpers_1.parseOptionalThreadId)(normalized.messageThreadId);
-                            const groupTypingTarget = normalized.chatId;
-                            await gram.withTyping(groupTypingTarget, async () => {
-                                log?.info?.("clawgram dispatching group reply", {
-                                    accountId,
-                                    chatId: normalized.chatId,
-                                    messageId: normalized.messageId,
-                                    routeSessionKey: route.sessionKey,
-                                    storePath,
-                                });
-                                await channelRuntime.session.recordInboundSession({
-                                    storePath,
-                                    sessionKey: ctxPayload.SessionKey ?? route.sessionKey,
-                                    ctx: ctxPayload,
-                                    updateLastRoute: {
-                                        sessionKey: route.sessionKey,
-                                        channel: constants_2.CHANNEL_ID,
-                                        to: conversationRouteTarget,
-                                        accountId: route.accountId ?? accountId,
-                                    },
-                                    onRecordError: (err) => {
-                                        log?.info?.("clawgram failed to update group last route", {
-                                            accountId,
-                                            chatId: normalized.chatId,
-                                            messageId: normalized.messageId,
-                                            error: String(err),
-                                        });
-                                    },
-                                });
-                                const dispatchBase = (0, inbound_reply_dispatch_1.buildInboundReplyDispatchBase)({
-                                    cfg,
-                                    channel: "clawgram",
-                                    accountId: route.accountId ?? accountId,
-                                    route,
-                                    storePath,
-                                    ctxPayload,
-                                    core: { channel: channelRuntime },
-                                });
-                                const { onModelSelected, ...replyPipeline } = (0, channel_reply_pipeline_1.createChannelReplyPipeline)({
-                                    cfg,
-                                    agentId: route.agentId,
-                                    channel: "clawgram",
-                                    accountId: route.accountId ?? accountId,
-                                });
-                                // Boundary for the transcript fallback below: only replies
-                                // written after this instant may be salvaged. Same clock as
-                                // the transcript writer — both live in this process.
-                                const dispatchStartedAt = Date.now();
-                                const dispatchResult = await dispatchBase.dispatchReplyWithBufferedBlockDispatcher({
-                                    ctx: ctxPayload,
-                                    cfg,
-                                    dispatcherOptions: {
-                                        ...replyPipeline,
-                                        deliver: async (payload) => {
-                                            const outboundText = typeof payload.text === "string" ? payload.text.trim() : "";
-                                            log?.info?.("clawgram deliver group payload", {
-                                                accountId,
-                                                chatId: normalized.chatId,
-                                                messageId: normalized.messageId,
-                                                payloadTextLength: outboundText.length,
-                                                payloadReplyToId: payload.replyToId ?? null,
-                                            });
-                                            if (!outboundText) {
-                                                return;
-                                            }
-                                            // The agent may decline to answer by returning the shared
-                                            // silent token. Drop it before addressing: otherwise the
-                                            // reply-address prefix turns it into a visible message.
-                                            const visibleText = (0, helpers_1.stripSilentReplyToken)(outboundText);
-                                            if (!visibleText) {
-                                                log?.info?.("clawgram suppressing silent group reply", {
-                                                    accountId,
-                                                    chatId: normalized.chatId,
-                                                    messageId: normalized.messageId,
-                                                });
-                                                return;
-                                            }
-                                            // Ядро подклеивает свою телеметрию к полезной нагрузке
-                                            // хода, и сюда она приходит тем же путём, что ответ.
-                                            // Проверка стояла только в `outbound.sendText`, то есть
-                                            // класс инцидента 30.08–01.09 был закрыт для рассылок и
-                                            // открыт для обычного ответа на упоминание (A5-10).
-                                            const groupNotice = (0, system_notice_1.shouldSuppressGroupSystemNotice)({
-                                                targetKind: "group",
-                                                text: visibleText,
-                                            });
-                                            if (groupNotice) {
-                                                log?.warn?.("clawgram suppressing system notice in group reply", {
-                                                    accountId,
-                                                    chatId: normalized.chatId,
-                                                    messageId: normalized.messageId,
-                                                    noticeKind: groupNotice,
-                                                    textLength: visibleText.length,
-                                                });
-                                                return;
-                                            }
-                                            const replyToMessageId = payload.replyToId ? Number(payload.replyToId) : Number(normalized.messageId);
-                                            const rememberedAddress = (0, group_reply_address_1.consumeGroupReplyAddress)({
-                                                accountId: route.accountId ?? accountId,
-                                                chatId: normalized.chatId,
-                                                replyToId: payload.replyToId ?? normalized.messageId,
-                                            });
-                                            await sendTextToConversation({
-                                                text: (0, helpers_1.prefixReplyTextToAddress)(visibleText, rememberedAddress ?? groupReplyAddress),
-                                                replyToMessageId,
-                                                messageThreadId,
-                                            });
-                                        },
-                                        onError: (err, info) => {
-                                            log?.error?.("clawgram failed to dispatch group reply", {
-                                                accountId,
-                                                chatId: normalized.chatId,
-                                                messageId: normalized.messageId,
-                                                kind: info.kind,
-                                                error: String(err),
-                                            });
-                                        },
-                                    },
-                                    replyOptions: {
-                                        onModelSelected,
-                                        // `groups.<id>.skills` → core's per-turn skill allowlist.
-                                        // Undefined = inherit the agent's skills; [] = none here.
-                                        skillFilter: groupConfig.skillFilter,
-                                    },
-                                });
-                                log?.info?.("clawgram group dispatch completed", {
-                                    accountId,
-                                    chatId: normalized.chatId,
-                                    messageId: normalized.messageId,
-                                    queuedFinal: dispatchResult?.queuedFinal ?? null,
-                                    counts: dispatchResult?.counts ?? null,
-                                });
-                                const dispatchCounts = dispatchResult?.counts ?? { tool: 0, block: 0, final: 0 };
-                                const nothingDelivered = dispatchResult?.queuedFinal !== true &&
-                                    (dispatchCounts.tool ?? 0) === 0 &&
-                                    (dispatchCounts.block ?? 0) === 0 &&
-                                    (dispatchCounts.final ?? 0) === 0;
-                                if (nothingDelivered) {
-                                    const fallbackText = (0, helpers_1.readLatestAssistantFallbackFromTranscript)(route.sessionKey, storePath, dispatchStartedAt);
-                                    // A suppressed silent reply legitimately delivers nothing, so
-                                    // this fallback fires right after it. Without the same check
-                                    // the token would be read back from the transcript and sent.
-                                    //
-                                    // TTS markup needs the same treatment for the same reason:
-                                    // core strips it on the normal reply path, but this text comes
-                                    // straight out of the transcript. On 2026-08-08 a group got
-                                    // `[[tts:text]]Привет, Вася!…[[/tts:text]]` verbatim. The
-                                    // spoken words are kept — a synthesis that did not happen
-                                    // should degrade to readable text, not to markup.
-                                    const rawFallback = fallbackText
-                                        ? (0, helpers_1.stripTtsDirectives)((0, helpers_1.stripSilentReplyToken)(fallbackText))
-                                        : "";
-                                    // Тот же фильтр и здесь: последняя реплика в стенограмме
-                                    // вполне может оказаться именно уведомлением об ошибке.
-                                    const fallbackNotice = rawFallback
-                                        ? (0, system_notice_1.shouldSuppressGroupSystemNotice)({ targetKind: "group", text: rawFallback })
-                                        : undefined;
-                                    if (fallbackNotice) {
-                                        log?.warn?.("clawgram suppressing system notice in transcript fallback", {
-                                            accountId,
-                                            chatId: normalized.chatId,
-                                            messageId: normalized.messageId,
-                                            noticeKind: fallbackNotice,
-                                            textLength: rawFallback.length,
-                                        });
-                                    }
-                                    const visibleFallbackText = fallbackNotice ? "" : rawFallback;
-                                    if (!visibleFallbackText) {
-                                        if (fallbackText) {
-                                            log?.info?.("clawgram skipping silent transcript fallback", {
-                                                accountId,
-                                                chatId: normalized.chatId,
-                                                messageId: normalized.messageId,
-                                                routeSessionKey: route.sessionKey,
-                                            });
-                                        }
-                                        else {
-                                            log?.warn?.("clawgram transcript fallback unavailable", {
-                                                accountId,
-                                                chatId: normalized.chatId,
-                                                messageId: normalized.messageId,
-                                                routeSessionKey: route.sessionKey,
-                                            });
-                                        }
-                                        // Named, and nothing came back: leave a reaction so the
-                                        // decision is visible instead of reading as her ignoring
-                                        // people. The condition is her silence, not the shape of
-                                        // the transcript — a turn that wrote no entry at all is
-                                        // just as silent as one that wrote the NO_REPLY token.
-                                        //
-                                        // Never allowed to disturb the turn: the reply is already
-                                        // settled by this point, so a failure here stays silent.
-                                        await reactToSilentMentionForAccount({
-                                            cfg,
-                                            accountId,
-                                            gram: runtimes.get(accountId),
-                                            pluginRuntime,
-                                            chatId: normalized.chatId,
-                                            messageId: normalized.messageId,
-                                            messageText: normalized.text,
-                                            // Same sense of "addressed" the agent was given for this
-                                            // turn on line 817: a reply to her own message counts as
-                                            // being spoken to, mention or not.
-                                            wasMentioned: mentionDecision.effectiveWasMentioned || wasReplyToSelf,
-                                        }).catch((err) => {
-                                            log?.info?.("clawgram silent-mention reaction failed", {
-                                                accountId,
-                                                chatId: normalized.chatId,
-                                                messageId: normalized.messageId,
-                                                error: String(err),
-                                            });
-                                        });
-                                    }
-                                    else {
-                                        log?.warn?.("clawgram using transcript fallback reply", {
-                                            accountId,
-                                            chatId: normalized.chatId,
-                                            messageId: normalized.messageId,
-                                            routeSessionKey: route.sessionKey,
-                                            fallbackTextLength: visibleFallbackText.length,
-                                        });
-                                        await sendTextToConversation({
-                                            text: (0, helpers_1.prefixReplyTextToAddress)(visibleFallbackText, groupReplyAddress),
-                                            replyToMessageId: Number(normalized.messageId),
-                                            messageThreadId,
-                                        });
-                                    }
-                                }
-                            }, {
-                                readMessageId: Number(normalized.messageId),
-                                messageThreadId,
-                                // The indicator is a promise of an answer, and it is owed only
-                                // to someone who addressed her. Under `open` the turn runs on
-                                // every message in the chat, so without this the whole room
-                                // watches her "type" through conversations she is only reading.
-                                typing: mentionDecision.effectiveWasMentioned || wasReplyToSelf,
-                            });
-                            log?.info?.("clawgram group inbound handled", {
-                                accountId,
-                                chatId: normalized.chatId,
-                                messageId: normalized.messageId,
-                                senderId,
-                                senderLabel,
-                                wasMentioned: mentionDecision.effectiveWasMentioned,
-                                wasReplyToSelf,
-                            });
-                            return;
-                        }
-                        if (!(0, helpers_1.isSenderAllowed)({
-                            allowFrom: directAllowFrom,
-                            senderId,
-                            senderUsername: normalized.senderUsername,
-                        })) {
-                            log?.info?.("clawgram direct allowFrom mismatch", {
-                                accountId,
-                                senderId,
-                                senderUsername: normalized.senderUsername,
-                                allowFrom: directAllowFrom,
-                            });
-                            return;
-                        }
-                        const access = await (0, direct_dm_1.resolveInboundDirectDmAccessWithRuntime)({
-                            cfg,
-                            channel: "clawgram",
-                            accountId,
-                            dmPolicy,
-                            allowFrom: directAllowFrom,
-                            senderId,
-                            rawBody: text,
-                            runtime: channelRuntime.commands,
-                            isSenderAllowed: (_candidateSenderId, allowEntries) => (0, helpers_1.isSenderAllowed)({
-                                allowFrom: allowEntries,
-                                senderId,
-                                senderUsername,
-                            }),
-                            readStoreAllowFrom: pairing.readStoreForDmPolicy,
-                        });
-                        if (access.access.decision === "block") {
-                            log?.info?.("clawgram blocking inbound direct message", {
-                                accountId,
-                                chatId: normalized.chatId,
-                                messageId: normalized.messageId,
-                                senderId,
-                                reason: access.access.reason,
-                                reasonCode: access.access.reasonCode,
-                            });
-                            return;
-                        }
-                        if (access.access.decision === "pairing") {
-                            await pairing.issueChallenge({
-                                senderId,
-                                senderIdLine: `Your Telegram user id: ${senderId}`,
-                                meta: {
-                                    username: normalized.senderUsername,
-                                    name: normalized.senderDisplay,
-                                },
-                                sendPairingReply: async (pairingText) => {
-                                    await sendTextToConversation({
-                                        text: pairingText,
-                                    });
-                                },
-                                onReplyError: (err) => {
-                                    log?.info?.("clawgram pairing reply failed", {
-                                        accountId,
-                                        chatId: normalized.chatId,
-                                        senderId,
-                                        error: String(err),
-                                    });
-                                },
-                            });
-                            log?.info?.("clawgram pairing required for inbound direct message", {
-                                accountId,
-                                chatId: normalized.chatId,
-                                messageId: normalized.messageId,
-                                senderId,
-                            });
-                            return;
-                        }
-                        // Same fetch as the group path. In a DM the parent is as often
-                        // the agent's own message as the person's — the owner answers a
-                        // notice she sent — and neither text is available any other way.
-                        const replyParent = await (0, helpers_1.resolveReplyParent)(rawMessage, { selfId, selfLabel });
-                        await gram.withTyping(conversationTarget, async () => {
-                            await (0, direct_dm_1.dispatchInboundDirectDmWithRuntime)({
-                                cfg,
-                                runtime: { channel: channelRuntime },
-                                channel: "clawgram",
-                                channelLabel: "Telegram",
-                                accountId,
-                                peer: {
-                                    kind: "direct",
-                                    id: senderId,
-                                },
-                                senderId,
-                                senderAddress: `telegram:${senderId}`,
-                                recipientAddress: selfId ? `telegram:${selfId}` : `telegram:${accountId}`,
-                                conversationLabel: senderLabel,
-                                rawBody: text,
-                                messageId: normalized.messageId,
-                                timestamp: normalized.timestamp,
-                                commandAuthorized: access.commandAuthorized,
-                                provider: "telegram",
-                                surface: "clawgram",
-                                originatingChannel: "clawgram",
-                                originatingTo: senderId,
-                                extraContext: {
-                                    SenderUsername: normalized.senderUsername,
-                                    SenderName: normalized.senderDisplay,
-                                    ReplyToId: normalized.replyToMessageId,
-                                    // Same reason as the group path: highlighted replies happen in
-                                    // direct messages too, and the fragment is not part of the text.
-                                    ReplyToQuoteText: normalized.replyQuoteText,
-                                    ReplyToIsQuote: normalized.replyIsQuote,
-                                    ReplyToBody: replyParent.body,
-                                    ReplyToSender: replyParent.sender,
-                                    NativeChannelId: normalized.chatId,
-                                },
-                                deliver: async (payload) => {
-                                    const outboundText = typeof payload.text === "string" ? payload.text.trim() : "";
-                                    if (!outboundText) {
-                                        return;
-                                    }
-                                    const visibleText = (0, helpers_1.stripSilentReplyToken)(outboundText);
-                                    if (!visibleText) {
-                                        log?.info?.("clawgram suppressing silent direct reply", {
-                                            accountId,
-                                            chatId: normalized.chatId,
-                                            messageId: normalized.messageId,
-                                        });
-                                        return;
-                                    }
-                                    await sendTextToConversation({
-                                        text: visibleText,
-                                        replyToMessageId: payload.replyToId ? Number(payload.replyToId) : undefined,
-                                    });
-                                },
-                                onRecordError: (err) => {
-                                    log?.info?.("clawgram failed to record inbound session", {
-                                        accountId,
-                                        chatId: normalized.chatId,
-                                        messageId: normalized.messageId,
-                                        error: String(err),
-                                    });
-                                },
-                                onDispatchError: (err, info) => {
-                                    log?.info?.("clawgram failed to dispatch reply", {
-                                        accountId,
-                                        chatId: normalized.chatId,
-                                        messageId: normalized.messageId,
-                                        kind: info.kind,
-                                        error: String(err),
-                                    });
-                                },
-                            });
-                        }, {
-                            readMessageId: Number(normalized.messageId),
-                        });
-                        log?.info?.("clawgram inbound handled", {
-                            accountId,
-                            chatId: normalized.chatId,
-                            messageId: normalized.messageId,
-                            senderId,
-                            senderLabel,
-                        });
-                    }
-                    catch (error) {
-                        const rawMessage = event?.message;
-                        log?.error?.("clawgram inbound handling failed", {
-                            accountId,
-                            chatId: String(rawMessage?.chatId ?? rawMessage?.peerId?.userId ?? rawMessage?.peerId?.chatId ?? rawMessage?.peerId?.channelId ?? ""),
-                            messageId: String(rawMessage?.id ?? ""),
-                            error: String(error),
-                        });
-                        log?.info?.("clawgram inbound preflight failed", {
-                            accountId,
-                            chatId: String(rawMessage?.chatId ?? rawMessage?.peerId?.userId ?? rawMessage?.peerId?.chatId ?? rawMessage?.peerId?.channelId ?? ""),
-                            messageId: String(rawMessage?.id ?? ""),
-                            error: String(error),
-                        });
-                    }
-                };
+                const eventHandler = async (event) => (0, inbound_pipeline_1.handleInboundEvent)(event, {
+                    accountId, cfg, channelRuntime, client, gram, log, pairing,
+                    pluginRuntime, runtimes, selfId, selfLabel, selfUsername,
+                });
                 client.addEventHandler(eventHandler, eventBuilder);
                 // Being added to a chat arrives as a service message, which `NewMessage`
                 // drops — so joins are observed on the raw update stream instead. Only
@@ -1304,7 +439,7 @@ const createChannelPlugin = (runtimes, pluginRuntime) => {
             },
         },
         messaging: {
-            targetPrefixes: [constants_2.CHANNEL_ID, "tguserbot", "telegram", "tg"],
+            targetPrefixes: [constants_1.CHANNEL_ID, "tguserbot", "telegram", "tg"],
             normalizeTarget(raw) {
                 const normalized = (0, helpers_1.normalizeOutboundTarget)(raw);
                 return normalized || undefined;
@@ -1376,7 +511,7 @@ const createChannelPlugin = (runtimes, pluginRuntime) => {
                 return (0, core_1.buildChannelOutboundSessionRoute)({
                     cfg: params.cfg,
                     agentId: params.agentId,
-                    channel: constants_2.CHANNEL_ID,
+                    channel: constants_1.CHANNEL_ID,
                     accountId,
                     peer: {
                         kind: (0, helpers_1.routeKindFromChatType)(chatType),