@llblab/pi-telegram 0.52.2 → 0.53.1

package/dist/lib/outbound-attachments.d.ts

@@ -37,8 +37,8 @@ export interface TelegramOutboundMessagePlan {
     markdown: string;
     replyMarkup?: unknown;
 }
-export interface TelegramOutboundMessageToolRegistrationDeps extends TelegramOutboundAttachmentRuntimeEventRecorderPort {
-    getDefaultChatId: () => number | undefined;
+export interface TelegramOutboundMessageDeliveryPorts {
+    getDefaultChatId?: () => number | undefined;
     getDefaultTarget?: () => TelegramTarget | undefined;
     getActiveTurn?: () => {
         chatId: number;
@@ -63,6 +63,9 @@ export interface TelegramOutboundMessageToolRegistrationDeps extends TelegramOut
         replyMarkup?: unknown;
     }) => Promise<number | undefined>;
 }
+export interface TelegramOutboundMessageToolRegistrationDeps extends TelegramOutboundMessageDeliveryPorts, TelegramOutboundAttachmentRuntimeEventRecorderPort {
+    getDefaultChatId: () => number | undefined;
+}
 export interface TelegramQueuedOutboundAttachmentView {
     path: string;
     fileName: string;
@@ -169,7 +172,7 @@ export declare function deliverTelegramGuestCachedAttachment(options: {
     deleteMessage: (chatId: number, messageId: number) => Promise<void>;
     recordRuntimeEvent?: TelegramOutboundAttachmentRuntimeEventRecorderPort["recordRuntimeEvent"];
 }): Promise<void>;
-export declare function sendTelegramOutboundMessage(options: {
+export declare function sendTelegramOutboundMessage(options: TelegramOutboundMessageDeliveryPorts & {
     text: string;
     media?: string;
     operationId?: string;
@@ -178,30 +181,6 @@ export declare function sendTelegramOutboundMessage(options: {
     threadId?: number;
     agentThread?: string | number;
     target?: TelegramTarget;
-    getDefaultChatId?: () => number | undefined;
-    getDefaultTarget?: () => TelegramTarget | undefined;
-    getActiveTurn?: () => {
-        chatId: number;
-        target?: TelegramTarget;
-    } | undefined;
-    resolveAgentTarget?: (selector: TelegramBusAgentTargetSelector) => Promise<TelegramTarget & {
-        threadId: number;
-    }>;
-    routeAgentMessage?: (message: TelegramBusAgentMessage) => Promise<void>;
-    canSendDirect: () => boolean;
-    planMessage: (markdown: string) => TelegramOutboundMessagePlan;
-    sendMarkdownMessage: (chatId: number, markdown: string, options?: {
-        replyMarkup?: unknown;
-        target?: TelegramTarget;
-    }) => Promise<number | undefined>;
-    sendChannelMarkdownMessage?: (channel: number | string, markdown: string, options: {
-        operationId: string;
-        replyMarkup?: unknown;
-    }) => Promise<number | undefined>;
-    sendChannelMediaMessage?: (channel: number | string, mediaPath: string, markdown: string, options: {
-        operationId: string;
-        replyMarkup?: unknown;
-    }) => Promise<number | undefined>;
 }): Promise<{
     content: Array<{
         type: "text";

package/dist/lib/outbound-attachments.js

@@ -8,10 +8,11 @@ import { basename } from "node:path";
 import { Type } from "@sinclair/typebox";
 import { isTelegramChannelPostValidationError, TelegramChannelPostValidationError, } from "./channel-posts.js";
 import { TELEGRAM_ATTACH_PROMPT_GUIDELINES, TELEGRAM_ATTACH_PROMPT_SNIPPET, TELEGRAM_MESSAGE_PROMPT_GUIDELINES, TELEGRAM_MESSAGE_PROMPT_SNIPPET, } from "./prompts.js";
-import { withTelegramReplyParameters, normalizeTelegramNativeMarkdown, } from "./replies.js";
+import { normalizeTelegramNativeMarkdown, withTelegramReplyParameters, } from "./replies.js";
 import { getTelegramTargetThreadParams, } from "./target.js";
 const MAX_ATTACHMENTS_PER_TURN = 10;
 export const TELEGRAM_OUTBOUND_ATTACHMENT_DEFAULT_MAX_BYTES = 50 * 1024 * 1024;
+// Deliberately local: outbound attachment delivery stays decoupled from Bot API helpers.
 export function getTelegramOutboundAttachmentByteLimitFromEnv(env, names, defaultValue = TELEGRAM_OUTBOUND_ATTACHMENT_DEFAULT_MAX_BYTES) {
     for (const name of names) {
         const rawValue = env[name]?.trim();
@@ -102,8 +103,14 @@ export function createTelegramRichOutboundAttachmentSender(deps) {
         if (!plan)
             return false;
         try {
-            const result = await withTelegramReplyParameters(turn.chatId, turn.replyToMessageId, turn.target, (replyParameters) => deps.sendMultipart(plan.method, { ...plan.fields, ...(replyParameters ? { reply_parameters: JSON.stringify(replyParameters) } : {}) }, plan.fileField, plan.filePath, plan.fileName));
-            const messageId = result && typeof result === "object" &&
+            const result = await withTelegramReplyParameters(turn.chatId, turn.replyToMessageId, turn.target, (replyParameters) => deps.sendMultipart(plan.method, {
+                ...plan.fields,
+                ...(replyParameters
+                    ? { reply_parameters: JSON.stringify(replyParameters) }
+                    : {}),
+            }, plan.fileField, plan.filePath, plan.fileName));
+            const messageId = result &&
+                typeof result === "object" &&
                 Number.isInteger(result.message_id)
                 ? result.message_id
                 : undefined;
@@ -162,8 +169,16 @@ function formatTelegramOutboundAttachmentToolResultText(count, mode = "queued")
     const verb = mode === "queued" ? "Queued" : "Sent";
     return ["", `${verb} ${count} Telegram attachment(s).`].join("\n");
 }
-function formatTelegramOutboundMessageToolResultText(chatId) {
-    return ["", `Sent Telegram message to ${chatId}.`].join("\n");
+function buildTelegramOutboundMessageToolResult(chatId, messageId) {
+    return {
+        content: [
+            {
+                type: "text",
+                text: ["", `Sent Telegram message to ${chatId}.`].join("\n"),
+            },
+        ],
+        details: { chatId, messageId },
+    };
 }
 function getTelegramMultipartTargetFields(target) {
     if (!target)
@@ -280,10 +295,9 @@ export function registerTelegramOutboundMessageTool(pi, deps) {
                 minLength: 1,
                 description: "Local single-file channel upload: .jpg/.jpeg/.png/.webp photo or .mp4 video; the text becomes its caption (max 1024 characters). Albums and other media types are rejected.",
             })),
-            chat_id: Type.Optional(Type.Union([
-                Type.Number(),
-                Type.String({ pattern: "^@[A-Za-z0-9_]{5,32}$" }),
-            ], { description: "Optional exact Telegram chat id or public channel @username" })),
+            chat_id: Type.Optional(Type.Union([Type.Number(), Type.String({ pattern: "^@[A-Za-z0-9_]{5,32}$" })], {
+                description: "Optional exact Telegram chat id or public channel @username",
+            })),
             thread_id: Type.Optional(Type.Number({
                 description: "Optional Telegram topic thread id with chat_id",
             })),
@@ -318,11 +332,12 @@ export function registerTelegramOutboundMessageTool(pi, deps) {
             }
             catch (error) {
                 const isChannelTarget = typeof params.chat_id === "string" || params.channel === true;
-                const reportableError = isChannelTarget &&
-                    !isTelegramChannelPostValidationError(error)
+                const reportableError = isChannelTarget && !isTelegramChannelPostValidationError(error)
                     ? new Error("Telegram channel publication failed; inspect the retained local record before retrying.")
                     : error;
-                deps.recordRuntimeEvent?.("message", reportableError, { phase: "direct" });
+                deps.recordRuntimeEvent?.("message", reportableError, {
+                    phase: "direct",
+                });
                 throw formatTelegramOutboundToolError(reportableError);
             }
         },
@@ -435,9 +450,7 @@ export async function deliverTelegramGuestCachedAttachment(options) {
         await options.answerGuestQuery(options.guestQueryId, result);
     }
     catch (error) {
-        if (!answerAttempted &&
-            options.answerGuestText &&
-            options.fallbackText) {
+        if (!answerAttempted && options.answerGuestText && options.fallbackText) {
             answerAttempted = true;
             await options.answerGuestText(options.guestQueryId, options.fallbackText);
         }
@@ -464,10 +477,14 @@ export async function sendTelegramOutboundMessage(options) {
     assertTelegramDirectDeliveryAllowed(options.canSendDirect);
     const activeTurn = options.getActiveTurn?.();
     if (typeof options.chatId === "string" || options.channel === true) {
-        if (!((typeof options.chatId === "string" && /^@[A-Za-z0-9_]{5,32}$/u.test(options.chatId)) ||
-            (typeof options.chatId === "number" && Number.isSafeInteger(options.chatId) && options.chatId < 0)) ||
+        if (!((typeof options.chatId === "string" &&
+            /^@[A-Za-z0-9_]{5,32}$/u.test(options.chatId)) ||
+            (typeof options.chatId === "number" &&
+                Number.isSafeInteger(options.chatId) &&
+                options.chatId < 0)) ||
             options.threadId !== undefined ||
-            options.target !== undefined || options.agentThread !== undefined) {
+            options.target !== undefined ||
+            options.agentThread !== undefined) {
             throw new Error("Telegram channel delivery requires one exact @username or negative numeric channel ID without a thread target.");
         }
         const plan = options.planMessage(options.text);
@@ -476,18 +493,13 @@ export async function sendTelegramOutboundMessage(options) {
                 throw new TelegramChannelPostValidationError("Telegram channel media delivery requires direct leader transport ownership and operation identity.");
             }
             const messageId = await options.sendChannelMediaMessage(options.chatId, options.media, plan.markdown, { operationId: options.operationId, replyMarkup: plan.replyMarkup });
-            return { content: [{ type: "text",
-                        text: formatTelegramOutboundMessageToolResultText(options.chatId) }],
-                details: { chatId: options.chatId, messageId } };
+            return buildTelegramOutboundMessageToolResult(options.chatId, messageId);
         }
         if (!options.sendChannelMarkdownMessage || !options.operationId) {
             throw new Error("Telegram channel delivery requires direct leader transport ownership and operation identity.");
         }
-        const messageId = await options.sendChannelMarkdownMessage(options.chatId, plan.markdown, { operationId: options.operationId,
-            replyMarkup: plan.replyMarkup });
-        return { content: [{ type: "text",
-                    text: formatTelegramOutboundMessageToolResultText(options.chatId) }],
-            details: { chatId: options.chatId, messageId } };
+        const messageId = await options.sendChannelMarkdownMessage(options.chatId, plan.markdown, { operationId: options.operationId, replyMarkup: plan.replyMarkup });
+        return buildTelegramOutboundMessageToolResult(options.chatId, messageId);
     }
     if (options.media !== undefined) {
         throw new TelegramChannelPostValidationError("telegram_message media uploads require channel delivery with an exact @username or negative numeric channel ID and channel: true.");
@@ -499,7 +511,7 @@ export async function sendTelegramOutboundMessage(options) {
         : activeTurn &&
             options.resolveAgentTarget &&
             options.routeAgentMessage &&
-            ((options.target?.threadId !== undefined) ||
+            (options.target?.threadId !== undefined ||
                 (options.chatId !== undefined && options.threadId !== undefined))
             ? {
                 chatId: options.target?.chatId ?? options.chatId,
@@ -547,15 +559,7 @@ export async function sendTelegramOutboundMessage(options) {
             text: options.text,
         });
     }
-    return {
-        content: [
-            {
-                type: "text",
-                text: formatTelegramOutboundMessageToolResultText(chatId),
-            },
-        ],
-        details: { chatId, messageId },
-    };
+    return buildTelegramOutboundMessageToolResult(chatId, messageId);
 }
 export async function sendTelegramOutboundFiles(options) {
     assertTelegramDirectDeliveryAllowed(options.canSendDirect);
@@ -599,7 +603,8 @@ export function createTelegramQueuedOutboundAttachmentSender(deps) {
     return async (turn, options) => {
         await sendQueuedTelegramOutboundAttachments(turn, {
             ...deps,
-            isDeliveryActive: () => deps.isDeliveryActive?.() !== false && options?.isDeliveryActive?.() !== false,
+            isDeliveryActive: () => deps.isDeliveryActive?.() !== false &&
+                options?.isDeliveryActive?.() !== false,
             maxAttachmentSizeBytes: deps.maxAttachmentSizeBytes ?? TELEGRAM_OUTBOUND_ATTACHMENT_MAX_BYTES,
         });
     };
@@ -622,7 +627,9 @@ export async function sendQueuedTelegramOutboundAttachments(turn, deps) {
             const fieldName = isPhoto ? "photo" : "document";
             await withTelegramReplyParameters(turn.chatId, turn.replyToMessageId, turn.target, (replyParameters) => deps.sendMultipart(method, {
                 chat_id: String(turn.chatId),
-                ...(replyParameters ? { reply_parameters: JSON.stringify(replyParameters) } : {}),
+                ...(replyParameters
+                    ? { reply_parameters: JSON.stringify(replyParameters) }
+                    : {}),
                 ...getTelegramMultipartTargetFields(turn.target),
             }, fieldName, attachment.path, attachment.fileName));
         }

package/dist/lib/outbound-buttons.js

@@ -83,12 +83,14 @@ function escapeTelegramRichButtonText(text) {
     return text.replace(/[&<>"'`\\*_\[\]{}$~\r\n]/g, (character) => `&#${character.charCodeAt(0)};`);
 }
 function renderTelegramRichButtonRow(row) {
-    return `<tg-button-row>${row.map((button) => {
+    return `<tg-button-row>${row
+        .map((button) => {
         const attributes = button.disabled
             ? 'type="disabled"'
             : `type="callback_data" data="${escapeTelegramRichButtonText(button.callback_data)}"`;
         return `<tg-button ${attributes}>${escapeTelegramRichButtonText(button.text)}</tg-button>`;
-    }).join("")}</tg-button-row>`;
+    })
+        .join("")}</tg-button-row>`;
 }
 export function planTelegramButtonReply(markdown, deps) {
     const keyboard = [];
@@ -96,12 +98,14 @@ export function planTelegramButtonReply(markdown, deps) {
         const actions = payloadRows.map((row) => row.map(parseTelegramButtonAction));
         if (actions.some((row) => row.some((action) => !action)))
             return undefined;
-        if (rich && actions.some((row) => {
-            const projected = row.map((action) => action.disabled
-                ? { text: action.text || "\u00a0", disabled: {} }
-                : { text: action.text, callback_data: "x".repeat(64) });
-            return row.length > 8 || renderTelegramRichButtonRow(projected).length > 32768;
-        }))
+        if (rich &&
+            actions.some((row) => {
+                const projected = row.map((action) => action.disabled
+                    ? { text: action.text || "\u00a0", disabled: {} }
+                    : { text: action.text, callback_data: "x".repeat(64) });
+                return (row.length > 8 ||
+                    renderTelegramRichButtonRow(projected).length > 32768);
+            }))
             return undefined;
         return actions.map((row) => row.map((action) => action.disabled
             ? { text: action.text || "\u00a0", disabled: {} }
@@ -131,7 +135,9 @@ export function planTelegramButtonReply(markdown, deps) {
     });
     const stripped = replaceTopLevelHtmlComments(withRichButtons, (comment) => {
         const command = "telegram_button";
-        const normalizedContent = comment.content.replace(/^\s+/, "").replace(/^!/, "");
+        const normalizedContent = comment.content
+            .replace(/^\s+/, "")
+            .replace(/^!/, "");
         if (!normalizedContent.startsWith(command))
             return comment.raw;
         const payloadRows = parseTelegramActionPayloadRows(comment, command);
@@ -186,19 +192,19 @@ export async function handleTelegramButtonCallbackQuery(query, ctx, deps) {
     const action = deps.resolveAction(query.data);
     if (!action) {
         if (query.data?.startsWith(`${TELEGRAM_BUTTON_CALLBACK_PREFIX}:`)) {
-            await deps.answerCallbackQuery(query.id, "Button action expired.");
+            await deps.answerCallbackQuery(query.id, "Button action expired");
             return true;
         }
         return false;
     }
     if (action.disabled) {
-        await deps.answerCallbackQuery(query.id, "Button action unavailable.");
+        await deps.answerCallbackQuery(query.id, "Button action unavailable");
         return true;
     }
     const chatId = query.message?.chat?.id;
     const messageId = query.message?.message_id;
     if (typeof chatId !== "number" || typeof messageId !== "number") {
-        await deps.answerCallbackQuery(query.id, "Button action expired.");
+        await deps.answerCallbackQuery(query.id, "Button action expired");
         return true;
     }
     if (deps.invokeBoundAction) {
@@ -216,18 +222,18 @@ export async function handleTelegramButtonCallbackQuery(query, ctx, deps) {
                         }
                     }
                 }
-                await deps.answerCallbackQuery(query.id, "Done.");
+                await deps.answerCallbackQuery(query.id, "Done");
                 return true;
             }
         }
         catch (error) {
-            await deps.answerCallbackQuery(query.id, "Generative App action failed.");
+            await deps.answerCallbackQuery(query.id, "Generative App action failed");
             throw error;
         }
     }
     const enqueued = deps.enqueueButtonPrompt(query, action, ctx);
     if (enqueued === false) {
-        await deps.answerCallbackQuery(query.id, "Already queued.");
+        await deps.answerCallbackQuery(query.id, "Already queued");
         return true;
     }
     const selectedMarkup = query.data && query.message?.reply_markup
@@ -236,6 +242,6 @@ export async function handleTelegramButtonCallbackQuery(query, ctx, deps) {
     if (selectedMarkup && deps.editMessageReplyMarkup) {
         await deps.editMessageReplyMarkup(chatId, messageId, selectedMarkup);
     }
-    await deps.answerCallbackQuery(query.id, "Queued.");
+    await deps.answerCallbackQuery(query.id, "Queued");
     return true;
 }

package/dist/lib/outbound-markup.d.ts

@@ -17,10 +17,8 @@ export declare function replaceTelegramButtonFences(markdown: string, replace: (
 export declare function replaceTopLevelHtmlComments(markdown: string, replacer: (comment: TelegramTopLevelHtmlComment) => string): string;
 export declare function parseTelegramButtonPayloadRows(source: string): Record<string, unknown>[][] | undefined;
 export declare function parseTelegramActionPayloadRows(comment: TelegramTopLevelHtmlComment, command: string): Record<string, unknown>[][] | undefined;
-export declare function normalizeMarkdownAfterVoiceExtraction(markdown: string): string;
 export declare function stripTelegramCommentMarkupForPreview(markdown: string): string;
 export declare function stripTelegramCommentMarkupForDelivery(markdown: string): string;
-export declare function stripTelegramVoiceMarkupForPreview(markdown: string): string;
 export interface TelegramVoiceReplyItem {
     text: string;
     lang?: string;

package/dist/lib/outbound-markup.js

@@ -192,7 +192,9 @@ function removeTelegramJsonTrailingCommas(source) {
 }
 function parseTelegramJsonObjectCandidate(source) {
     const normalized = removeTelegramJsonTrailingCommas(source);
-    for (const candidate of normalized === source ? [source] : [source, normalized]) {
+    for (const candidate of normalized === source
+        ? [source]
+        : [source, normalized]) {
         try {
             const value = JSON.parse(candidate);
             if (isTelegramActionPayload(value))
@@ -207,36 +209,46 @@ function parseTelegramJsonObjectCandidate(source) {
 function looksLikeTelegramNamedJsonObject(source, offset) {
     return /^\{\s*"(?:[^"\\]|\\.)*"\s*:/u.test(source.slice(offset));
 }
-function parseTelegramActionPayload(comment, command) {
+/** Blank one structured span so tolerant attribute parsing never reads keys inside rejected JSON or matrices. */
+function blankTelegramActionSpan(text, start, end) {
+    return `${text.slice(0, start)}${" ".repeat(end - start)}${text.slice(end)}`;
+}
+/**
+ * Scans one action comment for its first accepted structured payload. Otherwise returns the attribute envelope
+ * with every structured span blanked; implausible `[` starts are skipped without a parse attempt.
+ */
+function scanTelegramActionComment(comment, command, parseStructured) {
     let content = comment.content.replace(/^\s+/, "").replace(/^!/, "");
     if (!content.startsWith(command))
         return undefined;
     content = content.slice(command.length);
     let attributeEnvelope = content;
     for (let offset = 0; offset < content.length; offset += 1) {
-        if (content[offset] !== "{" && content[offset] !== "[")
+        const char = content[offset];
+        if (char !== "{" && char !== "[")
             continue;
-        if (content[offset] === "[" &&
-            !isPlausibleTelegramMatrixStart(content, offset)) {
-            const noiseEnd = findTelegramStructuredPayloadEnd(content, offset);
-            if (noiseEnd !== undefined) {
-                attributeEnvelope = `${attributeEnvelope.slice(0, offset)}${" ".repeat(noiseEnd - offset)}${attributeEnvelope.slice(noiseEnd)}`;
-                offset = noiseEnd - 1;
-            }
-            continue;
-        }
-        if (content[offset] === "{") {
-            const parsed = parseTelegramAdaptiveActionPayloadRows(content.slice(offset), parseTelegramVoiceCompactActionPayload, { allowTrailing: true });
-            if (parsed)
-                return parsed.rows[0][0];
+        if (char === "{" || isPlausibleTelegramMatrixStart(content, offset)) {
+            const payload = parseStructured(content, offset);
+            if (payload !== undefined)
+                return { payload };
         }
         const end = findTelegramStructuredPayloadEnd(content, offset);
         if (end === undefined)
             continue;
-        attributeEnvelope = `${attributeEnvelope.slice(0, offset)}${" ".repeat(end - offset)}${attributeEnvelope.slice(end)}`;
+        attributeEnvelope = blankTelegramActionSpan(attributeEnvelope, offset, end);
         offset = end - 1;
     }
-    return parseTolerantTelegramAttributes(attributeEnvelope, [
+    return { attributeEnvelope };
+}
+function parseTelegramActionPayload(comment, command) {
+    const scanned = scanTelegramActionComment(comment, command, (content, offset) => content[offset] === "{"
+        ? parseTelegramAdaptiveActionPayloadRows(content.slice(offset), parseTelegramVoiceCompactActionPayload, { allowTrailing: true })?.rows[0][0]
+        : undefined);
+    if (!scanned)
+        return undefined;
+    if ("payload" in scanned)
+        return scanned.payload;
+    return parseTolerantTelegramAttributes(scanned.attributeEnvelope, [
         "text",
         "value",
         "lang",
@@ -259,7 +271,10 @@ function parseTelegramButtonCompactActionPayload(atoms) {
         selectedStyle !== "danger" &&
         !(atoms.length === 4 && selectedStyle === ""))
         return undefined;
-    if (atoms.length === 4 && !isDisabled && disabled !== "0" && disabled !== "false") {
+    if (atoms.length === 4 &&
+        !isDisabled &&
+        disabled !== "0" &&
+        disabled !== "false") {
         return undefined;
     }
     return {
@@ -464,9 +479,7 @@ function parseTelegramAdaptiveActionPayloadRows(source, parseCompactPayload, opt
         return rows.length > 0 ? rows : undefined;
     };
     skipWhitespace();
-    const rows = source[offset] === "{"
-        ? parseVerticalSequence()
-        : parseMatrix();
+    const rows = source[offset] === "{" ? parseVerticalSequence() : parseMatrix();
     if (!rows)
         return undefined;
     skipWhitespace();
@@ -511,57 +524,32 @@ function isPlausibleTelegramMatrixStart(source, start) {
     let offset = start + 1;
     while (/\s/u.test(source[offset] ?? ""))
         offset += 1;
-    return (source[offset] === "{" ||
-        source[offset] === "[" ||
-        source[offset] === "]");
+    return (source[offset] === "{" || source[offset] === "[" || source[offset] === "]");
 }
 export function parseTelegramButtonPayloadRows(source) {
     return parseTelegramAdaptiveActionPayloadRows(source.trim(), parseTelegramButtonCompactActionPayload, { maxCompactAtoms: 4 })?.rows;
 }
 export function parseTelegramActionPayloadRows(comment, command) {
-    let content = comment.content.replace(/^\s+/, "").replace(/^!/, "");
-    if (!content.startsWith(command))
+    const scanned = scanTelegramActionComment(comment, command, (content, offset) => parseTelegramAdaptiveActionPayloadRows(content.slice(offset), parseTelegramButtonCompactActionPayload, { allowTrailing: true, maxCompactAtoms: 4 })?.rows);
+    if (!scanned)
         return undefined;
-    content = content.slice(command.length);
-    let attributeEnvelope = content;
-    for (let offset = 0; offset < content.length; offset += 1) {
-        if (content[offset] !== "[" && content[offset] !== "{")
-            continue;
-        if (content[offset] === "[" &&
-            !isPlausibleTelegramMatrixStart(content, offset)) {
-            const noiseEnd = findTelegramStructuredPayloadEnd(content, offset);
-            if (noiseEnd !== undefined) {
-                attributeEnvelope = `${attributeEnvelope.slice(0, offset)}${" ".repeat(noiseEnd - offset)}${attributeEnvelope.slice(noiseEnd)}`;
-                offset = noiseEnd - 1;
-            }
-            continue;
-        }
-        const parsed = parseTelegramAdaptiveActionPayloadRows(content.slice(offset), parseTelegramButtonCompactActionPayload, { allowTrailing: true, maxCompactAtoms: 4 });
-        if (parsed)
-            return parsed.rows;
-        const end = findTelegramStructuredPayloadEnd(content, offset);
-        if (end === undefined)
-            continue;
-        attributeEnvelope = `${attributeEnvelope.slice(0, offset)}${" ".repeat(end - offset)}${attributeEnvelope.slice(end)}`;
-        offset = end - 1;
-    }
-    const attributes = parseTolerantTelegramAttributes(attributeEnvelope, [
-        "label",
-        "prompt",
-        "value",
-        "selected_style",
-        "disabled",
-    ]);
+    if ("payload" in scanned)
+        return scanned.payload;
+    const attributes = parseTolerantTelegramAttributes(scanned.attributeEnvelope, ["label", "prompt", "value", "selected_style", "disabled"]);
     if (!attributes)
         return undefined;
-    return [[{
+    return [
+        [
+            {
                 ...attributes,
                 ...(attributes.disabled === "true" || attributes.disabled === "false"
                     ? { disabled: attributes.disabled === "true" }
                     : {}),
-            }]];
+            },
+        ],
+    ];
 }
-export function normalizeMarkdownAfterVoiceExtraction(markdown) {
+function normalizeMarkdownAfterVoiceExtraction(markdown) {
     return markdown.replace(/\n{3,}/g, "\n\n").trim();
 }
 function isTelegramCommentOnlyLinePrefix(value) {
@@ -608,9 +596,6 @@ export function stripTelegramCommentMarkupForDelivery(markdown) {
         : withoutClosedBlocks;
     return normalizeMarkdownAfterVoiceExtraction(deliveryMarkdown);
 }
-export function stripTelegramVoiceMarkupForPreview(markdown) {
-    return stripTelegramCommentMarkupForPreview(markdown);
-}
 export function getTelegramActionString(payload, key) {
     const value = payload[key];
     if (typeof value !== "string")
@@ -624,7 +609,9 @@ export function planTelegramVoiceReply(markdown) {
     let rate;
     const stripped = replaceTopLevelHtmlComments(markdown, (comment) => {
         const command = "telegram_voice";
-        const normalizedContent = comment.content.replace(/^\s+/, "").replace(/^!/, "");
+        const normalizedContent = comment.content
+            .replace(/^\s+/, "")
+            .replace(/^!/, "");
         if (!normalizedContent.startsWith(command))
             return comment.raw;
         const payload = parseTelegramActionPayload(comment, command);

package/dist/lib/outbound-voice.js

@@ -8,8 +8,8 @@ import { basename, extname } from "node:path";
 import { assertTelegramInlineKeyboardCallbackData } from "./keyboard.js";
 import { withTelegramReplyParameters } from "./replies.js";
 import { getTelegramTargetThreadParams, } from "./target.js";
-import { getTelegramVoiceSynthesisProviders } from "./voice.js";
 import { isTelegramApiCommitUnknownError } from "./telegram-api.js";
+import { getTelegramVoiceSynthesisProviders } from "./voice.js";
 async function ensureTelegramVoiceFileFormat(filePath) {
     const ext = extname(filePath).toLowerCase();
     if (ext === ".opus" || ext === ".ogg")
@@ -38,11 +38,14 @@ export function createTelegramVoiceReplySender(deps, ports = {}) {
             return;
         await withTelegramReplyParameters(turn.chatId, options?.replyToPrompt === false ? undefined : turn.replyToMessageId, turn.target, (replyParameters) => deps.sendMultipart("sendVoice", {
             chat_id: String(turn.chatId),
-            ...(replyParameters ? { reply_parameters: JSON.stringify(replyParameters) } : {}),
+            ...(replyParameters
+                ? { reply_parameters: JSON.stringify(replyParameters) }
+                : {}),
             ...(turn.target
                 ? Object.fromEntries(Object.entries(getTelegramTargetThreadParams(turn.target)).map(([key, value]) => [key, String(value)]))
                 : {}),
-            ...(options?.replyMarkup !== undefined && options.replyMarkup !== null
+            ...(options?.replyMarkup !== undefined &&
+                options.replyMarkup !== null
                 ? {
                     reply_markup: typeof options.replyMarkup === "string"
                         ? options.replyMarkup

package/dist/lib/outbound.d.ts

@@ -4,12 +4,12 @@
  * Owns configured outbound handler execution, text transforms, public assistant-output reply composition and mutation fencing, voice-file generation/delivery, runtime-event bridge, and compatibility re-exports; assistant markup parsing lives in outbound-markup and button callback actions live in outbound-buttons
  */
 import type { TelegramAssistantSegmentEvent } from "./activity.ts";
-import * as Replies from "./replies.ts";
-import type { TelegramPreparedPreviewDelivery } from "./preview.ts";
-import type { TelegramEditMessageTextBody, TelegramSendMessageBody, TelegramSendRichMessageBody, TelegramSentMessage } from "./telegram-api.ts";
 import { type TelegramButtonActionStore, type TelegramOutboundButtonBinding, type TelegramOutboundButtonMarkup } from "./outbound-buttons.ts";
 import { type TelegramVoiceReplyItem } from "./outbound-markup.ts";
+import type { TelegramPreparedPreviewDelivery } from "./preview.ts";
+import * as Replies from "./replies.ts";
 import type { TelegramTarget } from "./target.ts";
+import type { TelegramEditMessageTextBody, TelegramSendMessageBody, TelegramSendRichMessageBody, TelegramSentMessage } from "./telegram-api.ts";
 import { type CommandTemplateObjectConfig } from "./command-templates.ts";
 /**
  * Record a runtime event that appears in `/telegram-status`.
@@ -27,13 +27,13 @@ export interface TelegramOutboundHandlerConfig extends CommandTemplateObjectConf
     output?: string;
     timeout?: number | string;
 }
-export { normalizeMarkdownAfterVoiceExtraction, planTelegramVoiceReply, stripTelegramCommentMarkupForDelivery, stripTelegramCommentMarkupForPreview, stripTelegramVoiceMarkupForPreview, type TelegramVoiceReplyItem, type TelegramVoiceReplyPlan, } from "./outbound-markup.ts";
 export interface TelegramVoiceExecOptions {
     cwd?: string;
     timeout?: number;
     signal?: AbortSignal;
     stdin?: string;
     retry?: number;
+    recover?: () => Promise<void>;
 }
 export interface TelegramVoiceExecResult {
     stdout: string;
@@ -74,11 +74,11 @@ export interface TelegramOutboundTextReplyRuntimeDeps<TReplyMarkup = unknown> {
     sendTextReply: (chatId: number, replyToMessageId: number | undefined, text: string, options?: {
         parseMode?: "HTML";
         target?: TelegramTarget;
-    }) => Promise<number | undefined>;
+    } & Pick<Replies.TelegramReplyTargetOptions, "assertAuthority">) => Promise<number | undefined>;
     sendMarkdownReply: (chatId: number, replyToMessageId: number | undefined, markdown: string, options?: {
         replyMarkup?: TReplyMarkup;
         target?: TelegramTarget;
-    }) => Promise<number | undefined>;
+    } & Pick<Replies.TelegramReplyTargetOptions, "assertAuthority">) => Promise<number | undefined>;
     cwd?: string;
     recordRuntimeEvent?: TelegramVoiceReplySenderDeps["recordRuntimeEvent"];
 }