pi-telegram-plus 0.0.1

package/lib/menu-commands.ts

@@ -0,0 +1,72 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { setTelegramMyCommands } from "./telegram-api.ts";
+
+const TELEGRAM_MENU_COMMANDS: Array<{ command: string; description: string }> = [
+  // Keep the built-in pi commands in the same order as the TUI slash menu.
+  { command: "login", description: "Configure provider authentication" },
+  { command: "logout", description: "Remove stored credentials" },
+  { command: "model", description: "Show or change the current model" },
+  { command: "scoped-models", description: "Enable/disable models for cycling" },
+  { command: "settings", description: "Open settings menu" },
+  { command: "resume", description: "Resume a previous session" },
+  { command: "new", description: "Start a new session" },
+  { command: "name", description: "Set or show session name" },
+  { command: "session", description: "Show session statistics" },
+  { command: "tree", description: "Navigate session tree" },
+  { command: "fork", description: "Fork from a previous message" },
+  { command: "clone", description: "Clone at a previous message" },
+  { command: "compact", description: "Compact session context" },
+  { command: "copy", description: "Copy last assistant message" },
+  { command: "export", description: "Export session" },
+  { command: "share", description: "Share session as gist" },
+  { command: "reload", description: "Reload pi resources" },
+  { command: "hotkeys", description: "Show keyboard shortcuts" },
+  { command: "changelog", description: "Show changelog" },
+  { command: "quit", description: "Shut down pi" },
+
+  // Additional pi-telegram-plus commands.
+  { command: "cwd", description: "Show current working directory" },
+  { command: "cd", description: "Switch pi working directory" },
+  { command: "import", description: "Import a session" },
+  { command: "thinking", description: "Show or change thinking level" },
+  { command: "stop", description: "Stop the current agent turn" },
+  { command: "debug", description: "Show debug information" },
+  // tg-* commands visible in the Telegram bot menu.
+  // tg-bind-cwd / tg-unbind-cwd are workspace-management commands that
+  // require local cwd context and do not belong in the bot command list.
+  { command: "tg-setup", description: "Configure Telegram bot token" },
+  { command: "tg-connect", description: "Enable/start Telegram connection" },
+  { command: "tg-disconnect", description: "Disable/stop Telegram connection" },
+  { command: "tg-config", description: "Configure Telegram message rendering" },
+  { command: "tg-list", description: "List Telegram bot bindings" },
+];
+
+const toTelegramCommandName = (name: string): string | undefined => {
+  // Telegram bot menu commands allow only [A-Za-z0-9_] and max 32 chars.
+  const telegramName = name.replace(/-/g, "_").toLowerCase();
+  if (!/^[a-z0-9_]{1,32}$/.test(telegramName)) return undefined;
+  return telegramName;
+};
+
+export function buildTelegramMenuCommands(pi: ExtensionAPI): Array<{ command: string; description: string }> {
+  const commands = new Map<string, string>();
+  const addCommand = (name: string, description?: string) => {
+    const telegramName = toTelegramCommandName(name);
+    if (!telegramName || commands.has(telegramName)) return;
+    commands.set(telegramName, (description?.trim() || `Run /${telegramName}`).slice(0, 256));
+  };
+
+  for (const command of TELEGRAM_MENU_COMMANDS) addCommand(command.command, command.description);
+  for (const command of pi.getCommands()) addCommand(command.name, command.description);
+
+  // Telegram accepts at most 100 bot commands. Keep the curated built-in-style
+  // commands first, then fill the rest with extension/prompt/skill commands.
+  return Array.from(commands, ([command, description]) => ({ command, description })).slice(0, 100);
+}
+
+export async function syncTelegramCommands(botToken: string | undefined, pi: ExtensionAPI): Promise<void> {
+  if (!botToken) return;
+  try {
+    await setTelegramMyCommands(botToken, buildTelegramMenuCommands(pi));
+  } catch { /* non-critical */ }
+}

package/lib/polling.ts

@@ -0,0 +1,255 @@
+import { createHash, randomUUID } from "node:crypto";
+import { mkdir, readFile, rm, stat, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { getAgentDir } from "./config.ts";
+import { getTelegramUpdates } from "./telegram-api.ts";
+import type { TelegramConfig, TelegramUpdate } from "./types.ts";
+
+export type TelegramPollingRuntime = {
+  start(): void;
+  stop(): Promise<void>;
+  isActive(): boolean;
+};
+
+const MIN_BACKOFF_MS = 1_000;
+const MAX_BACKOFF_MS = 30_000;
+const POLL_LOCK_STALE_MS = 45_000;
+const POLL_LOCK_TOUCH_MS = 5_000;
+
+type PollingLockOwner = {
+  id: string;
+  pid: number;
+  at: string;
+  touchedAt: string;
+};
+
+const sleep = (ms: number, signal: AbortSignal) =>
+  new Promise<void>((resolve) => {
+    const timer = setTimeout(resolve, ms);
+    signal.addEventListener("abort", () => {
+      clearTimeout(timer);
+      resolve();
+    }, { once: true });
+  });
+
+function tokenLockPath(token: string): string {
+  const hash = createHash("sha256").update(token).digest("hex").slice(0, 24);
+  return join(getAgentDir(), `tg-poll-${hash}.lock`);
+}
+
+function isPidAlive(pid: unknown): boolean {
+  if (typeof pid !== "number" || !Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function ownerText(owner: PollingLockOwner): string {
+  return JSON.stringify(owner, null, 2) + "\n";
+}
+
+async function readPollingLockOwner(ownerPath: string): Promise<PollingLockOwner | undefined> {
+  try {
+    const owner = JSON.parse(await readFile(ownerPath, "utf8")) as Partial<PollingLockOwner>;
+    if (typeof owner.id !== "string" || typeof owner.pid !== "number") return undefined;
+    return {
+      id: owner.id,
+      pid: owner.pid,
+      at: typeof owner.at === "string" ? owner.at : "",
+      touchedAt: typeof owner.touchedAt === "string" ? owner.touchedAt : "",
+    };
+  } catch {
+    return undefined;
+  }
+}
+
+async function isPollingLockStale(lockPath: string): Promise<boolean> {
+  const ownerPath = join(lockPath, "owner.json");
+  const owner = await readPollingLockOwner(ownerPath);
+  const age = Date.now() - (await stat(ownerPath).then((s) => s.mtimeMs).catch(() => 0));
+  if (age > POLL_LOCK_STALE_MS) return true;
+  return owner !== undefined && !isPidAlive(owner.pid);
+}
+
+/**
+ * Atomically claim the polling lock. Uses a temporary candidate file written
+ * with `wx` (exclusive create) inside the agent dir, then renames it into the
+ * lock directory. No check-then-rm-then-mkdir TOCTOU window exists: only one
+ * process can successfully rename its candidate into the lock's owner.json.
+ */
+async function acquirePollingLock(token: string): Promise<{ owns: () => Promise<boolean>; release: () => Promise<void> } | undefined> {
+  await mkdir(getAgentDir(), { recursive: true });
+  const lockPath = tokenLockPath(token);
+  const ownerPath = join(lockPath, "owner.json");
+  const owner: PollingLockOwner = {
+    id: randomUUID(),
+    pid: process.pid,
+    at: new Date().toISOString(),
+    touchedAt: new Date().toISOString(),
+  };
+
+  // Clean up stale lock if it exists.
+  if (!await isPollingLockStale(lockPath)) return undefined;
+  await rm(lockPath, { recursive: true, force: true }).catch(() => undefined);
+
+  // Create lock directory; if another process won, bail out.
+  try {
+    await mkdir(lockPath, { mode: 0o700 });
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code !== "EEXIST") throw error;
+    // Someone else created it after our stale check — their lock is fresh now.
+    return undefined;
+  }
+
+  // Write a temp candidate with exclusive flag, then rename atomically.
+  const tmpPath = join(getAgentDir(), `tg-poll-candidate-${owner.id}.tmp`);
+  try {
+    await writeFile(tmpPath, ownerText(owner), { mode: 0o600, flag: "wx" });
+  } catch (error) {
+    // Another process's candidate won; clean up and bail.
+    await rm(tmpPath).catch(() => undefined);
+    if ((error as NodeJS.ErrnoException).code === "EEXIST") return undefined;
+    throw error;
+  }
+
+  try {
+    const { rename: nodeRename } = await import("node:fs/promises");
+    await nodeRename(tmpPath, ownerPath);
+  } catch {
+    // rename failed (e.g. cross-device or another process already wrote owner.json).
+    await rm(tmpPath).catch(() => undefined);
+    return undefined;
+  }
+
+  const touch = setInterval(() => {
+    void (async () => {
+      const current = await readPollingLockOwner(ownerPath);
+      if (current?.id !== owner.id) return;
+      owner.touchedAt = new Date().toISOString();
+      await writeFile(ownerPath, ownerText(owner), { mode: 0o600 }).catch(() => undefined);
+    })();
+  }, POLL_LOCK_TOUCH_MS);
+
+  return {
+    owns: async () => (await readPollingLockOwner(ownerPath))?.id === owner.id,
+    release: async () => {
+      clearInterval(touch);
+      const current = await readPollingLockOwner(ownerPath);
+      if (current?.id === owner.id) await rm(lockPath, { recursive: true, force: true }).catch(() => undefined);
+    },
+  };
+}
+
+
+export function createTelegramPollingRuntime(deps: {
+  getConfig: () => TelegramConfig;
+  setConfig: (config: TelegramConfig) => void;
+  persistConfig: (config: TelegramConfig) => Promise<void>;
+  handleUpdate: (update: TelegramUpdate) => Promise<void>;
+  reloadConfig?: () => Promise<void>;
+  onError: (error: unknown) => void;
+  onSuccess?: () => void;
+}): TelegramPollingRuntime {
+  let abort: AbortController | undefined;
+  let pollLock: { token: string; owns: () => Promise<boolean>; release: () => Promise<void> } | undefined;
+
+  const releasePollLock = async () => {
+    const lock = pollLock;
+    pollLock = undefined;
+    await lock?.release().catch(() => undefined);
+  };
+
+  const ensurePollLock = async (token: string): Promise<boolean> => {
+    if (pollLock?.token === token) {
+      if (await pollLock.owns()) return true;
+      await releasePollLock();
+    } else {
+      await releasePollLock();
+    }
+    const lock = await acquirePollingLock(token);
+    if (!lock) return false;
+    pollLock = { token, owns: lock.owns, release: lock.release };
+    return true;
+  };
+
+  const loop = async (signal: AbortSignal) => {
+    let backoffMs = MIN_BACKOFF_MS;
+
+    while (!signal.aborted) {
+      const token = deps.getConfig().botToken;
+      if (!token) {
+        await releasePollLock();
+        await sleep(MIN_BACKOFF_MS, signal);
+        continue;
+      }
+      if (!(await ensurePollLock(token))) {
+        deps.onError(new Error("Telegram polling skipped: another local pi instance is already polling this bot token."));
+        await sleep(MAX_BACKOFF_MS, signal);
+        continue;
+      }
+
+      try {
+        // Refresh config after owning the poll lock. A process that waited for
+        // the lock may have stale in-memory lastUpdateId; re-reading prevents it
+        // from polling an already-persisted update after another process/reload.
+        await deps.reloadConfig?.();
+        if (signal.aborted) return;
+        const refreshedToken = deps.getConfig().botToken;
+        if (!refreshedToken) continue;
+        if (refreshedToken !== token) continue;
+
+        const updates = await getTelegramUpdates(deps.getConfig(), signal);
+        backoffMs = MIN_BACKOFF_MS;
+        deps.onSuccess?.();
+
+        for (const update of updates) {
+          if (signal.aborted) return;
+          try {
+            await deps.handleUpdate(update);
+          } catch (error) {
+            deps.onError(error);
+            // Do not advance offset on failure; retry on next poll loop.
+            continue;
+          }
+          const nextConfig = { ...deps.getConfig(), lastUpdateId: update.update_id };
+          try {
+            await deps.persistConfig(nextConfig);
+            deps.setConfig(nextConfig);
+          } catch (error) {
+            deps.onError(error);
+            continue;
+          }
+        }
+      } catch (error) {
+        if (signal.aborted) return;
+        deps.onError(error);
+        await sleep(backoffMs, signal);
+        backoffMs = Math.min(backoffMs * 2, MAX_BACKOFF_MS);
+      }
+    }
+    await releasePollLock();
+  };
+
+  return {
+    start() {
+      if (abort) return;
+      abort = new AbortController();
+      void loop(abort.signal).catch((error) => {
+        abort = undefined;
+        void releasePollLock();
+        deps.onError(error);
+      });
+    },
+    async stop() {
+      abort?.abort();
+      abort = undefined;
+      await releasePollLock();
+    },
+    isActive() {
+      return !!abort;
+    },
+  };
+}

package/lib/renderer.ts

@@ -0,0 +1,284 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { escapeHtml } from "./html.ts";
+import { markdownToTelegramHtml } from "./markdown.ts";
+import type { TelegramConfig, TelegramRenderLevel, TelegramTransport, TelegramTurn } from "./types.ts";
+import { RENDER_LEVELS } from "./types.ts";
+
+type AnyMessage = {
+  role?: string;
+  content?: unknown;
+  errorMessage?: string;
+  usage?: { cost?: { total?: number }; totalTokens?: number };
+  model?: string;
+  provider?: string;
+};
+
+const TOOL_UPDATE_MS = 5000;
+const EDIT_LIMIT = 3500;
+
+function formatThinkingInline(part: Record<string, any>, level: TelegramRenderLevel): string {
+  if (level === "hidden") return "";
+  const text = part.redacted ? "[thinking redacted]" : String(part.thinking ?? "");
+  if (!text) return "";
+  if (level === "brief") {
+    const short = text.length > 200 ? text.slice(0, 197) + "…" : text;
+    return `💭 ${short}`;
+  }
+  return `💭 Thinking\n${text}`;
+}
+
+function contentToRenderParts(
+  content: unknown,
+  thinkingLevel: TelegramRenderLevel = "brief",
+  toolLevel: TelegramRenderLevel = "brief",
+): { body: string; inlineEvents: string[] } {
+  if (typeof content === "string") return { body: content, inlineEvents: [] };
+  if (!Array.isArray(content)) return { body: "", inlineEvents: [] };
+  const body: string[] = [];
+  const inlineEvents: string[] = [];
+  for (const part of content) {
+    if (!part || typeof part !== "object") continue;
+    const p = part as Record<string, any>;
+    if (p.type === "text") body.push(String(p.text ?? ""));
+    else if (p.type === "thinking") {
+      const inline = formatThinkingInline(p, thinkingLevel);
+      if (inline) inlineEvents.push(inline);
+    } else if (p.type === "toolCall") {
+      if (toolLevel === "hidden") continue;
+      const name = String(p.name ?? "tool");
+      inlineEvents.push(toolLevel === "brief"
+        ? formatToolBrief(name, p.arguments ?? {})
+        : `🔧 ${name}\n${stringifyShort(p.arguments ?? {}, 1200)}`);
+    }
+  }
+  return { body: body.filter(Boolean).join("\n"), inlineEvents };
+}
+
+function contentImages(content: unknown): Array<{ data: string; mimeType?: string }> {
+  if (!Array.isArray(content)) return [];
+  return content.flatMap((part) => {
+    if (!part || typeof part !== "object") return [];
+    const p = part as Record<string, any>;
+    return p.type === "image" && typeof p.data === "string"
+      ? [{ data: p.data, mimeType: typeof p.mimeType === "string" ? p.mimeType : undefined }]
+      : [];
+  });
+}
+
+function stringifyShort(value: unknown, max = 900): string {
+  let text: string;
+  if (typeof value === "string") text = value;
+  else {
+    try { text = JSON.stringify(value, null, 2); }
+    catch { text = String(value); }
+  }
+  return text.length <= max ? text : text.slice(0, max - 1) + "…";
+}
+
+function renderLevel(config: TelegramConfig, key: "tool" | "thinking"): TelegramRenderLevel {
+  const value = config[key];
+  return (RENDER_LEVELS as readonly string[]).includes(value ?? "") ? value! : "brief";
+}
+
+function firstLine(text: string): string {
+  return text.split(/\r?\n/, 1)[0].replace(/\s+/g, " ").trim();
+}
+
+function shortenSummary(text: string, max: number): string {
+  if (!text || text === "{}") return "";
+  return text.length <= max ? text : text.slice(0, max - 1) + "…";
+}
+
+function summarizeToolArgs(toolName: string, args: unknown, max = 96): string {
+  if (!args || typeof args !== "object") return "";
+  const a = args as Record<string, unknown>;
+  let text = "";
+
+  if (toolName === "edit" && typeof a.path === "string") text = a.path;
+  else if (toolName === "read" && typeof a.path === "string") {
+    text = a.path;
+    const offset = typeof a.offset === "number" ? a.offset : undefined;
+    const limit = typeof a.limit === "number" ? a.limit : undefined;
+    if (offset !== undefined || limit !== undefined) {
+      const start = offset ?? 1;
+      const end = limit !== undefined ? start + limit - 1 : "";
+      text += `:${start}${end ? `-${end}` : ""}`;
+    }
+  } else if (toolName === "bash" && typeof a.command === "string") text = firstLine(a.command);
+  else if (typeof a.path === "string") text = a.path;
+  else if (typeof a.url === "string") text = a.url;
+  else if (Array.isArray(a.paths)) text = a.paths.map(String).join(", ");
+  else if (typeof a.file === "string") text = a.file;
+  else if (typeof a.query === "string") text = a.query;
+  else text = stringifyShort(args, max);
+
+  return shortenSummary(text, max);
+}
+
+function formatToolBrief(toolName: string, args: unknown): string {
+  const summary = summarizeToolArgs(toolName, args);
+  return summary ? `🔧 ${toolName}: ${summary}` : `🔧 ${toolName}`;
+}
+
+function summarizeToolResult(result: unknown, max = 96): string {
+  if (typeof result === "string") {
+    const text = result.trim();
+    return text.length <= max ? text : text.slice(0, max - 1) + "…";
+  }
+  if (!result || typeof result !== "object") return stringifyShort(result, max);
+  const r = result as Record<string, unknown>;
+  const candidates = [r.errorMessage, r.message, r.error, r.stderr, r.stdout, r.text, r.output, r.result];
+  const found = candidates.find((value) => typeof value === "string" && value.trim());
+  const text = typeof found === "string" ? firstLine(found) : stringifyShort(result, max);
+  return shortenSummary(text, max);
+}
+
+function formatToolFailureBrief(toolName: string, result: unknown, args?: unknown): string {
+  const argSummary = summarizeToolArgs(toolName, args, 72);
+  const resultSummary = summarizeToolResult(result, 72);
+  const summary = argSummary && resultSummary
+    ? `${argSummary} — ${resultSummary}`
+    : argSummary || resultSummary;
+  return summary ? `❌ ${toolName}: ${summary}` : `❌ ${toolName}`;
+}
+
+export function registerTelegramRenderer(
+  pi: ExtensionAPI,
+  deps: {
+    getConfig: () => TelegramConfig;
+    transport: TelegramTransport;
+    getActiveTurn: (chatId?: number) => TelegramTurn | undefined;
+  },
+): void {
+  const sentInlineEvents = new Set<string>();
+  const toolUpdateAt = new Map<string, number>();
+  const toolArgs = new Map<string, unknown>();
+
+  const currentChats = () => {
+    const cfg = deps.getConfig();
+    return cfg.botToken && cfg.activeChatId !== undefined ? [cfg.activeChatId] : [];
+  };
+
+  const send = async (html: string) => {
+    const chatIds = currentChats();
+    if (chatIds.length === 0) return [];
+    return [await deps.transport.sendText(chatIds[0], html)];
+  };
+
+  const sendToTurn = async (html: string, options: { final?: boolean } = {}) => {
+    const turn = deps.getActiveTurn();
+    if (!turn) {
+      await send(html);
+      return;
+    }
+    if (turn.replaceMessageId === undefined) {
+      await deps.transport.sendText(turn.chatId, html);
+      return;
+    }
+    if (options.final && Buffer.byteLength(html, "utf8") > EDIT_LIMIT) {
+      await deps.transport.editText(turn.chatId, turn.replaceMessageId, "🤖 <b>Assistant</b>\n\nFinal answer follows in separate message(s).").catch(() => undefined);
+      turn.replaceMessageId = undefined;
+      await deps.transport.sendText(turn.chatId, html);
+      return;
+    }
+    try {
+      await deps.transport.editText(turn.chatId, turn.replaceMessageId, html);
+    } catch {
+      // Edit failed (message deleted / too many edits). Fall back to a new message.
+      turn.replaceMessageId = undefined;
+      await deps.transport.sendText(turn.chatId, html);
+    }
+  };
+
+  const sendInlineEvent = async (event: string) => {
+    if (!event || sentInlineEvents.has(event)) return;
+    sentInlineEvents.add(event);
+    await sendToTurn(`<blockquote>${escapeHtml(event)}</blockquote>`);
+  };
+
+  const sendInlineEvents = async (events: string[]) => {
+    for (const event of events) await sendInlineEvent(event);
+  };
+
+  pi.on("agent_start", async () => {
+    sentInlineEvents.clear();
+    toolArgs.clear();
+    toolUpdateAt.clear();
+    const turn = deps.getActiveTurn();
+    if (!turn) return;
+    if (turn.replaceMessageId !== undefined) await deps.transport.editText(turn.chatId, turn.replaceMessageId, "🤖 <b>Working…</b>");
+  });
+
+  pi.on("tool_execution_start", async (event) => {
+    const level = renderLevel(deps.getConfig(), "tool");
+    if (level === "hidden") return;
+    toolArgs.set(event.toolCallId, event.args);
+    const inline = level === "brief"
+      ? formatToolBrief(event.toolName, event.args)
+      : `🔧 ${event.toolName} started
+${stringifyShort(event.args, 1200)}`;
+    await sendInlineEvent(inline);
+  });
+
+  pi.on("tool_execution_update", async (event) => {
+    const level = renderLevel(deps.getConfig(), "tool");
+    if (level !== "full") return;
+    const now = Date.now();
+    const last = toolUpdateAt.get(event.toolCallId) ?? 0;
+    if (now - last < TOOL_UPDATE_MS) return;
+    toolUpdateAt.set(event.toolCallId, now);
+    const partial = stringifyShort(event.partialResult, 700);
+    if (!partial || partial === "{}") return;
+    await sendInlineEvent(`🔄 ${event.toolName} update
+${partial}`);
+  });
+
+  pi.on("tool_execution_end", async (event) => {
+    const level = renderLevel(deps.getConfig(), "tool");
+    toolUpdateAt.delete(event.toolCallId);
+    const args = toolArgs.get(event.toolCallId);
+    toolArgs.delete(event.toolCallId);
+    if (level === "hidden") return;
+    const status = event.isError ? "❌ Tool failed" : "✅ Tool finished";
+    const result = stringifyShort(event.result, event.isError ? 1800 : 900);
+    if (level === "brief") {
+      if (!event.isError) return;
+      await sendInlineEvent(formatToolFailureBrief(event.toolName, event.result, args));
+    } else {
+      await sendInlineEvent(result && result !== "{}"
+        ? `${status}: ${event.toolName}
+${result}`
+        : `${status}: ${event.toolName}`);
+    }
+  });
+
+  pi.on("message_end", async (event) => {
+    const message = event.message as AnyMessage;
+    if (message.role !== "assistant") return;
+    const config = deps.getConfig();
+    const thinkingLevel = renderLevel(config, "thinking");
+    const toolLevel = renderLevel(config, "tool");
+    const rendered = contentToRenderParts(message.content, thinkingLevel, toolLevel);
+    await sendInlineEvents(rendered.inlineEvents);
+    const body = rendered.body || message.errorMessage || "";
+    const images = contentImages(message.content);
+
+    const hasBody = body.trim().length > 0;
+    if (hasBody) await sendToTurn(markdownToTelegramHtml(body), { final: true });
+
+    const turn = deps.getActiveTurn();
+    for (const image of images) {
+      const chatIds = turn ? [turn.chatId] : currentChats();
+      for (const chatId of chatIds) {
+        await deps.transport.sendChatAction(chatId, "upload_photo");
+        await deps.transport.sendPhoto(chatId, image.data, "image").catch(() => deps.transport.sendText(chatId, "[image output could not be sent]"));
+      }
+    }
+    if (!hasBody && turn?.replaceMessageId !== undefined && images.length > 0) {
+      const noun = `${images.length} image${images.length === 1 ? "" : "s"}`;
+      await deps.transport.editText(turn.chatId, turn.replaceMessageId, `✅ <b>Output sent.</b>\n${noun}`);
+      turn.replaceMessageId = undefined;
+    }
+  });
+
+}