@llblab/pi-kit 0.4.0 → 0.5.1

package/node_modules/@llblab/pi-telegram/lib/locks.ts

@@ -871,6 +871,7 @@ export function createTelegramLockRuntime<TContext extends TelegramLockContext>(
     options.runtimeGeneration ?? allocateTelegramLockRuntimeGeneration();
   let ownedLockKey: string | undefined;
   let ownedLock: TelegramLockEntry | undefined;
+  let deliveryRevoked = false;
   const stateOptions = () => ({
     nowMs: getNowMs(),
     staleHeartbeatMs: options.staleHeartbeatMs,
@@ -917,7 +918,8 @@ export function createTelegramLockRuntime<TContext extends TelegramLockContext>(
         );
         if (
           state.kind === "active-here" &&
-          hasSameLockOwner(current, expectedOwned)
+          hasSameLockOwner(current, expectedOwned) &&
+          !deliveryRevoked
         ) {
           return {
             result: {
@@ -958,6 +960,7 @@ export function createTelegramLockRuntime<TContext extends TelegramLockContext>(
         if (
           !acquireOptions.election &&
           (state.kind === "active-here" || state.kind === "active-elsewhere") &&
+          !(deliveryRevoked && hasSameLockOwner(current, expectedOwned)) &&
           (!acquireOptions.force ||
             !expectedReplacementMatches ||
             !canReplaceCurrent)
@@ -978,6 +981,7 @@ export function createTelegramLockRuntime<TContext extends TelegramLockContext>(
         locks[effectiveKey] = lock;
         ownedLockKey = effectiveKey;
         ownedLock = lock;
+        deliveryRevoked = false;
         return {
           result: {
             ok: true,
@@ -987,8 +991,10 @@ export function createTelegramLockRuntime<TContext extends TelegramLockContext>(
           changed: true,
         };
       }),
-    release: () =>
-      withLockTransaction(locksPath, (locks) => {
+    release: () => {
+      // Withdraw local send authority even if the durable release fails.
+      deliveryRevoked = true;
+      return withLockTransaction(locksPath, (locks) => {
         const effectiveKey = resolveEffectiveKey();
         const state = getLockState(
           parseTelegramLockEntry(locks[effectiveKey]),
@@ -1008,17 +1014,20 @@ export function createTelegramLockRuntime<TContext extends TelegramLockContext>(
           ownedLock = undefined;
         }
         return { result: state, changed };
-      }),
+      });
+    },
     getState: () => getLockState(readLock(), pid, isAlive, stateOptions()),
     getStatusLabel: () =>
       formatLockState(getLockState(readLock(), pid, isAlive, stateOptions())),
     getOwnedLeaderEpoch: () => {
+      if (deliveryRevoked) return undefined;
       const effectiveKey = resolveEffectiveKey();
       const lock = parseTelegramLockEntry(readLocks(locksPath)[effectiveKey]);
       const exactOwner = adoptCompatibleOwnedLock(effectiveKey, lock);
       return hasSameLockOwner(lock, exactOwner) ? lock?.leaderEpoch : undefined;
     },
     owns: (ctx) => {
+      if (deliveryRevoked) return false;
       const effectiveKey = resolveEffectiveKey();
       const lock = parseTelegramLockEntry(readLocks(locksPath)[effectiveKey]);
       return hasSameLockOwner(
@@ -1027,7 +1036,7 @@ export function createTelegramLockRuntime<TContext extends TelegramLockContext>(
       );
     },
     commitIfOwned: (commit) =>
-      withLockTransaction(locksPath, (locks) => {
+      !deliveryRevoked && withLockTransaction(locksPath, (locks) => {
         const effectiveKey = resolveEffectiveKey();
         const lock = parseTelegramLockEntry(locks[effectiveKey]);
         const exactOwner =
@@ -1043,7 +1052,7 @@ export function createTelegramLockRuntime<TContext extends TelegramLockContext>(
         return { result: true, changed: false };
       }),
     refresh: (ctx) =>
-      withLockTransaction(locksPath, (locks) => {
+      !deliveryRevoked && withLockTransaction(locksPath, (locks) => {
         const effectiveKey = resolveEffectiveKey();
         const lock = parseTelegramLockEntry(locks[effectiveKey]);
         const expectedOwner = adoptCompatibleOwnedLock(effectiveKey, lock, ctx);
@@ -1116,6 +1125,7 @@ export interface TelegramLockedPollingRuntime<
   ) => Promise<TelegramLockedPollingStartResult>;
   stop: () => Promise<string>;
   suspend: () => Promise<void>;
+  onPersistentConflict: (ctx: TContext, count: number) => Promise<void>;
   onSessionStart: (_event: unknown, ctx: TContext) => Promise<void>;
   registerFollowerWithOwner?: (
     ctx: TContext,
@@ -1130,6 +1140,7 @@ export interface TelegramLockedPollingRuntimeDeps<
   lock: TelegramLockRuntime<TContext>;
   hasBotToken: () => boolean;
   canStartPolling?: (ctx: TContext) => boolean;
+  isContextCurrent?: (ctx: TContext) => boolean;
   formatStartBlockedMessage?: (ctx: TContext) => string;
   startPolling: (
     ctx: TContext,
@@ -1142,6 +1153,7 @@ export interface TelegramLockedPollingRuntimeDeps<
   ) => boolean | undefined | Promise<boolean | undefined>;
   stopFollowerRegistration?: () => void;
   onTransportAvailabilityChanged?: () => void;
+  transportMonitor?: { start: (ctx: TContext) => void; stop: () => void };
   updateStatus: (ctx: TContext) => void;
   recordRuntimeEvent?: (
     category: string,
@@ -1164,9 +1176,10 @@ export function createTelegramLockedPollingRuntime<
   let ownershipCheckInterval: ReturnType<typeof setInterval> | undefined;
   let ownershipRefreshInterval: ReturnType<typeof setInterval> | undefined;
   let ownershipStop: Promise<void> | undefined;
+  let activeContext: TContext | undefined;
   let takeoverCandidate: TelegramLockEntry | undefined;
   let sessionAutoStartRun: Promise<void> | undefined;
-  let sessionAutoStartGeneration = 0;
+  let pollingGeneration = 0;
   const ownershipCheckMs =
     deps.ownershipCheckMs ?? TELEGRAM_OWNERSHIP_CHECK_MS;
   const ownershipRefreshMs =
@@ -1178,7 +1191,9 @@ export function createTelegramLockedPollingRuntime<
     ownershipRefreshInterval = undefined;
   };
   const suspendPolling = async () => {
-    sessionAutoStartGeneration += 1;
+    pollingGeneration += 1;
+    activeContext = undefined;
+    deps.transportMonitor?.stop();
     deps.stopFollowerRegistration?.();
     stopOwnershipWatcher();
     if (sessionAutoStartRun) {
@@ -1192,6 +1207,8 @@ export function createTelegramLockedPollingRuntime<
   };
   const stopAfterOwnershipLoss = () => {
     if (ownershipStop) return;
+    activeContext = undefined;
+    deps.transportMonitor?.stop();
     stopOwnershipWatcher();
     deps.onTransportAvailabilityChanged?.();
     ownershipStop = deps
@@ -1228,7 +1245,10 @@ export function createTelegramLockedPollingRuntime<
   const runOwnedPollingStart = async (
     ctx: TContext,
     options: TelegramLockedPollingStartOptions,
+    isCurrent: () => boolean,
   ): Promise<boolean> => {
+    if (!isCurrent()) return false;
+    activeContext = ctx;
     startOwnershipWatcher(ctx);
     try {
       if (!deps.lock.refresh(snapshotLockContext(ctx))) {
@@ -1236,8 +1256,10 @@ export function createTelegramLockedPollingRuntime<
         return false;
       }
       await options.onAcquired?.();
+      if (!isCurrent()) return false;
       await deps.startPolling(ctx, options);
     } catch (error) {
+      if (!isCurrent()) return false;
       stopOwnershipWatcher();
       try {
         await deps.stopPolling();
@@ -1246,14 +1268,22 @@ export function createTelegramLockedPollingRuntime<
           phase: "startup-rollback",
         });
       }
+      if (!isCurrent()) return false;
       deps.lock.release();
       deps.onTransportAvailabilityChanged?.();
       throw error;
     }
-    if (deps.lock.owns(ctx)) return true;
+    if (!isCurrent()) return false;
+    if (deps.lock.owns(ctx)) {
+      if (activeContext !== ctx) return false;
+      deps.transportMonitor?.start(ctx);
+      return true;
+    }
     stopOwnershipWatcher();
     if (ownershipStop) await ownershipStop;
+    if (!isCurrent()) return false;
     await deps.stopPolling();
+    if (!isCurrent()) return false;
     deps.onTransportAvailabilityChanged?.();
     return false;
   };
@@ -1270,6 +1300,17 @@ export function createTelegramLockedPollingRuntime<
       if (!canStartPolling(ctx)) {
         return { ok: false, message: formatStartBlockedMessage(ctx) };
       }
+      const cancelled = {
+        ok: false as const,
+        canTakeover: false as const,
+        message: "Telegram polling startup was cancelled or superseded.",
+      };
+      if (deps.isContextCurrent?.(ctx) === false) return cancelled;
+      const generation = ++pollingGeneration;
+      const isCurrent = () => generation === pollingGeneration &&
+        (deps.isContextCurrent?.(ctx) ?? true);
+      if (ownershipStop) await ownershipStop;
+      if (!isCurrent()) return cancelled;
       let acquired = deps.lock.acquire(ctx, {
         force: options.force,
         expectedOwner:
@@ -1306,6 +1347,7 @@ export function createTelegramLockedPollingRuntime<
               ctx,
               acquired.lock,
             );
+            if (!isCurrent()) return cancelled;
             if (registered) {
               deps.updateStatus(ctx);
               return { ok: true, canTakeover: false };
@@ -1337,13 +1379,15 @@ export function createTelegramLockedPollingRuntime<
         };
       }
       takeoverCandidate = undefined;
-      if (!(await runOwnedPollingStart(ctx, options))) {
+      if (!(await runOwnedPollingStart(ctx, options, isCurrent))) {
+        if (!isCurrent()) return cancelled;
         return {
           ok: false,
           canTakeover: false,
           message: "Telegram leadership changed during polling startup.",
         };
       }
+      if (!isCurrent()) return cancelled;
       deps.onTransportAvailabilityChanged?.();
       deps.updateStatus(ctx);
       const staleSuffix = acquired.replacedStale ? " Replaced stale lock." : "";
@@ -1362,6 +1406,42 @@ export function createTelegramLockedPollingRuntime<
       return "Telegram bridge disconnected.";
     },
     suspend: suspendPolling,
+    onPersistentConflict: async (ctx, count) => {
+      if (activeContext === undefined || ownershipStop) return;
+      if (!(deps.isContextCurrent?.(ctx) ?? activeContext === ctx)) return;
+      activeContext = undefined;
+      pollingGeneration += 1;
+      stopOwnershipWatcher();
+      deps.transportMonitor?.stop();
+      let ownership = "unverifiable";
+      const cleanupErrors: string[] = [];
+      try {
+        ownership = deps.lock.owns(snapshotLockContext(ctx)) ? "owned" : "lost";
+      } catch (error) {
+        cleanupErrors.push(String(error));
+      }
+      try {
+        deps.lock.release();
+      } catch (error) {
+        ownership = "unverifiable";
+        cleanupErrors.push(String(error));
+      }
+      ownershipStop = Promise.resolve()
+        .then(() => deps.stopPolling())
+        .catch((error) => { cleanupErrors.push(String(error)); })
+        .finally(() => {
+          ownershipStop = undefined;
+          deps.recordRuntimeEvent?.("polling", ownership === "lost"
+            ? "Telegram transport stopped: local ownership lost; check for another Pi instance."
+            : "Telegram transport stopped: competing getUpdates client or ownership mismatch.", {
+            phase: "persistent-conflict", count, ownership,
+            ...(cleanupErrors.length ? { cleanupErrors } : {}),
+          });
+          deps.updateStatus(ctx);
+        });
+      deps.onTransportAvailabilityChanged?.();
+      await ownershipStop;
+    },
     onSessionStart: async (_event, ctx) => {
       if (!deps.hasBotToken()) return;
       if (!canStartPolling(ctx)) return;
@@ -1379,15 +1459,18 @@ export function createTelegramLockedPollingRuntime<
       ) {
         return;
       }
-      sessionAutoStartGeneration += 1;
-      const generation = sessionAutoStartGeneration;
+      if (deps.isContextCurrent?.(ctx) === false) return;
+      const generation = ++pollingGeneration;
+      const isCurrent = () => generation === pollingGeneration &&
+        (deps.isContextCurrent?.(ctx) ?? true);
       const startedAtMs = Date.now();
       deps.recordRuntimeEvent?.("lock", "Telegram auto-start scheduled", {
         phase: "auto-start-scheduled",
       });
       const run = (async () => {
         await new Promise((resolve) => setTimeout(resolve, 0));
-        if (generation !== sessionAutoStartGeneration) return;
+        if (ownershipStop) await ownershipStop;
+        if (!isCurrent()) return;
         if (canResumeStaleSameCwd || canHandoffSameProcess) {
           const acquired = deps.lock.acquire(
             ctx,
@@ -1397,9 +1480,9 @@ export function createTelegramLockedPollingRuntime<
           );
           if (!acquired.ok) return;
         }
-        if (generation !== sessionAutoStartGeneration) return;
-        if (!(await runOwnedPollingStart(ctx, {}))) return;
-        if (generation !== sessionAutoStartGeneration) return;
+        if (!isCurrent()) return;
+        if (!(await runOwnedPollingStart(ctx, {}, isCurrent))) return;
+        if (!isCurrent()) return;
         deps.onTransportAvailabilityChanged?.();
         deps.updateStatus(ctx);
         deps.recordRuntimeEvent?.("lock", "Telegram auto-start completed", {

package/node_modules/@llblab/pi-telegram/lib/outbound-buttons.ts

@@ -12,6 +12,8 @@ import type {
 } from "./keyboard.ts";
 import {
   parseTelegramActionPayloadRows,
+  parseTelegramButtonPayloadRows,
+  replaceTelegramButtonFences,
   replaceTopLevelHtmlComments,
 } from "./outbound-markup.ts";
 import {
@@ -34,6 +36,7 @@ export interface TelegramOutboundButtonAction {
   prompt: string;
   binding?: TelegramOutboundButtonBinding;
   selectedStyle?: TelegramInlineKeyboardButtonStyle;
+  disabled?: true;
 }
 
 export interface TelegramOutboundButtonStoredAction extends TelegramOutboundButtonAction {
@@ -115,6 +118,12 @@ function parseTelegramButtonAction(
   const explicitLabel = getTelegramButtonString(payload, "label");
   const explicitPrompt = getTelegramButtonString(payload, "prompt");
   const label = explicitLabel ?? value ?? explicitPrompt;
+  if (payload.disabled !== undefined && typeof payload.disabled !== "boolean") {
+    return undefined;
+  }
+  if (payload.disabled === true) {
+    return { text: label ?? "", prompt: "", disabled: true };
+  }
   const prompt = explicitPrompt ?? value ?? explicitLabel;
   if (!label || !prompt) return undefined;
   const selectedStyle = payload.selected_style;
@@ -159,6 +168,7 @@ export function createTelegramButtonActionStore(
       return {
         text: action.text,
         prompt: action.prompt,
+        ...(action.disabled ? { disabled: true as const } : {}),
         ...(action.binding ? { binding: action.binding } : {}),
         ...(action.selectedStyle
           ? { selectedStyle: action.selectedStyle }
@@ -171,33 +181,75 @@ export function createTelegramButtonActionStore(
 const DEFAULT_TELEGRAM_BUTTON_REPLY_MARKDOWN =
   "☑️ **Choose an option:**";
 
+function escapeTelegramRichButtonText(text: string): string {
+  return text.replace(/[&<>"'`\\*_\[\]{}$~\r\n]/g, (character) =>
+    `&#${character.charCodeAt(0)};`,
+  );
+}
+
+function renderTelegramRichButtonRow(
+  row: TelegramOutboundButtonMarkup["inline_keyboard"][number],
+): string {
+  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>`;
+}
+
 export function planTelegramButtonReply(
   markdown: string,
   deps: {
     registerAction: (action: TelegramOutboundButtonAction) => string;
     binding?: TelegramOutboundButtonBinding;
+    rendering?: "rich" | "html";
   },
 ): TelegramButtonReplyPlan {
   const keyboard: TelegramOutboundButtonMarkup["inline_keyboard"] = [];
-  const stripped = replaceTopLevelHtmlComments(markdown, (comment) => {
+  const buildRows = (
+    payloadRows: Record<string, unknown>[][],
+    rich: boolean,
+  ): TelegramOutboundButtonMarkup["inline_keyboard"] | undefined => {
+    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;
+    })) return undefined;
+    return actions.map((row) => row.map((action) => action!.disabled
+      ? { text: action!.text || "\u00a0", disabled: {} }
+      : {
+          text: action!.text,
+          callback_data: deps.registerAction({
+            ...action!,
+            ...(deps.binding ? { binding: deps.binding } : {}),
+          }),
+        }));
+  };
+  const withRichButtons = replaceTelegramButtonFences(markdown, (payload, closed) => {
+    if (!closed) return "";
+    const payloadRows = parseTelegramButtonPayloadRows(payload);
+    if (!payloadRows) return "";
+    const rich = deps.rendering !== "html";
+    const rows = buildRows(payloadRows, rich);
+    if (!rows) return "";
+    if (!rich) {
+      keyboard.push(...rows);
+      return "";
+    }
+    return `\n${rows.map(renderTelegramRichButtonRow).join("\n\n")}\n`;
+  });
+  const stripped = replaceTopLevelHtmlComments(withRichButtons, (comment) => {
     const command = "telegram_button";
     const normalizedContent = comment.content.replace(/^\s+/, "").replace(/^!/, "");
     if (!normalizedContent.startsWith(command)) return comment.raw;
     const payloadRows = parseTelegramActionPayloadRows(comment, command);
     if (!payloadRows) return "";
-    const actionRows = payloadRows.map((payloadRow) =>
-      payloadRow.map(parseTelegramButtonAction),
-    );
-    if (actionRows.some((row) => row.some((action) => !action))) return "";
-    for (const actionRow of actionRows) {
-      keyboard.push(actionRow.map((action) => ({
-        text: action!.text,
-        callback_data: deps.registerAction({
-          ...action!,
-          ...(deps.binding ? { binding: deps.binding } : {}),
-        }),
-      })));
-    }
+    const rows = buildRows(payloadRows, false);
+    if (rows) keyboard.push(...rows);
     return "";
   });
   const visibleMarkdown = normalizeMarkdownAfterButtonExtraction(stripped);
@@ -254,7 +306,7 @@ export function markTelegramButtonSelected(
   let matched = false;
   const inlineKeyboard = replyMarkup.inline_keyboard.map((row) =>
     row.map((button) => {
-      if (button.callback_data !== callbackData) return { ...button };
+      if (button.disabled || button.callback_data !== callbackData) return { ...button };
       matched = true;
       return { ...button, style: selectedStyle };
     }),
@@ -277,6 +329,11 @@ export async function handleTelegramButtonCallbackQuery<TContext = unknown>(
     return false;
   }
 
+  if (action.disabled) {
+    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") {

package/node_modules/@llblab/pi-telegram/lib/outbound-markup.ts

@@ -90,6 +90,50 @@ export function collectTopLevelHtmlComments(markdown: string): {
   return { comments };
 }
 
+export function replaceTelegramButtonFences(
+  markdown: string,
+  replace: (payload: string, closed: boolean) => string,
+): string {
+  let result = "";
+  let copied = 0;
+  let offset = 0;
+  let fence: TelegramTopLevelFenceState | undefined;
+  let actionStart: number | undefined;
+  let contentStart = 0;
+  while (offset < markdown.length) {
+    const end = getMarkdownLineEnd(markdown, offset);
+    const line = getMarkdownLineText(markdown, offset, end);
+    if (fence) {
+      if (isTopLevelClosingFence(line, fence)) {
+        if (actionStart !== undefined) {
+          result += markdown.slice(copied, actionStart);
+          result += replace(markdown.slice(contentStart, offset), true) + "\n";
+          copied = end;
+          actionStart = undefined;
+        }
+        fence = undefined;
+      }
+    } else if (line.includes("<!--")) {
+      const close = markdown.indexOf("-->", offset + line.indexOf("<!--") + 4);
+      if (close < 0) break;
+      offset = getMarkdownLineEnd(markdown, close + 3);
+      continue;
+    } else {
+      fence = getTopLevelOpeningFence(line);
+      if (fence && /^```telegram_button[ \t]*$/.test(line)) {
+        actionStart = offset;
+        contentStart = end;
+      }
+    }
+    offset = end;
+  }
+  if (actionStart !== undefined) {
+    result += markdown.slice(copied, actionStart);
+    return result + replace(markdown.slice(contentStart), false);
+  }
+  return result + markdown.slice(copied);
+}
+
 export function replaceTopLevelHtmlComments(
   markdown: string,
   replacer: (comment: TelegramTopLevelHtmlComment) => string,
@@ -275,17 +319,26 @@ type TelegramCompactActionPayloadParser = (
 function parseTelegramButtonCompactActionPayload(
   atoms: readonly string[],
 ): Record<string, unknown> | undefined {
-  const [label, prompt, selectedStyle] = atoms;
+  const [label, prompt, selectedStyle, disabled] = atoms;
   if (atoms.length === 1) return label ? { value: label } : undefined;
-  if (!prompt) return undefined;
+  const isDisabled = disabled === "1" || disabled === "true";
+  if (!prompt && !(atoms.length === 4 && isDisabled)) return undefined;
   const action = label ? { label, prompt } : { prompt };
   if (atoms.length === 2) return action;
   if (
     selectedStyle !== "primary" &&
     selectedStyle !== "success" &&
-    selectedStyle !== "danger"
+    selectedStyle !== "danger" &&
+    !(atoms.length === 4 && selectedStyle === "")
   ) return undefined;
-  return { ...action, selected_style: selectedStyle };
+  if (atoms.length === 4 && !isDisabled && disabled !== "0" && disabled !== "false") {
+    return undefined;
+  }
+  return {
+    ...action,
+    ...(selectedStyle ? { selected_style: selectedStyle } : {}),
+    ...(atoms.length === 4 ? { disabled: isDisabled } : {}),
+  };
 }
 
 function parseTelegramVoiceCompactActionPayload(
@@ -303,7 +356,7 @@ function parseTelegramVoiceCompactActionPayload(
 function parseTelegramAdaptiveActionPayloadRows(
   source: string,
   parseCompactPayload: TelegramCompactActionPayloadParser,
-  options: { allowTrailing?: boolean } = {},
+  options: { allowTrailing?: boolean; maxCompactAtoms?: number } = {},
 ): { rows: Record<string, unknown>[][]; end: number } | undefined {
   let offset = 0;
   const isStructuralWhitespace = (character: string | undefined): boolean =>
@@ -343,7 +396,7 @@ function parseTelegramAdaptiveActionPayloadRows(
         continue;
       }
       if (character === "|") {
-        if (atomSources.length >= 3) return undefined;
+        if (atomSources.length >= (options.maxCompactAtoms ?? 3)) return undefined;
         atomSources.push([]);
         offset += 1;
         continue;
@@ -509,6 +562,16 @@ function isPlausibleTelegramMatrixStart(
   );
 }
 
+export function parseTelegramButtonPayloadRows(
+  source: string,
+): Record<string, unknown>[][] | undefined {
+  return parseTelegramAdaptiveActionPayloadRows(
+    source.trim(),
+    parseTelegramButtonCompactActionPayload,
+    { maxCompactAtoms: 4 },
+  )?.rows;
+}
+
 export function parseTelegramActionPayloadRows(
   comment: TelegramTopLevelHtmlComment,
   command: string,
@@ -533,7 +596,7 @@ export function parseTelegramActionPayloadRows(
     const parsed = parseTelegramAdaptiveActionPayloadRows(
       content.slice(offset),
       parseTelegramButtonCompactActionPayload,
-      { allowTrailing: true },
+      { allowTrailing: true, maxCompactAtoms: 4 },
     );
     if (parsed) return parsed.rows;
     const end = findTelegramStructuredPayloadEnd(content, offset);
@@ -546,8 +609,15 @@ export function parseTelegramActionPayloadRows(
     "prompt",
     "value",
     "selected_style",
+    "disabled",
   ]);
-  return attributes ? [[attributes]] : undefined;
+  if (!attributes) return undefined;
+  return [[{
+    ...attributes,
+    ...(attributes.disabled === "true" || attributes.disabled === "false"
+      ? { disabled: attributes.disabled === "true" }
+      : {}),
+  }]];
 }
 
 export function normalizeMarkdownAfterVoiceExtraction(
@@ -589,7 +659,9 @@ function stripTelegramHtmlCommentBlocks(markdown: string): string {
 }
 
 export function stripTelegramCommentMarkupForPreview(markdown: string): string {
-  const withoutClosedBlocks = stripTelegramHtmlCommentBlocks(markdown);
+  const withoutClosedBlocks = stripTelegramHtmlCommentBlocks(
+    replaceTelegramButtonFences(markdown, () => ""),
+  );
   const openBlockIndex =
     findTopLevelOpenOrPartialHtmlCommentIndex(withoutClosedBlocks);
   const previewMarkdown =

package/node_modules/@llblab/pi-telegram/lib/outbound.ts

@@ -835,6 +835,7 @@ export {
 
 export function createTelegramOutboundReplyPlanner(
   store: Pick<TelegramButtonActionStore, "register">,
+  getRenderingMode: () => "rich" | "html" = () => "rich",
 ): (
   markdown: string,
   options?: { binding?: TelegramOutboundButtonBinding },
@@ -842,6 +843,7 @@ export function createTelegramOutboundReplyPlanner(
   return (markdown, options) => {
     const buttonReply = planTelegramButtonReply(markdown, {
       registerAction: store.register,
+      rendering: getRenderingMode(),
       ...(options?.binding ? { binding: options.binding } : {}),
     });