telegram-agent-kit 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ivan Kalinichenko
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,237 @@
+# telegram-agent-kit
+
+> Wire LLM agents to Telegram: render Markdown, stream replies into a live native draft, and drive a snapshot/rollback turn-loop — over thin injected interfaces, with **zero runtime dependencies** in the core.
+
+[![npm](https://img.shields.io/npm/v/telegram-agent-kit.svg)](https://www.npmjs.com/package/telegram-agent-kit)
+[![license](https://img.shields.io/npm/l/telegram-agent-kit.svg)](./LICENSE)
+[![types](https://img.shields.io/npm/types/telegram-agent-kit.svg)](https://www.typescriptlang.org/)
+
+ESM-only. Runs on **Node 18+, Bun, Deno, and the browser** (the formatting core).
+
+---
+
+## Why this exists
+
+Connecting an LLM agent to a Telegram bot looks simple until you hit the edges:
+
+- LLMs emit arbitrary Markdown — Telegram speaks a small, strict HTML subset. A
+  single unclosed tag makes the Bot API reject the whole message.
+- Token streaming into a *live draft* means you render **partial** Markdown many
+  times a second, where marks and fences are routinely mid-token.
+- A failed turn must roll back cleanly so the conversation thread isn't corrupted.
+
+`telegram-agent-kit` solves these once. Notably, it's the only JS package that
+renders Markdown to **Telegram-HTML** with **totality** (never throws on arbitrary
+LLM output) *and* a **streaming/partial** mode (auto-closes unclosed marks and
+fences, so a live draft never flashes broken markup).
+
+It is **runtime-agnostic**: you supply all I/O through small injected interfaces,
+and the kit owns the orchestration. No HTTP client, no framework, no globals.
+
+## Features
+
+- **Markdown → Telegram-HTML** that never throws, with a `partial` mode for live drafts.
+- **Live draft streaming** — a throttle / keepalive / typing-heartbeat / drain state
+  machine that animates one native Telegram draft from a growing string.
+- **Turn-loop orchestration** — `snapshot → stream → animate → finalize → reply`,
+  with rollback on error and a guarantee it never throws out.
+- **Resilient send path** — automatic chunking, surrogate-safe splitting, and
+  deterministic `400` fallbacks (rich → HTML → plain text; photo → text).
+- **Optional deepagents adapter** on a separate subpath, so the core never pulls in
+  langchain.
+
+## Installation
+
+```sh
+npm install telegram-agent-kit
+```
+
+The optional `telegram-agent-kit/deepagents` subpath needs its peers — install them
+only if you use it:
+
+```sh
+npm install @langchain/core deepagents
+```
+
+## Quick start
+
+Implement a thin `BotClient` over the Bot API, then drive one turn per incoming
+message. The example uses the deepagents adapter, but any `AgentStream` works.
+
+```ts
+import { runTelegramTurn, TelegramApiError, type BotClient } from 'telegram-agent-kit';
+import { toAgentStream } from 'telegram-agent-kit/deepagents';
+
+// 1. Raw Bot API primitives — one HTTP call each. Throw TelegramApiError on a
+//    Bot API error so the kit's deterministic-400 fallbacks can fire.
+const client: BotClient = {
+  sendMessage:        (p, signal) => call('sendMessage',        { chat_id: p.chatId, text: p.text, parse_mode: p.parseMode }, signal),
+  sendRichMessage:    (p, signal) => call('sendMessage',        { chat_id: p.chatId, text: p.markdown },                       signal),
+  sendPhoto:          (p, signal) => call('sendPhoto',          { chat_id: p.chatId, photo: p.url, caption: p.caption, parse_mode: p.parseMode }, signal),
+  sendChatAction:     (p, signal) => call('sendChatAction',     { chat_id: p.chatId, action: p.action ?? 'typing' },          signal),
+  sendMessageDraft:   (p, signal) => call('sendMessageDraft',   { chat_id: p.chatId, draft_id: p.draftId, text: p.text },     signal),
+  sendRichMessageDraft:(p, signal) => call('sendRichMessageDraft',{ chat_id: p.chatId, draft_id: p.draftId, text: p.markdown },signal),
+};
+
+// 2. Drive one turn.
+await runTelegramTurn({
+  chatKey: { chatId, agentId: 'main' },
+  userText,
+  draftId: updateId,        // non-zero, unique per turn — reused for every draft write
+  rich: true,
+  client,
+  agentStream: toAgentStream(agent),   // your deepagents agent
+  checkpointer: {
+    snapshot: (threadId)     => saver.snapshotId(threadId),
+    rollback: (threadId, id) => saver.rollbackThread(threadId, id),
+  },
+  threadStore: {
+    resolve: (key)      => threads.resolve(key.chatId, key.agentId),
+    touch:   (key, now) => threads.touch(key.chatId, key.agentId, now),
+  },
+  log: console,
+});
+
+// Thin transport helper.
+async function call(method: string, body: unknown, signal?: AbortSignal) {
+  const res = await fetch(`https://api.telegram.org/bot${TOKEN}/${method}`, {
+    method: 'POST',
+    headers: { 'content-type': 'application/json' },
+    body: JSON.stringify(body),
+    signal,
+  });
+  if (!res.ok) {
+    const j = await res.json().catch(() => ({}));
+    throw new TelegramApiError(res.status, j.description);
+  }
+}
+```
+
+> **Note:** `sendRichMessage` / `sendRichMessageDraft` map to your bot's rich-text
+> transport. If your bot has no rich endpoint, point them at plain `sendMessage`
+> and set `rich: false` — the kit then renders via HTML only.
+
+## How it works
+
+The kit is three layers plus one optional adapter. The dependency direction is
+strictly **Bridge → Draft → Formatting**; lower layers never import higher ones,
+and the core never imports the adapter.
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│  /deepagents  (optional subpath)                            │
+│  toAgentStream · streamAgent  →  AgentStream                │
+└─────────────────────────────────────────────────────────────┘
+┌─────────────────────────────────────────────────────────────┐
+│  Bridge       runTelegramTurn · sendReply · sendText        │
+│               + the four interfaces you implement           │
+└─────────────────────────────────────────────────────────────┘
+┌─────────────────────────────────────────────────────────────┐
+│  Draft        createDraftStreamer (throttle/keepalive/drain)│
+└─────────────────────────────────────────────────────────────┘
+┌─────────────────────────────────────────────────────────────┐
+│  Format       mdToTelegramHtml · chunk* · rich helpers      │
+│               pure, zero deps, browser-safe                 │
+└─────────────────────────────────────────────────────────────┘
+```
+
+**Transport vs. orchestration.** You provide *raw* Bot API primitives — one HTTP
+call each, no chunking, rendering, or fallback. The kit owns all orchestration over
+them: HTML rendering, chunking, the rich → classic and photo → text `400` fallbacks,
+and the trailing-cover photo flow.
+
+## The four interfaces
+
+You implement these; the kit drives them.
+
+| Interface      | Shape                                                                 | Role |
+| -------------- | --------------------------------------------------------------------- | ---- |
+| `BotClient`    | `sendMessage`, `sendRichMessage`, `sendPhoto`, `sendChatAction`, `sendMessageDraft`, `sendRichMessageDraft` | Raw transport. Each throws `TelegramApiError` on a Bot API error. |
+| `AgentStream`  | `(input, { threadId, signal }) => AsyncIterable<RenderEvent>`          | Your agent. `threadId` **must** reach it so the checkpointer writes to the snapshotted thread. |
+| `Checkpointer` | `{ snapshot(threadId), rollback(threadId, id) }`                       | Per-thread snapshot/rollback for clean recovery on a failed turn. |
+| `ThreadStore`  | `{ resolve(chatKey, now), touch(chatKey, now) }`                      | Maps `{ chatId, agentId }` to a thread id (so two bots over one chat id don't collide). |
+
+A `RenderEvent` is one of `token`, `tool_start`, `tool_end`, or `error`. The kit
+appends `token` text to the live draft and treats an `error` event as a rollback.
+
+## API reference
+
+### Core entry — `telegram-agent-kit`
+
+**Formatting** (pure, zero deps)
+
+- `mdToTelegramHtml(md, opts?)` — Markdown → Telegram-HTML. Never throws. `opts.partial`
+  auto-closes unclosed marks/fences for live drafts.
+- `chunkText(text)` / `safeSlice(text, max)` / `chunkRich(md)` — surrogate-safe splitting
+  (classic limit 4096, rich limit 32768).
+- `repairRichTables(md)` · `neutralizeRichMedia(md)` · `extractTrailingCover(reply)` — rich helpers.
+
+**Draft engine**
+
+- `createDraftStreamer(deps)` → `{ start(), push(fullText), finalize(), abort() }`.
+- `DEFAULT_DRAFT_CONSTANTS` / `DraftConstants` — overridable tunables (throttle, keepalive,
+  typing heartbeat, preview cap, drain, …).
+
+**Bridge**
+
+- `runTelegramTurn(opts)` — orchestrate one turn. Never throws out; every failure is caught and logged.
+- `sendReply(client, chatId, reply, opts, signal?)` / `sendText(...)` — the send path on its own.
+- Types: `BotClient`, `AgentStream`, `Checkpointer`, `ThreadStore`, `RenderEvent`, `ChatKey`, `Logger`.
+
+**Errors**
+
+- `TelegramApiError` — throw this from `BotClient` primitives (carries `error_code`).
+- `isBadRequest(err)` — true only for a deterministic `400` (rejected, safe to retry on a degraded path).
+
+### Optional entry — `telegram-agent-kit/deepagents`
+
+- `toAgentStream(agent)` → `AgentStream` — adapts a deepagents/langgraph agent to the kit's contract.
+- `streamAgent(agent, input, config, signal?)` — lower-level event stream if you need direct control.
+
+> `@langchain/core` and `deepagents` are **type-only, optional** peers. The built
+> `/deepagents` bundle contains no runtime import of either, so the core stays
+> dependency-free.
+
+## Design guarantees
+
+These are intentional and enforced by tests:
+
+- **`mdToTelegramHtml` is total** — it never throws on any LLM output. The send path
+  also wraps it and falls back to plain text as defence-in-depth.
+- **Deterministic `400` fallbacks** keyed off `isBadRequest`: rich → classic HTML →
+  plain text, and photo → text. Any non-`400` error always propagates.
+- **`runTelegramTurn` never throws out** — snapshot happens only after a turn isn't
+  skipped, rollback fires only on a real failure, and draft teardown is idempotent.
+- **Surrogate-safe splitting** — chunking never severs a UTF-16 surrogate pair.
+
+## Development
+
+```sh
+npm run build       # tsup → dist/ (ESM + .d.ts) for both entry points
+npm run typecheck   # tsc --noEmit
+npm test            # vitest run
+npm run lint        # biome check .
+npm run format      # biome format --write .
+```
+
+Run a single test:
+
+```sh
+npx vitest run test/format/md-to-html.test.ts     # one file
+npx vitest run -t "renders nested bold"           # by name
+```
+
+> Build before testing if you touch `/deepagents`: one test greps the built bundle
+> to prove it carries no runtime import of the optional peers (it skips when `dist/`
+> is absent). CI runs `build` before `test` for this reason.
+
+## Contributing
+
+Issues and pull requests are welcome. Before opening a PR, please run
+`npm run lint`, `npm run typecheck`, and `npm test` — and `npm run build` if your
+change touches the `/deepagents` entry. See [CHANGELOG.md](./CHANGELOG.md) for the
+project history.
+
+## License
+
+[MIT](./LICENSE) © Ivan Kalinichenko

package/dist/deepagents/index.d.ts

@@ -0,0 +1,20 @@
+import { R as RenderEvent, A as AgentStream } from '../interfaces-BRu3W_FZ.js';
+import { RunnableConfig } from '@langchain/core/runnables';
+import { createDeepAgent } from 'deepagents';
+
+type Agent$1 = ReturnType<typeof createDeepAgent>;
+type StreamAgentInput = {
+    messages: Array<{
+        role: 'user';
+        content: string;
+    }>;
+};
+declare function streamAgent(agent: Agent$1, input: StreamAgentInput, config: RunnableConfig, signal?: AbortSignal): AsyncIterable<RenderEvent>;
+
+type Agent = Parameters<typeof streamAgent>[0];
+/** Adapt a deepagents agent to the kit's runtime-agnostic AgentStream: build
+ *  the langgraph config from context.threadId, forward the signal. This is the
+ *  ONLY place the langgraph config shape lives. */
+declare function toAgentStream(agent: Agent): AgentStream;
+
+export { RenderEvent, type StreamAgentInput, streamAgent, toAgentStream };

package/dist/deepagents/index.js

@@ -0,0 +1,76 @@
+// src/deepagents/stream-agent.ts
+function extractText(content) {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    return content.filter(
+      (p) => typeof p === "object" && p !== null && p.type === "text" && typeof p.text === "string"
+    ).map((p) => p.text).join("");
+  }
+  return "";
+}
+function extractToolError(output) {
+  if (typeof output !== "object" || output === null) return void 0;
+  const o = output;
+  if (o.status !== "error") return void 0;
+  const c = o.content;
+  if (typeof c === "string") return c;
+  try {
+    return JSON.stringify(c);
+  } catch {
+    return String(c);
+  }
+}
+async function* streamAgent(agent, input, config, signal) {
+  const toolStart = /* @__PURE__ */ new Map();
+  const iter = agent.streamEvents(input, {
+    ...config,
+    signal,
+    version: "v2"
+  });
+  try {
+    for await (const ev of iter) {
+      if (ev.event === "on_chat_model_stream") {
+        if (ev.metadata?.langgraph_node !== "model_request") continue;
+        const text = extractText(ev.data?.chunk?.content);
+        if (text) yield { type: "token", text };
+      } else if (ev.event === "on_tool_start") {
+        toolStart.set(ev.run_id, Date.now());
+        yield {
+          type: "tool_start",
+          id: ev.run_id,
+          name: ev.name ?? "unknown",
+          args: ev.data?.input
+        };
+      } else if (ev.event === "on_tool_end" || ev.event === "on_tool_error") {
+        const startedAt = toolStart.get(ev.run_id) ?? Date.now();
+        toolStart.delete(ev.run_id);
+        const error = ev.event === "on_tool_error" ? ev.data?.error instanceof Error ? ev.data.error.message : String(ev.data?.error ?? "tool error") : extractToolError(ev.data?.output);
+        yield {
+          type: "tool_end",
+          id: ev.run_id,
+          durationMs: Date.now() - startedAt,
+          ...error !== void 0 ? { error } : {}
+        };
+      }
+    }
+  } catch (err) {
+    yield {
+      type: "error",
+      message: signal?.aborted ? "canceled" : err instanceof Error ? err.message : String(err)
+    };
+  }
+}
+
+// src/deepagents/to-agent-stream.ts
+function toAgentStream(agent) {
+  return (input, context) => streamAgent(
+    agent,
+    input,
+    { configurable: { thread_id: context.threadId } },
+    context.signal
+  );
+}
+export {
+  streamAgent,
+  toAgentStream
+};

package/dist/index.d.ts

@@ -0,0 +1,167 @@
+import { B as BotClient, L as Logger, C as ChatKey, A as AgentStream, a as Checkpointer, T as ThreadStore } from './interfaces-BRu3W_FZ.js';
+export { b as AgentStreamContext, R as RenderEvent, S as StreamInput } from './interfaces-BRu3W_FZ.js';
+
+type SendOpts = {
+    rich: boolean;
+    log: Logger;
+};
+/** Active reply path — rich when opts.rich, else classic. */
+declare function sendText(client: BotClient, chatId: number, text: string, opts: SendOpts, signal?: AbortSignal): Promise<void>;
+/** Final reply send for a completed turn (client.ts sendReply). */
+declare function sendReply(client: BotClient, chatId: number, reply: string, opts: SendOpts, signal?: AbortSignal): Promise<void>;
+
+/** DraftStreamer tunables — overridable via DraftStreamerDeps.constants.
+ *  Defaults mirror the machine-spirit values (the draft-streaming design
+ *  spec): native drafts tolerate frequent writes; the keepalive must beat the
+ *  ~30s draft-expiry window; the typing action must re-fire before its ~5s
+ *  lifetime lapses. */
+type DraftConstants = {
+    throttleMs: number;
+    keepaliveMs: number;
+    typingHeartbeatMs: number;
+    previewCap: number;
+    maxFailures: number;
+    drainMs: number;
+    tickMs: number;
+};
+declare const DEFAULT_DRAFT_CONSTANTS: DraftConstants;
+
+type IntervalHandle = ReturnType<typeof setInterval>;
+type DraftStreamerDeps = {
+    client: Pick<BotClient, 'sendMessageDraft' | 'sendRichMessageDraft' | 'sendChatAction'>;
+    chatId: number;
+    draftId: number;
+    rich: boolean;
+    log: Logger;
+    /** Override any subset of the draft tunables; defaults fill the rest. */
+    constants?: Partial<DraftConstants>;
+    now?: () => number;
+    schedule?: (fn: () => void, ms: number) => IntervalHandle;
+    cancel?: (h: IntervalHandle) => void;
+    delay?: (ms: number) => {
+        promise: Promise<void>;
+        cancel: () => void;
+    };
+};
+type DraftStreamer = {
+    start(): void;
+    push(fullText: string): void;
+    finalize(): Promise<void>;
+    abort(): Promise<void>;
+};
+declare function createDraftStreamer(deps: DraftStreamerDeps): DraftStreamer;
+
+type TurnContext = {
+    chatKey: ChatKey;
+    userText: string;
+};
+type RunTelegramTurnOpts = {
+    chatKey: ChatKey;
+    userText: string;
+    draftId: number;
+    rich: boolean;
+    client: BotClient;
+    agentStream: AgentStream;
+    checkpointer: Checkpointer;
+    threadStore: ThreadStore;
+    signal?: AbortSignal;
+    now?: () => number;
+    log?: Logger;
+    hooks?: {
+        preStream?: (ctx: TurnContext) => void | {
+            skip?: boolean;
+        } | Promise<void | {
+            skip?: boolean;
+        }>;
+        beforeTurn?: (ctx: TurnContext) => void | Promise<void>;
+        afterTurn?: (ctx: TurnContext) => void | Promise<void>;
+    };
+    makeDraftStreamer?: (deps: DraftStreamerDeps) => DraftStreamer;
+    draftConstants?: Partial<DraftConstants>;
+};
+declare function runTelegramTurn(opts: RunTelegramTurnOpts): Promise<void>;
+
+/** Thrown by BotClient transport primitives on a Bot API error. The
+ *  `error_code` is the Bot API numeric code; 400 is the deterministic
+ *  "rejected, not delivered" class the kit's fallbacks key off. */
+declare class TelegramApiError extends Error {
+    readonly error_code: number;
+    readonly description?: string | undefined;
+    constructor(error_code: number, description?: string | undefined);
+}
+/** True only for a deterministic 400 (rejected, not delivered) — safe to
+ *  retry on a degraded path without risking a double-send. */
+declare function isBadRequest(err: unknown): err is TelegramApiError;
+
+/** Split into ≤TELEGRAM_LIMIT UTF-16-code-unit chunks without severing a
+ *  surrogate pair. Prefers paragraph/line boundaries, hard-cuts otherwise. */
+declare function chunkText(text: string): string[];
+/** Surrogate-safe hard truncation to `max` UTF-16 code units. Mirrors the
+ *  high-surrogate guard in chunkText so a draft cap never severs a pair. */
+declare function safeSlice(text: string, max: number): string;
+/** Block-aware splitter for rich markdown. Most replies fit RICH_LIMIT in one
+ *  message; when they don't, split only on blank-line (paragraph) boundaries
+ *  so a table/list/quote is never cut. A single block over the limit is
+ *  hard-cut surrogate-safely (rare — see spec §9). */
+declare function chunkRich(md: string): string[];
+
+/** Markdown → Telegram-HTML renderer (channel-local). Tokenize-on-raw,
+ *  escape-at-emission, total (never throws). Deliberately NOT named
+ *  markdown.ts — src/runtime/markdown.ts owns that name in greps. Spec:
+ *  docs/superpowers/specs/2026-06-07-telegram-markdown-rendering-design.md */
+type MdToHtmlOpts = {
+    /** Draft mode: auto-close unclosed inline marks / fences at end of input. */
+    partial?: boolean;
+};
+declare function mdToTelegramHtml(md: string, opts?: MdToHtmlOpts): string;
+
+/** Re-absorb table rows the model detached with a blank line. A GFM table ends
+ *  at a blank line, so a reply that puts a summary/total row a blank line below
+ *  the body (observed live: `| Итого |` after `\n\n`, with cells that DID match
+ *  the header) turns that row into a standalone paragraph — Telegram's rich
+ *  renderer then prints it with literal pipes instead of inside the table. This
+ *  drops the separating blank line whenever a pipe-only paragraph (not itself a
+ *  new header+delimiter table) directly follows a table, rejoining the orphan;
+ *  it repeats so several stacked orphan rows all fold back in. Genuinely
+ *  separate tables (the next block has its own delimiter) and non-table content
+ *  are left untouched. Code regions are tracked and skipped — both fenced code
+ *  blocks (`` ``` `` / `~~~`) AND HTML `<pre>`/`<code>` regions: a blank-line-
+ *  split table inside one is a literal example, not an orphan, so it is left
+ *  verbatim (mirroring `neutralizeRichMedia`'s code-region skip — both run on
+ *  the same send path, so they must agree on what is literal code). Merge
+ *  eligibility of the preceding block is *tracked as it is emitted* (a table
+ *  emitted OUTSIDE any code region whose last line is still a table row), never
+ *  recomputed from its text — a table-shaped block that was code inside a region
+ *  still looks like a table once the region closes, so an outside orphan must not
+ *  fold into it, and a block that opens as a table but whose body contains
+ *  non-table prose (mid-body or trailing) is not eligible either (else the orphan
+ *  glues onto non-table content). Pure and total. */
+declare function repairRichTables(md: string): string;
+/** Extract a standalone cover image that is the LAST non-empty line of `md`:
+ *  the whole line is a single `![alt](http(s)://…)` token. Returns the URL plus
+ *  the body (the reply with that line removed, trailing whitespace trimmed).
+ *  Anything else — no image, an image mid-text, an inline image, a
+ *  non-HTTP(S)/angle-bracketed URL, or an image line inside an open code region —
+ *  returns null. Narrow by design: only a standalone trailing line triggers the
+ *  photo path, so non-media replies and inline URLs never fire it. */
+declare function extractTrailingCover(md: string): {
+    url: string;
+    body: string;
+} | null;
+/** Rewrite HTTP(S) media image syntax `![alt](url ["title"])` to a plain link
+ *  (bare URL when alt is empty) so a rich send never attempts a media block —
+ *  media needs send-rights and fails for non-parse reasons (§4.2). `tg://`
+ *  image syntax (custom emoji / date-time) is left untouched: it is an inline
+ *  entity, not a media send. Dropping only the `!` keeps any "title" intact.
+ *
+ *  Code regions are skipped: a fenced block (closed, or unterminated and thus
+ *  code through EOF), an inline code span, an HTML `<pre>`/`<code>` region
+ *  (Telegram's Rich HTML subset — fixed-width code, body is literal), or a
+ *  backslash-escaped `!` (only when preceded by an ODD run of backslashes — even
+ *  runs are literal `\` pairs and leave the `!` live) is literal to Telegram
+ *  (never a media send), so its `![](…)` must stay verbatim — neutralizing there
+ *  would corrupt a literal Markdown/code example for no benefit. Pure and
+ *  total. */
+declare function neutralizeRichMedia(md: string): string;
+
+export { AgentStream, BotClient, ChatKey, Checkpointer, DEFAULT_DRAFT_CONSTANTS, type DraftConstants, type DraftStreamer, type DraftStreamerDeps, Logger, type MdToHtmlOpts, type RunTelegramTurnOpts, TelegramApiError, ThreadStore, type TurnContext, chunkRich, chunkText, createDraftStreamer, extractTrailingCover, isBadRequest, mdToTelegramHtml, neutralizeRichMedia, repairRichTables, runTelegramTurn, safeSlice, sendReply, sendText };