@llblab/pi-telegram 0.2.9 → 0.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@llblab/pi-telegram",
-  "version": "0.2.9",
+  "version": "0.3.0",
   "private": false,
   "description": "Better Telegram DM bridge extension for pi",
   "type": "module",
@@ -21,8 +21,19 @@
     "url": "https://github.com/llblab/pi-telegram/issues"
   },
   "scripts": {
-    "test": "node --experimental-strip-types --test tests/*.test.ts"
+    "test": "node --experimental-strip-types --test tests/*.test.ts",
+    "typecheck": "tsc --noEmit",
+    "audit": "npm audit",
+    "pack:check": "npm pack --dry-run",
+    "validate": "npm run typecheck && npm test && npm run audit && npm run pack:check"
   },
+  "files": [
+    "index.ts",
+    "lib/",
+    "README.md",
+    "docs/",
+    "screenshot.png"
+  ],
   "publishConfig": {
     "access": "public"
   },
@@ -33,9 +44,13 @@
     "image": "https://github.com/llblab/pi-telegram/raw/main/screenshot.png"
   },
   "peerDependencies": {
-    "@mariozechner/pi-ai": "*",
     "@mariozechner/pi-agent-core": "*",
+    "@mariozechner/pi-ai": "*",
     "@mariozechner/pi-coding-agent": "*",
     "@sinclair/typebox": "*"
+  },
+  "devDependencies": {
+    "@types/node": "latest",
+    "typescript": "latest"
   }
 }

package/AGENTS.md

@@ -1,91 +0,0 @@
-# Project Context
-
-## 0. Meta-Protocol Principles
-
-- `Constraint-Driven Evolution`: Add structure when the bridge gains real operator or runtime constraints
-- `Single Source of Truth`: Keep durable rules in `AGENTS.md`, open work in `BACKLOG.md`, completed delivery in `CHANGELOG.md`, and deeper technical detail in `/docs`
-- `Boundary Clarity`: Separate Telegram transport concerns, pi integration concerns, rendering behavior, and release/documentation state
-- `Progressive Enhancement + Graceful Degradation`: Prefer behavior that upgrades automatically when richer runtime context exists, but always preserves a useful fallback path when it does not
-- `Runtime Safety`: Prefer queue and rendering behavior that fails predictably over clever behavior that can desynchronize the Telegram bridge from pi session state
-
-## 1. Concept
-
-`pi-telegram` is a pi extension that turns a Telegram DM into a session-local frontend for pi, including text/file forwarding, streaming previews, queued follow-ups, model controls, and outbound attachment delivery.
-
-## 2. Identity & Naming Contract
-
-- `Telegram turn`: One unit of Telegram input processed by pi; this may represent one message or a coalesced media group
-- `Queued Telegram turn`: A Telegram turn accepted by the bridge but not yet active in pi
-- `Active Telegram turn`: The Telegram turn currently bound to the running pi agent loop
-- `Preview`: The transient streamed response shown through Telegram drafts or editable messages before the final reply lands
-- `Scoped models`: The subset of models exposed to Telegram model selection when pi settings or CLI flags limit the available list
-
-## 3. Project Topology
-
-- `/index.ts`: Main extension entrypoint and runtime composition layer for the bridge
-- `/lib/*.ts`: Flat domain modules for reusable runtime logic. Favor domain files such as queueing/runtime, replies, polling, updates, attachments, registration/hooks, Telegram API/config, turns, media, setup, rendering, menu/status/model-resolution support, and other cohesive bridge subsystems; use `shared` only when a type or constant truly spans multiple domains
-- `/tests/*.test.ts`: Domain-mirrored regression suites that follow the same flat naming as `/lib`
-- `/docs/README.md`: Documentation index for technical project docs
-- `/docs/architecture.md`: Runtime and subsystem overview for the bridge
-- `/README.md`: User-facing project entry point, install guide, and fork summary
-- `/AGENTS.md`: Durable engineering and runtime conventions
-- `/BACKLOG.md`: Canonical open work
-- `/CHANGELOG.md`: Completed delivery history
-
-## 4. Core Entities
-
-- `TelegramConfig`: Persisted bot/session pairing state
-- `PendingTelegramTurn` / `ActiveTelegramTurn`: Queue and active-turn state for Telegram-originated work
-- `TelegramPreviewState`: Streaming preview state for drafts or editable Telegram messages
-- `TelegramModelMenuState`: Inline menu state for status/model/thinking controls
-- `QueuedAttachment`: Outbound files staged for delivery through `telegram_attach`
-
-## 5. Architectural Decisions
-
-- `index.ts` stays the single extension entrypoint, while reusable runtime logic should be split into flat domain files under `/lib`; prefer domain-oriented grouping over atomizing every helper into its own file, and use `shared` sparingly for genuinely cross-domain types or constants
-- The bridge is session-local and intentionally pairs with a single allowed Telegram user per config
-- Telegram queue state is tracked locally and must stay aligned with pi agent lifecycle hooks; queued items now have explicit kinds and lanes so prompt turns and synthetic control actions can share one ordering model, while dispatch still respects active turns, pending dispatch, compaction, and pi pending-message state
-- Prompt items should remain in the queue until `agent_start` consumes the dispatched turn; removing them earlier breaks active-turn binding, preview delivery, and end-of-turn follow-up behavior
-- In-flight `/model` switching is supported only for Telegram-owned active turns and is implemented as set-model plus synthetic continuation turn plus abort; if a tool call is active, the abort is delayed until that tool finishes instead of interrupting the tool mid-flight
-- Telegram replies render through Telegram HTML, not raw Markdown; real code blocks must stay literal and escaped
-- `telegram_attach` is the canonical outbound file-delivery path for Telegram-originated requests
-
-## 6. Engineering Conventions
-
-- Treat queue handling, compaction interaction, and lifecycle-hook state transitions as regression-prone areas; validate them after changing dispatch logic
-- Treat Markdown rendering as Telegram-specific output work, not generic Markdown rendering; preserve literal code content, avoid HTML chunk splits that break tags, prefer width-efficient monospace table and list formatting for narrow clients, and flatten nested Markdown quotes into indented single-blockquote output because Telegram does not render nested blockquotes reliably
-- Keep comments and user-facing docs in English unless the surrounding file already follows another convention
-- Each project `.ts` file should start with a short multi-line responsibility header comment that explains the file boundary to future maintainers
-- Name extracted `/lib` modules and mirrored `/tests` suites by bare domain when the repository already supplies the Telegram scope; prefer `api.ts`, `queue.ts`, `updates.ts`, and `queue.test.ts` over redundant `telegram-*` filename prefixes
-- Prefer targeted edits, keeping `index.ts` as the orchestration layer and moving reusable logic into flat `/lib` domain modules when a subsystem becomes large enough to earn extraction; current extracted domains include queueing/runtime decisions, preview streaming, replies, polling, updates, attachments, registration and lifecycle-hook binding, Telegram API/config support, turn-building, media extraction, setup, rendering, status rendering, menu/model-resolution/UI support, and model-switch support
-- Keep preview appearance logic in the rendering domain and preview transport/lifecycle logic in the preview domain so richer streaming strategies can evolve without entangling Telegram delivery state with Markdown formatting rules
-
-## 7. Operational Conventions
-
-- When Telegram-visible behavior changes, sync `README.md` and the relevant `/docs` entry in the same pass
-- When durable runtime constraints or repeat bug patterns emerge, record them here instead of burying them in changelog prose
-- When fork identity changes, keep `README.md`, package metadata, and docs aligned so the published package does not point back at stale upstream coordinates
-- Work only inside this repository during development tasks; updating the installed Pi extension checkout is a separate manual operator step, not part of normal in-repo implementation work
-
-## 8. Integration Protocols
-
-- Telegram API methods currently used include polling, message editing, draft streaming, callback queries, reactions, file download, and media upload endpoints
-- pi integration depends on lifecycle hooks such as `before_agent_start`, `agent_start`, `message_start`, `message_update`, and `agent_end`
-- `ctx.ui.input()` provides placeholder text rather than an editable prefilled value; when a real default must appear already filled in, prefer `ctx.ui.editor()`
-- For `/telegram-setup`, prefer the locally saved bot token over environment variables on repeat setup runs; env vars are the bootstrap path when no local token exists
-- Status/model/thinking controls are driven through Telegram inline keyboards and callback queries
-- Inbound files may become pi image inputs; outbound files must flow through `telegram_attach`
-
-## 9. Pre-Task Preparation Protocol
-
-- Read `README.md` for current user-facing behavior and fork positioning
-- Read `BACKLOG.md` before changing runtime behavior or documentation so open work stays truthful
-- Read `/docs/architecture.md` before restructuring queue, preview, rendering, or command-handling logic
-- Inspect the relevant `index.ts` section before editing because most bridge behavior is stateful and cross-linked
-
-## 10. Task Completion Protocol
-
-- Run the smallest meaningful validation for the touched area; `npm test` is the default regression suite once rendering or queue logic changes
-- For rendering changes, ensure regressions still cover nested lists, code blocks, underscore-heavy text, and long-message chunking
-- For queue/dispatch changes, validate abort, compaction, pending-dispatch, and pi pending-message guard behavior
-- Sync `README.md`, `CHANGELOG.md`, `BACKLOG.md`, and `/docs` whenever user-visible behavior or real open-work state changes

package/BACKLOG.md

@@ -1,5 +0,0 @@
-# Project Backlog
-
-## Open Backlog
-
-- No open backlog items right now

package/CHANGELOG.md

@@ -1,23 +0,0 @@
-# Changelog
-
-## Current
-
-- `[Rendering]` Hardened link rendering so absolute links stay clickable, markdown-heavy link labels reduce to plain clickable labels, tooltip titles are ignored safely, balanced-parenthesis URLs stay intact, and unsupported link forms degrade without broken anchors. Impact: Telegram replies now keep more links usable while avoiding malformed output for relative, reference-style, or footnote-like link syntax.
-- `[Preview]` Evolved rich streaming from first-chunk snapshots to stable-block previews with a conservative plain tail fallback, while preserving original blank-line spacing between rendered blocks and keeping headings visually separated from following blocks. Impact: closed top-level Markdown blocks now stream as rich Telegram HTML before finalization, incomplete fences, quotes, lists, and other trailing work remain readable without producing broken rich formatting, preview/final block spacing no longer collapses extra empty lines, and headings no longer visually merge into following code blocks when source Markdown omits a blank line.
-- `[Refactor]` Split preview concerns so runtime transport and finalization live in the preview domain while preview snapshot derivation lives in the rendering domain. Impact: rich streaming can evolve independently from final reply delivery while keeping preview appearance decisions closer to the Telegram renderer.
-- `[Streaming]` Switched Telegram previews from plain draft-first text to rich first-chunk message editing, so formatting appears during generation instead of only after finalization. Impact: users now see richer streamed output earlier, while final replies still replace the preview with fully rendered Telegram HTML.
-- `[Rendering]` Preserved leading indentation on the first Markdown line, kept numeric markers for ordered task lists in both preview and final Telegram rendering, and stopped reinterpreting standalone `[x]` or `[ ]` prose as inline checkboxes. Impact: nested content no longer flattens when a message starts with indentation, numbered checklists keep their ordered semantics, and literal checklist-like prose stays literal.
-- `[Queue UI]` Marked liked high-priority queued Telegram turns with `⬆` in the pi status-bar queue preview. Impact: operators can now distinguish reaction-promoted turns from normal queued prompts at a glance.
-- `[Docs]` Added short responsibility header comments to every project `.ts` file. Impact: file boundaries are easier to understand while navigating the growing `/lib` split.
-- `[Naming]` Renamed extracted domain modules and mirrored regression suites to use repo-scoped bare domain filenames such as `api.ts`, `queue.ts`, and `queue.test.ts` instead of repeating `telegram-*` in every path. Impact: the internal topology is easier to scan and stays aligned with the repository-level Telegram scope.
-- `[Controls]` Expanded Telegram session controls with a richer `/status` view, inline model selection, and thinking-level controls, and fixed the callback-selection path so idle model and thinking picks apply immediately instead of only becoming visible after a later Telegram interaction. Impact: more bridge configuration can be managed directly from Telegram with more predictable immediate feedback.
-- `[Queue]` Upgraded Telegram turn queueing with previews, reaction-driven prioritization/removal, media-group handling, aborted-turn history preservation, and safer dispatch gating. Impact: follow-up handling is more transparent and less prone to lifecycle races.
-- `[Rendering]` Added Telegram-oriented Markdown rendering and hardened reply streaming/chunking behavior, including narrower monospace Markdown table output without outer side borders, monospace list markers for unordered and ordered lists, and flattened nested quote indentation inside a single Telegram blockquote. Impact: formatted replies render more reliably while preserving literal code blocks and using width more efficiently on narrow Telegram clients.
-- `[Runtime]` Hardened attachment delivery, polling/runtime behavior, Telegram session integration, preview-finalization and reply-transport routing into the replies domain, lazy Telegram API client routing into the Telegram API domain, turn-building extraction into its own domain, menu/model-resolution plus menu-state, pure menu-page derivation, pure menu render-payload builders, menu-message runtime, callback parsing, callback entry handling, callback mutation helpers, full model-callback planning and execution, and interface-polished callback effect ports into the menu domain, direct execute-from-update routing into the updates domain, model-switch restart glue extraction into the model-switch domain, and tool/command/lifecycle-hook registration extraction into a dedicated registration domain. Impact: the bridge is more robust as a daily Telegram frontend for pi.
-- `[Metadata]` Updated package repository metadata to point at the `llblab/pi-telegram` fork and renamed the npm package to `@llblab/pi-telegram` with public scoped publish settings. Impact: published package links no longer send users to stale upstream coordinates and the package can be published under the fork-owned npm scope.
-- `[Validation]` Added lightweight regression tests for Telegram Markdown rendering, queue/runtime/agent-loop/session/control/dispatch, replies, polling, updates, attachments, registration, turns, menu, and Telegram API/media/config helpers, including quote/list, table, link/code, mixed-link/code chunking, mixed-block chunk transitions, long multi-block, long-quote, long inline-formatting chunk boundaries, list-code-quote-prose chunk transitions, narrower monospace table rendering without outer side borders, monospace unordered and ordered list markers, flattened nested quote indentation inside one Telegram blockquote, inbound poll/pair/dispatch runtime cases, preview finalization, aborted-turn history carry-over, queued-status/model-after-agent-end sequencing, compaction gating, media-group debounce dispatch, direct menu callback planning and execution, pure menu-page derivation, pure menu render-payload builders, reaction-driven reprioritization/removal, immediate in-flight model-switch continuation, delayed abort-after-tool-completion, lazy Telegram API client routing, turn-building, and scoped-model resolution. Impact: key renderer and queue invariants now have repeatable automated coverage across the known high-risk bridge paths.
-- `[Model Switching]` Enabled `/model` during an active Telegram-owned run by applying the new model and continuing on the new model automatically, delaying the abort until the current tool finishes when needed. Impact: Telegram can now approximate pi's manual stop-switch-continue workflow with fewer mid-tool aborts.
-- `[Queue Core]` Introduced queued item kinds and explicit queue-lane ordering semantics so prompt turns and synthetic control actions share one ordering model, then regrouped the extracted helpers into flatter domain-oriented `/lib` modules such as queue, replies, polling, updates, attachments, turns, menu, Telegram API, and registration while keeping `index.ts` as the entrypoint. Prompt items now stay queued until `agent_start` consumes the dispatched turn, which restores correct active-turn binding for previews and final delivery. Impact: the bridge now has a clearer foundation for scheduling async extension operations alongside Telegram prompts without losing a single obvious runtime entry file.
-- `[Registration]` Moved extension tool, command, and lifecycle-hook binding into the registration domain and added registration-focused regression coverage. Impact: extension wiring is easier to reason about and test without dragging full runtime state into every registration change.
-- `[Control Queue]` Moved `/status` and `/model` command handling onto high-priority control queue items. Impact: control actions can wait safely behind the current run while still jumping ahead of normal queued prompts.
-- `[Setup]` `/telegram-setup` now shows the stored bot token first, otherwise prefills from common Telegram bot environment variables before falling back to the placeholder, using an actual prefilled editor when a real default exists. Impact: repeat setup respects local saved state while first-run and secret-managed setup stay fast.

package/lib/model-switch.ts

@@ -1,62 +0,0 @@
-/**
- * In-flight Telegram model-switch helpers
- * Encodes the safe restart and continuation rules for switching models during active Telegram-owned runs
- */
-
-import type { Model } from "@mariozechner/pi-ai";
-
-import type { TelegramInFlightModelSwitchState } from "./queue.ts";
-
-export type TelegramThinkingLevel =
-  | "off"
-  | "minimal"
-  | "low"
-  | "medium"
-  | "high"
-  | "xhigh";
-
-export function canRestartTelegramTurnForModelSwitch(
-  state: TelegramInFlightModelSwitchState,
-): boolean {
-  return !state.isIdle && state.hasActiveTelegramTurn && state.hasAbortHandler;
-}
-
-export function shouldTriggerPendingTelegramModelSwitchAbort(state: {
-  hasPendingModelSwitch: boolean;
-  hasActiveTelegramTurn: boolean;
-  hasAbortHandler: boolean;
-  activeToolExecutions: number;
-}): boolean {
-  return (
-    state.hasPendingModelSwitch &&
-    state.hasActiveTelegramTurn &&
-    state.hasAbortHandler &&
-    state.activeToolExecutions === 0
-  );
-}
-
-export function restartTelegramModelSwitchContinuation<TTurn, TSelection>(state: {
-  activeTurn: TTurn | undefined;
-  abort: (() => void) | undefined;
-  selection: TSelection;
-  queueContinuation: (turn: TTurn, selection: TSelection) => void;
-}): boolean {
-  if (!state.activeTurn || !state.abort) return false;
-  state.queueContinuation(state.activeTurn, state.selection);
-  state.abort();
-  return true;
-}
-
-export function buildTelegramModelSwitchContinuationText<
-  TModel extends Pick<Model<any>, "provider" | "id">,
->(
-  telegramPrefix: string,
-  model: TModel,
-  thinkingLevel?: TelegramThinkingLevel,
-): string {
-  const modelLabel = `${model.provider}/${model.id}`;
-  const thinkingSuffix = thinkingLevel
-    ? ` Keep the selected thinking level (${thinkingLevel}) if it still applies.`
-    : "";
-  return `${telegramPrefix} Continue the interrupted previous Telegram request using the newly selected model (${modelLabel}). Resume from the last unfinished step instead of restarting from scratch unless necessary.${thinkingSuffix}`;
-}

package/tests/api.test.ts

@@ -1,89 +0,0 @@
-/**
- * Regression tests for Telegram API and config helpers
- * Verifies config persistence and direct helper behavior around missing tokens and callback-query failures
- */
-
-import assert from "node:assert/strict";
-import { mkdtemp, readFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import test from "node:test";
-
-import {
-  answerTelegramCallbackQuery,
-  callTelegram,
-  createTelegramApiClient,
-  downloadTelegramFile,
-  readTelegramConfig,
-  writeTelegramConfig,
-} from "../lib/api.ts";
-
-test("Telegram config helpers persist and reload config", async () => {
-  const agentDir = await mkdtemp(join(tmpdir(), "pi-telegram-config-"));
-  const configPath = join(agentDir, "telegram.json");
-  const config = {
-    botToken: "123:abc",
-    botUsername: "demo_bot",
-    allowedUserId: 42,
-  };
-  await writeTelegramConfig(agentDir, configPath, config);
-  const reloaded = await readTelegramConfig(configPath);
-  assert.deepEqual(reloaded, config);
-  const raw = await readFile(configPath, "utf8");
-  assert.match(raw, /demo_bot/);
-});
-
-test("Telegram API helpers reject missing bot token for direct calls", async () => {
-  await assert.rejects(() => callTelegram(undefined, "getMe", {}), {
-    message: "Telegram bot token is not configured",
-  });
-  await assert.rejects(
-    () =>
-      downloadTelegramFile(
-        undefined,
-        "file-id",
-        "demo.txt",
-        join(tmpdir(), "pi-telegram-missing-token"),
-      ),
-    {
-      message: "Telegram bot token is not configured",
-    },
-  );
-});
-
-test("answerTelegramCallbackQuery ignores Telegram API failures", async () => {
-  const originalFetch = globalThis.fetch;
-  globalThis.fetch = (async () => {
-    throw new Error("network down");
-  }) as typeof fetch;
-  try {
-    await assert.doesNotReject(() =>
-      answerTelegramCallbackQuery("123:abc", "callback-id", "ok"),
-    );
-  } finally {
-    globalThis.fetch = originalFetch;
-  }
-});
-
-test("Telegram API client resolves bot tokens lazily for wrapped calls", async () => {
-  const originalFetch = globalThis.fetch;
-  const calls: string[] = [];
-  let botToken = "123:abc";
-  globalThis.fetch = (async (input) => {
-    calls.push(typeof input === "string" ? input : input.toString());
-    return {
-      ok: true,
-      json: async () => ({ ok: true, result: true }),
-    } as Response;
-  }) as typeof fetch;
-  try {
-    const client = createTelegramApiClient(() => botToken);
-    await client.call("sendChatAction", { chat_id: 1, action: "typing" });
-    botToken = "456:def";
-    await client.answerCallbackQuery("cb-1", "ok");
-    assert.match(calls[0] ?? "", /bot123:abc\/sendChatAction$/);
-    assert.match(calls[1] ?? "", /bot456:def\/answerCallbackQuery$/);
-  } finally {
-    globalThis.fetch = originalFetch;
-  }
-});

package/tests/attachments.test.ts

@@ -1,132 +0,0 @@
-/**
- * Regression tests for the Telegram attachments domain
- * Covers attachment queueing and attachment delivery behavior in one domain-level suite
- */
-
-import assert from "node:assert/strict";
-import test from "node:test";
-
-import {
-  queueTelegramAttachments,
-  sendQueuedTelegramAttachments,
-} from "../lib/attachments.ts";
-
-test("Attachment queueing adds files to the active Telegram turn", async () => {
-  const activeTurn = {
-    queuedAttachments: [],
-  } as unknown as {
-    queuedAttachments: Array<{ path: string; fileName: string }>;
-  } & Parameters<typeof queueTelegramAttachments>[0]["activeTurn"];
-  const result = await queueTelegramAttachments({
-    activeTurn,
-    paths: ["/tmp/demo.txt"],
-    maxAttachmentsPerTurn: 2,
-    statPath: async () => ({ isFile: () => true }),
-  });
-  assert.deepEqual(activeTurn.queuedAttachments, [
-    { path: "/tmp/demo.txt", fileName: "demo.txt" },
-  ]);
-  assert.deepEqual(result.details.paths, ["/tmp/demo.txt"]);
-});
-
-test("Attachment queueing rejects missing turns, non-files, and full queues", async () => {
-  await assert.rejects(
-    () =>
-      queueTelegramAttachments({
-        activeTurn: undefined,
-        paths: ["/tmp/demo.txt"],
-        maxAttachmentsPerTurn: 1,
-        statPath: async () => ({ isFile: () => true }),
-      }),
-    { message: /active Telegram turn/ },
-  );
-  await assert.rejects(
-    () =>
-      queueTelegramAttachments({
-        activeTurn: { queuedAttachments: [] } as never,
-        paths: ["/tmp/demo.txt"],
-        maxAttachmentsPerTurn: 1,
-        statPath: async () => ({ isFile: () => false }),
-      }),
-    { message: "Not a file: /tmp/demo.txt" },
-  );
-  await assert.rejects(
-    () =>
-      queueTelegramAttachments({
-        activeTurn: {
-          queuedAttachments: [{ path: "/tmp/a.txt", fileName: "a.txt" }],
-        } as never,
-        paths: ["/tmp/demo.txt"],
-        maxAttachmentsPerTurn: 1,
-        statPath: async () => ({ isFile: () => true }),
-      }),
-    { message: "Attachment limit reached (1)" },
-  );
-});
-
-test("Attachment delivery chooses photo vs document methods from file paths", async () => {
-  const sent: Array<string> = [];
-  await sendQueuedTelegramAttachments(
-    {
-      kind: "prompt",
-      chatId: 1,
-      replyToMessageId: 2,
-      sourceMessageIds: [],
-      queueOrder: 1,
-      queueLane: "default",
-      laneOrder: 1,
-      queuedAttachments: [
-        { path: "/tmp/a.png", fileName: "a.png" },
-        { path: "/tmp/b.txt", fileName: "b.txt" },
-      ],
-      content: [{ type: "text", text: "prompt" }],
-      historyText: "history",
-      statusSummary: "summary",
-    },
-    {
-      sendMultipart: async (
-        method,
-        _fields,
-        fileField,
-        _filePath,
-        fileName,
-      ) => {
-        sent.push(`${method}:${fileField}:${fileName}`);
-      },
-      sendTextReply: async () => undefined,
-    },
-  );
-  assert.deepEqual(sent, [
-    "sendPhoto:photo:a.png",
-    "sendDocument:document:b.txt",
-  ]);
-});
-
-test("Attachment delivery reports per-file failures via text replies", async () => {
-  const replies: string[] = [];
-  await sendQueuedTelegramAttachments(
-    {
-      kind: "prompt",
-      chatId: 1,
-      replyToMessageId: 2,
-      sourceMessageIds: [],
-      queueOrder: 1,
-      queueLane: "default",
-      laneOrder: 1,
-      queuedAttachments: [{ path: "/tmp/a.png", fileName: "a.png" }],
-      content: [{ type: "text", text: "prompt" }],
-      historyText: "history",
-      statusSummary: "summary",
-    },
-    {
-      sendMultipart: async () => {
-        throw new Error("upload failed");
-      },
-      sendTextReply: async (_chatId, _replyToMessageId, text) => {
-        replies.push(text);
-        return undefined;
-      },
-    },
-  );
-  assert.deepEqual(replies, ["Failed to send attachment a.png: upload failed"]);
-});

package/tests/config.test.ts

@@ -1,80 +0,0 @@
-/**
- * Regression tests for Telegram setup prompt defaults
- * Covers token-prefill priority across stored config, environment variables, and placeholder fallback
- */
-
-import assert from "node:assert/strict";
-import test from "node:test";
-
-import { __telegramTestUtils } from "../index.ts";
-
-test("Bot token input prefers stored config over env vars", () => {
-  const value = __telegramTestUtils.getTelegramBotTokenInputDefault(
-    {
-      TELEGRAM_KEY: "key-last",
-      TELEGRAM_TOKEN: "token-third",
-      TELEGRAM_BOT_KEY: "key-second",
-      TELEGRAM_BOT_TOKEN: "token-first",
-    },
-    "stored-token",
-  );
-  assert.equal(value, "stored-token");
-});
-
-test("Bot token input prefers the first configured Telegram env var when no config exists", () => {
-  const value = __telegramTestUtils.getTelegramBotTokenInputDefault({
-    TELEGRAM_KEY: "key-last",
-    TELEGRAM_TOKEN: "token-third",
-    TELEGRAM_BOT_KEY: "key-second",
-    TELEGRAM_BOT_TOKEN: "token-first",
-  });
-  assert.equal(value, "token-first");
-});
-
-test("Bot token prompt uses the editor when a real prefill exists", () => {
-  const prompt = __telegramTestUtils.getTelegramBotTokenPromptSpec({
-    TELEGRAM_BOT_TOKEN: "token-first",
-  });
-  assert.deepEqual(prompt, {
-    method: "editor",
-    value: "token-first",
-  });
-});
-
-test("Bot token prompt shows stored config before env values", () => {
-  const prompt = __telegramTestUtils.getTelegramBotTokenPromptSpec(
-    {
-      TELEGRAM_BOT_TOKEN: "token-first",
-    },
-    "stored-token",
-  );
-  assert.deepEqual(prompt, {
-    method: "editor",
-    value: "stored-token",
-  });
-});
-
-test("Bot token input skips blank env vars and falls back to config", () => {
-  const value = __telegramTestUtils.getTelegramBotTokenInputDefault(
-    {
-      TELEGRAM_BOT_TOKEN: "   ",
-      TELEGRAM_BOT_KEY: "",
-      TELEGRAM_TOKEN: "  ",
-    },
-    "stored-token",
-  );
-  assert.equal(value, "stored-token");
-});
-
-test("Bot token input falls back to placeholder when no value exists", () => {
-  const value = __telegramTestUtils.getTelegramBotTokenInputDefault({});
-  assert.equal(value, "123456:ABCDEF...");
-});
-
-test("Bot token prompt uses placeholder input when no prefill exists", () => {
-  const prompt = __telegramTestUtils.getTelegramBotTokenPromptSpec({});
-  assert.deepEqual(prompt, {
-    method: "input",
-    value: "123456:ABCDEF...",
-  });
-});

package/tests/media.test.ts

@@ -1,77 +0,0 @@
-/**
- * Regression tests for Telegram media and text extraction helpers
- * Covers inbound file-info collection, text extraction, id collection, and history formatting
- */
-
-import assert from "node:assert/strict";
-import test from "node:test";
-
-import {
-  collectTelegramFileInfos,
-  collectTelegramMessageIds,
-  extractFirstTelegramMessageText,
-  extractTelegramMessagesText,
-  formatTelegramHistoryText,
-  guessMediaType,
-} from "../lib/media.ts";
-
-test("Media helpers collect file infos across Telegram message variants", () => {
-  const files = collectTelegramFileInfos([
-    {
-      message_id: 1,
-      text: "hello",
-      photo: [
-        { file_id: "small", file_size: 1 },
-        { file_id: "large", file_size: 10 },
-      ],
-      document: {
-        file_id: "doc",
-        file_name: "report.png",
-        mime_type: "image/png",
-      },
-      voice: {
-        file_id: "voice",
-        mime_type: "audio/ogg",
-      },
-      sticker: {
-        file_id: "sticker",
-      },
-    },
-  ]);
-  assert.deepEqual(
-    files.map((file) => ({
-      id: file.file_id,
-      name: file.fileName,
-      image: file.isImage,
-    })),
-    [
-      { id: "large", name: "photo-1.jpg", image: true },
-      { id: "doc", name: "report.png", image: true },
-      { id: "voice", name: "voice-1.ogg", image: false },
-      { id: "sticker", name: "sticker-1.webp", image: true },
-    ],
-  );
-});
-
-test("Media helpers extract text, ids, and history summaries", () => {
-  const messages = [
-    { message_id: 1, text: "first" },
-    { message_id: 2, caption: "second" },
-    { message_id: 2, text: "duplicate id" },
-  ];
-  assert.equal(
-    extractTelegramMessagesText(messages),
-    "first\n\nsecond\n\nduplicate id",
-  );
-  assert.equal(extractFirstTelegramMessageText(messages), "first");
-  assert.deepEqual(collectTelegramMessageIds(messages), [1, 2]);
-  assert.equal(
-    formatTelegramHistoryText("hello", [{ path: "/tmp/demo.txt" }]),
-    "hello\nAttachments:\n- /tmp/demo.txt",
-  );
-});
-
-test("Media helpers infer outgoing image media types from file paths", () => {
-  assert.equal(guessMediaType("/tmp/demo.png"), "image/png");
-  assert.equal(guessMediaType("/tmp/demo.txt"), undefined);
-});