@femtomc/mu-server 26.2.95 → 26.2.96

package/README.md

@@ -189,6 +189,13 @@ When validating attachment support end-to-end, use this sequence:
 Operational fallback expectations:
 
 - If media upload fails, Telegram delivery falls back to text `sendMessage`.
+- Telegram text delivery chunks long messages into deterministic in-order `sendMessage` calls to stay below API size limits.
+- When outbound metadata includes `telegram_reply_to_message_id`, Telegram delivery anchors replies to the originating chat message.
+- Invalid/non-integer `telegram_reply_to_message_id` metadata is ignored so delivery degrades gracefully to non-anchored sends.
+- Awaiting-confirmation envelopes include Telegram inline `Confirm`/`Cancel` callback buttons when interaction metadata provides confirmation actions.
+- Telegram callback payloads are contract-limited to `confirm:<command_id>` and `cancel:<command_id>`; unsupported payloads are explicitly rejected.
+- Callback buttons keep parity with command fallback: `/mu confirm <id>` and `/mu cancel <id>` remain valid.
+- Group/supergroup Telegram freeform text is deterministic no-op with guidance; explicit `/mu ...` commands stay actionable.
 - If Slack/Telegram bot token is missing, channel capability reason codes should report `*_bot_token_missing` and outbound delivery retries rather than hard-crashing runtime.
 
 ## Running the Server

package/dist/control_plane.d.ts

@@ -4,21 +4,35 @@ import { type ControlPlaneConfig, type ControlPlaneGenerationContext, type Contr
 import { detectAdapters } from "./control_plane_adapter_registry.js";
 export type { ActiveAdapter, ControlPlaneConfig, ControlPlaneGenerationContext, ControlPlaneHandle, ControlPlaneSessionLifecycle, ControlPlaneSessionMutationAction, ControlPlaneSessionMutationResult, NotifyOperatorsOpts, NotifyOperatorsResult, TelegramGenerationReloadResult, TelegramGenerationRollbackTrigger, TelegramGenerationSwapHooks, WakeDeliveryEvent, WakeDeliveryObserver, WakeNotifyContext, WakeNotifyDecision, } from "./control_plane_contract.js";
 export { detectAdapters };
+type TelegramInlineKeyboardButton = {
+    text: string;
+    callback_data: string;
+};
+type TelegramInlineKeyboardMarkup = {
+    inline_keyboard: TelegramInlineKeyboardButton[][];
+};
 export type TelegramSendMessagePayload = {
     chat_id: string;
     text: string;
     parse_mode?: "Markdown";
     disable_web_page_preview?: boolean;
+    reply_markup?: TelegramInlineKeyboardMarkup;
+    reply_to_message_id?: number;
+    allow_sending_without_reply?: boolean;
 };
 export type TelegramSendPhotoPayload = {
     chat_id: string;
     photo: string;
     caption?: string;
+    reply_to_message_id?: number;
+    allow_sending_without_reply?: boolean;
 };
 export type TelegramSendDocumentPayload = {
     chat_id: string;
     document: string;
     caption?: string;
+    reply_to_message_id?: number;
+    allow_sending_without_reply?: boolean;
 };
 /**
  * Telegram supports a markdown dialect that uses single markers for emphasis.
@@ -32,6 +46,8 @@ export declare function buildTelegramSendMessagePayload(opts: {
     text: string;
     richFormatting: boolean;
 }): TelegramSendMessagePayload;
+export declare function splitTelegramMessageText(text: string, maxLen?: number): string[];
+export declare function splitSlackMessageText(text: string, maxLen?: number): string[];
 export declare function deliverTelegramOutboxRecord(opts: {
     botToken: string;
     record: OutboxRecord;

package/dist/control_plane.js

@@ -79,6 +79,147 @@ export function buildTelegramSendMessagePayload(opts) {
         disable_web_page_preview: true,
     };
 }
+const TELEGRAM_MESSAGE_MAX_LEN = 4_096;
+function maybeParseTelegramMessageId(value) {
+    if (typeof value === "number" && Number.isFinite(value)) {
+        return Math.trunc(value);
+    }
+    if (typeof value === "string" && /^-?\d+$/.test(value.trim())) {
+        const parsed = Number.parseInt(value.trim(), 10);
+        if (Number.isFinite(parsed)) {
+            return parsed;
+        }
+    }
+    return null;
+}
+export function splitTelegramMessageText(text, maxLen = TELEGRAM_MESSAGE_MAX_LEN) {
+    if (text.length <= maxLen) {
+        return [text];
+    }
+    const chunks = [];
+    let cursor = 0;
+    while (cursor < text.length) {
+        const end = Math.min(text.length, cursor + maxLen);
+        if (end === text.length) {
+            chunks.push(text.slice(cursor));
+            break;
+        }
+        const window = text.slice(cursor, end);
+        const splitAtNewline = window.lastIndexOf("\n");
+        const splitPoint = splitAtNewline >= Math.floor(maxLen * 0.5) ? cursor + splitAtNewline + 1 : end;
+        chunks.push(text.slice(cursor, splitPoint));
+        cursor = splitPoint;
+    }
+    return chunks;
+}
+const SLACK_MESSAGE_MAX_LEN = 3_500;
+export function splitSlackMessageText(text, maxLen = SLACK_MESSAGE_MAX_LEN) {
+    if (text.length <= maxLen) {
+        return [text];
+    }
+    const chunks = [];
+    let cursor = 0;
+    while (cursor < text.length) {
+        const end = Math.min(text.length, cursor + maxLen);
+        if (end === text.length) {
+            chunks.push(text.slice(cursor));
+            break;
+        }
+        const window = text.slice(cursor, end);
+        const splitAtNewline = window.lastIndexOf("\n");
+        const splitPoint = splitAtNewline >= Math.floor(maxLen * 0.5) ? cursor + splitAtNewline + 1 : end;
+        chunks.push(text.slice(cursor, splitPoint));
+        cursor = splitPoint;
+    }
+    return chunks;
+}
+function slackBlocksForOutboxRecord(record) {
+    const interactionMessage = record.envelope.metadata?.interaction_message;
+    if (!interactionMessage || typeof interactionMessage !== "object") {
+        return undefined;
+    }
+    const rawActions = interactionMessage.actions;
+    if (!Array.isArray(rawActions) || rawActions.length === 0) {
+        return undefined;
+    }
+    const buttons = [];
+    for (const action of rawActions) {
+        if (!action || typeof action !== "object") {
+            continue;
+        }
+        const candidate = action;
+        if (typeof candidate.label !== "string" || typeof candidate.command !== "string") {
+            continue;
+        }
+        const normalized = candidate.command.trim().replace(/^\/mu\s+/i, "");
+        const confirm = /^confirm\s+([^\s]+)$/i.exec(normalized);
+        if (confirm?.[1]) {
+            buttons.push({
+                type: "button",
+                text: { type: "plain_text", text: candidate.label },
+                value: `confirm:${confirm[1]}`,
+                action_id: `confirm_${confirm[1]}`,
+            });
+            continue;
+        }
+        const cancel = /^cancel\s+([^\s]+)$/i.exec(normalized);
+        if (cancel?.[1]) {
+            buttons.push({
+                type: "button",
+                text: { type: "plain_text", text: candidate.label },
+                value: `cancel:${cancel[1]}`,
+                action_id: `cancel_${cancel[1]}`,
+            });
+        }
+    }
+    if (buttons.length === 0) {
+        return undefined;
+    }
+    return [
+        { type: "section", text: { type: "mrkdwn", text: record.envelope.body } },
+        { type: "actions", elements: buttons },
+    ];
+}
+function slackThreadTsFromMetadata(metadata) {
+    const candidates = [metadata?.slack_thread_ts, metadata?.slack_message_ts, metadata?.thread_ts];
+    for (const value of candidates) {
+        if (typeof value === "string" && value.trim().length > 0) {
+            return value.trim();
+        }
+    }
+    return undefined;
+}
+function telegramReplyMarkupForOutboxRecord(record) {
+    const interactionMessage = record.envelope.metadata?.interaction_message;
+    if (!interactionMessage || typeof interactionMessage !== "object") {
+        return undefined;
+    }
+    const rawActions = interactionMessage.actions;
+    if (!Array.isArray(rawActions) || rawActions.length === 0) {
+        return undefined;
+    }
+    const row = [];
+    for (const action of rawActions) {
+        if (!action || typeof action !== "object") {
+            continue;
+        }
+        const candidate = action;
+        if (typeof candidate.label !== "string" || typeof candidate.command !== "string") {
+            continue;
+        }
+        const normalized = candidate.command.trim().replace(/^\/mu\s+/i, "");
+        const confirm = /^confirm\s+([^\s]+)$/i.exec(normalized);
+        if (confirm?.[1]) {
+            row.push({ text: candidate.label, callback_data: `confirm:${confirm[1]}` });
+            continue;
+        }
+        const cancel = /^cancel\s+([^\s]+)$/i.exec(normalized);
+        if (cancel?.[1]) {
+            row.push({ text: candidate.label, callback_data: `cancel:${cancel[1]}` });
+        }
+    }
+    return row.length > 0 ? { inline_keyboard: [row] } : undefined;
+}
 async function postTelegramMessage(botToken, payload) {
     return await fetch(`https://api.telegram.org/bot${botToken}/sendMessage`, {
         method: "POST",
@@ -133,37 +274,76 @@ function parseRetryDelayMs(res) {
     }
     return parsed * 1000;
 }
+async function sendTelegramTextChunks(opts) {
+    const chunks = splitTelegramMessageText(opts.basePayload.text);
+    for (const [index, chunk] of chunks.entries()) {
+        const payload = {
+            ...opts.basePayload,
+            text: chunk,
+            ...(index === 0 ? {} : { reply_markup: undefined, reply_to_message_id: undefined, allow_sending_without_reply: undefined }),
+        };
+        let res = await postTelegramMessage(opts.botToken, payload);
+        if (!res.ok && res.status === 400 && payload.parse_mode && opts.fallbackToPlainOnMarkdownError) {
+            const plainPayload = buildTelegramSendMessagePayload({
+                chatId: payload.chat_id,
+                text: payload.text,
+                richFormatting: false,
+            });
+            res = await postTelegramMessage(opts.botToken, {
+                ...plainPayload,
+                ...(payload.reply_markup ? { reply_markup: payload.reply_markup } : {}),
+                ...(payload.reply_to_message_id != null
+                    ? {
+                        reply_to_message_id: payload.reply_to_message_id,
+                        allow_sending_without_reply: payload.allow_sending_without_reply,
+                    }
+                    : {}),
+            });
+        }
+        if (!res.ok) {
+            return { ok: false, response: res, body: await res.text().catch(() => "") };
+        }
+    }
+    return { ok: true };
+}
 export async function deliverTelegramOutboxRecord(opts) {
     const { botToken, record } = opts;
-    const fallbackMessagePayload = buildTelegramSendMessagePayload({
-        chatId: record.envelope.channel_conversation_id,
-        text: record.envelope.body,
-        richFormatting: true,
-    });
+    const replyMarkup = telegramReplyMarkupForOutboxRecord(record);
+    const replyToMessageId = maybeParseTelegramMessageId(record.envelope.metadata?.telegram_reply_to_message_id);
+    const fallbackMessagePayload = {
+        ...buildTelegramSendMessagePayload({
+            chatId: record.envelope.channel_conversation_id,
+            text: record.envelope.body,
+            richFormatting: true,
+        }),
+        ...(replyMarkup ? { reply_markup: replyMarkup } : {}),
+        ...(replyToMessageId != null
+            ? {
+                reply_to_message_id: replyToMessageId,
+                allow_sending_without_reply: true,
+            }
+            : {}),
+    };
     const firstAttachment = record.envelope.attachments?.[0] ?? null;
     if (!firstAttachment) {
-        let res = await postTelegramMessage(botToken, fallbackMessagePayload);
-        if (!res.ok && res.status === 400 && fallbackMessagePayload.parse_mode) {
-            res = await postTelegramMessage(botToken, buildTelegramSendMessagePayload({
-                chatId: record.envelope.channel_conversation_id,
-                text: record.envelope.body,
-                richFormatting: false,
-            }));
-        }
-        if (res.ok) {
+        const sent = await sendTelegramTextChunks({
+            botToken,
+            basePayload: fallbackMessagePayload,
+            fallbackToPlainOnMarkdownError: true,
+        });
+        if (sent.ok) {
             return { kind: "delivered" };
         }
-        const responseBody = await res.text().catch(() => "");
-        if (res.status === 429 || res.status >= 500) {
+        if (sent.response.status === 429 || sent.response.status >= 500) {
             return {
                 kind: "retry",
-                error: `telegram sendMessage ${res.status}: ${responseBody}`,
-                retryDelayMs: parseRetryDelayMs(res),
+                error: `telegram sendMessage ${sent.response.status}: ${sent.body}`,
+                retryDelayMs: parseRetryDelayMs(sent.response),
             };
         }
         return {
             kind: "retry",
-            error: `telegram sendMessage ${res.status}: ${responseBody}`,
+            error: `telegram sendMessage ${sent.response.status}: ${sent.body}`,
         };
     }
     const mediaMethod = chooseTelegramMediaMethod(firstAttachment);
@@ -180,11 +360,23 @@ export async function deliverTelegramOutboxRecord(opts) {
                 chat_id: record.envelope.channel_conversation_id,
                 photo: firstAttachment.reference.file_id,
                 caption: mediaCaption,
+                ...(replyToMessageId != null
+                    ? {
+                        reply_to_message_id: replyToMessageId,
+                        allow_sending_without_reply: true,
+                    }
+                    : {}),
             }
             : {
                 chat_id: record.envelope.channel_conversation_id,
                 document: firstAttachment.reference.file_id,
                 caption: mediaCaption,
+                ...(replyToMessageId != null
+                    ? {
+                        reply_to_message_id: replyToMessageId,
+                        allow_sending_without_reply: true,
+                    }
+                    : {}),
             });
     }
     else {
@@ -206,6 +398,10 @@ export async function deliverTelegramOutboxRecord(opts) {
         if (mediaCaption.length > 0) {
             form.append("caption", mediaCaption);
         }
+        if (replyToMessageId != null) {
+            form.append("reply_to_message_id", String(replyToMessageId));
+            form.append("allow_sending_without_reply", "true");
+        }
         form.append(mediaField, new Blob([body], { type: contentType }), filename);
         mediaResponse = await postTelegramApiMultipart(botToken, mediaMethod, form);
     }
@@ -220,26 +416,38 @@ export async function deliverTelegramOutboxRecord(opts) {
             retryDelayMs: parseRetryDelayMs(mediaResponse),
         };
     }
-    const fallbackPlainPayload = buildTelegramSendMessagePayload({
-        chatId: record.envelope.channel_conversation_id,
-        text: record.envelope.body,
-        richFormatting: false,
+    const fallbackPlainPayload = {
+        ...buildTelegramSendMessagePayload({
+            chatId: record.envelope.channel_conversation_id,
+            text: record.envelope.body,
+            richFormatting: false,
+        }),
+        ...(replyMarkup ? { reply_markup: replyMarkup } : {}),
+        ...(replyToMessageId != null
+            ? {
+                reply_to_message_id: replyToMessageId,
+                allow_sending_without_reply: true,
+            }
+            : {}),
+    };
+    const fallbackSent = await sendTelegramTextChunks({
+        botToken,
+        basePayload: fallbackPlainPayload,
+        fallbackToPlainOnMarkdownError: false,
     });
-    const fallbackRes = await postTelegramMessage(botToken, fallbackPlainPayload);
-    if (fallbackRes.ok) {
+    if (fallbackSent.ok) {
         return { kind: "delivered" };
     }
-    const fallbackBody = await fallbackRes.text().catch(() => "");
-    if (fallbackRes.status === 429 || fallbackRes.status >= 500) {
+    if (fallbackSent.response.status === 429 || fallbackSent.response.status >= 500) {
         return {
             kind: "retry",
-            error: `telegram media fallback sendMessage ${fallbackRes.status}: ${fallbackBody}`,
-            retryDelayMs: parseRetryDelayMs(fallbackRes),
+            error: `telegram media fallback sendMessage ${fallbackSent.response.status}: ${fallbackSent.body}`,
+            retryDelayMs: parseRetryDelayMs(fallbackSent.response),
         };
     }
     return {
         kind: "retry",
-        error: `telegram media fallback sendMessage ${fallbackRes.status}: ${fallbackBody} (media_error=${mediaMethod} ${mediaResponse.status}: ${mediaBody})`,
+        error: `telegram media fallback sendMessage ${fallbackSent.response.status}: ${fallbackSent.body} (media_error=${mediaMethod} ${mediaResponse.status}: ${mediaBody})`,
     };
 }
 async function postSlackJson(opts) {
@@ -257,30 +465,38 @@ async function postSlackJson(opts) {
 export async function deliverSlackOutboxRecord(opts) {
     const { botToken, record } = opts;
     const attachments = record.envelope.attachments ?? [];
+    const textChunks = splitSlackMessageText(record.envelope.body);
+    const blocks = slackBlocksForOutboxRecord(record);
+    const threadTs = slackThreadTsFromMetadata(record.envelope.metadata);
     if (attachments.length === 0) {
-        const delivered = await postSlackJson({
-            botToken,
-            method: "chat.postMessage",
-            payload: {
-                channel: record.envelope.channel_conversation_id,
-                text: record.envelope.body,
-                unfurl_links: false,
-                unfurl_media: false,
-            },
-        });
-        if (delivered.response.ok && delivered.payload?.ok) {
-            return { kind: "delivered" };
-        }
-        const status = delivered.response.status;
-        const err = delivered.payload?.error ?? "unknown_error";
-        if (status === 429 || status >= 500) {
-            return {
-                kind: "retry",
-                error: `slack chat.postMessage ${status}: ${err}`,
-                retryDelayMs: parseRetryDelayMs(delivered.response),
-            };
+        for (const [index, chunk] of textChunks.entries()) {
+            const delivered = await postSlackJson({
+                botToken,
+                method: "chat.postMessage",
+                payload: {
+                    channel: record.envelope.channel_conversation_id,
+                    text: chunk,
+                    unfurl_links: false,
+                    unfurl_media: false,
+                    ...(index === 0 && blocks ? { blocks } : {}),
+                    ...(threadTs ? { thread_ts: threadTs } : {}),
+                },
+            });
+            if (delivered.response.ok && delivered.payload?.ok) {
+                continue;
+            }
+            const status = delivered.response.status;
+            const err = delivered.payload?.error ?? "unknown_error";
+            if (status === 429 || status >= 500) {
+                return {
+                    kind: "retry",
+                    error: `slack chat.postMessage ${status}: ${err}`,
+                    retryDelayMs: parseRetryDelayMs(delivered.response),
+                };
+            }
+            return { kind: "retry", error: `slack chat.postMessage ${status}: ${err}` };
         }
-        return { kind: "retry", error: `slack chat.postMessage ${status}: ${err}` };
+        return { kind: "delivered" };
     }
     let firstError = null;
     for (const [index, attachment] of attachments.entries()) {
@@ -311,7 +527,10 @@ export async function deliverSlackOutboxRecord(opts) {
         form.set("filename", filename);
         form.set("title", filename);
         if (index === 0 && record.envelope.body.trim().length > 0) {
-            form.set("initial_comment", record.envelope.body);
+            form.set("initial_comment", textChunks[0] ?? record.envelope.body);
+        }
+        if (threadTs) {
+            form.set("thread_ts", threadTs);
         }
         form.set("file", new Blob([bytes], { type: contentType }), filename);
         const uploaded = await fetch("https://slack.com/api/files.upload", {
@@ -337,33 +556,39 @@ export async function deliverSlackOutboxRecord(opts) {
             }
         }
     }
-    if (firstError) {
-        const fallback = await postSlackJson({
-            botToken,
-            method: "chat.postMessage",
-            payload: {
-                channel: record.envelope.channel_conversation_id,
-                text: record.envelope.body,
-                unfurl_links: false,
-                unfurl_media: false,
-            },
-        });
-        if (fallback.response.ok && fallback.payload?.ok) {
-            return { kind: "delivered" };
-        }
-        const status = fallback.response.status;
-        const err = fallback.payload?.error ?? "unknown_error";
-        if (status === 429 || status >= 500) {
+    if (firstError || textChunks.length > 1) {
+        for (const [index, chunk] of textChunks.entries()) {
+            if (index === 0 && !firstError) {
+                continue;
+            }
+            const fallback = await postSlackJson({
+                botToken,
+                method: "chat.postMessage",
+                payload: {
+                    channel: record.envelope.channel_conversation_id,
+                    text: chunk,
+                    unfurl_links: false,
+                    unfurl_media: false,
+                    ...(threadTs ? { thread_ts: threadTs } : {}),
+                },
+            });
+            if (fallback.response.ok && fallback.payload?.ok) {
+                continue;
+            }
+            const status = fallback.response.status;
+            const err = fallback.payload?.error ?? "unknown_error";
+            if (status === 429 || status >= 500) {
+                return {
+                    kind: "retry",
+                    error: `slack chat.postMessage fallback ${status}: ${err}${firstError ? ` (upload_error=${firstError})` : ""}`,
+                    retryDelayMs: parseRetryDelayMs(fallback.response),
+                };
+            }
             return {
                 kind: "retry",
-                error: `slack chat.postMessage fallback ${status}: ${err} (upload_error=${firstError})`,
-                retryDelayMs: parseRetryDelayMs(fallback.response),
+                error: `slack chat.postMessage fallback ${status}: ${err}${firstError ? ` (upload_error=${firstError})` : ""}`,
             };
         }
-        return {
-            kind: "retry",
-            error: `slack chat.postMessage fallback ${status}: ${err} (upload_error=${firstError})`,
-        };
     }
     return { kind: "delivered" };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@femtomc/mu-server",
-  "version": "26.2.95",
+  "version": "26.2.96",
   "description": "HTTP API server for mu control-plane transport/session plus run/activity scheduling coordination.",
   "keywords": [
     "mu",
@@ -30,8 +30,8 @@
     "start": "bun run dist/cli.js"
   },
   "dependencies": {
-    "@femtomc/mu-agent": "26.2.95",
-    "@femtomc/mu-control-plane": "26.2.95",
-    "@femtomc/mu-core": "26.2.95"
+    "@femtomc/mu-agent": "26.2.96",
+    "@femtomc/mu-control-plane": "26.2.96",
+    "@femtomc/mu-core": "26.2.96"
   }
 }