telegram-agent-kit 0.3.0 → 0.3.1

package/README.md

@@ -151,8 +151,9 @@ You implement these; the kit drives them.
 | `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.
+A `RenderEvent` is either `token` or `error`: `token` text is appended to the live draft,
+an `error` rolls the turn back, logs the message, and — if you pass `errorNotice` — tells
+the user in the chat instead of going silent.
 
 ## API reference
 
@@ -177,6 +178,8 @@ appends `token` text to the live draft and treats an `error` event as a rollback
 - `runTelegramTurn(opts)` — orchestrate one turn. Never throws out; every failure is caught and logged.
   Accepts an optional `configurable` bag forwarded to your `AgentStream` as `context.configurable`,
   for passing per-turn data (e.g. `pendingImages`) to the agent without widening the core input type.
+  Pass `errorNotice` (plain text, your language) to have a failed turn say so in the chat —
+  omit it and the user just sees the draft stop, which reads as being ignored.
 - `sendReply(client, chatId, reply, opts, signal?)` / `sendText(...)` — the send path on its own.
 - Types: `BotClient`, `AgentStream`, `Checkpointer`, `ThreadStore`, `RenderEvent`, `ChatKey`, `Logger`.
 

package/dist/index.d.ts

@@ -78,6 +78,10 @@ type RunTelegramTurnOpts = {
     };
     draftConstants?: Partial<DraftConstants>;
     configurable?: Record<string, unknown>;
+    /** Plain-text line sent to the chat when the stream errors out (model chain
+     *  exhausted, graph threw). Without it the turn returns silently and the user
+     *  sees only a draft that stops moving — indistinguishable from being ignored. */
+    errorNotice?: string;
 };
 declare function runTelegramTurn(opts: RunTelegramTurnOpts): Promise<void>;
 

package/dist/index.js

@@ -724,7 +724,7 @@ async function runTelegramTurn(opts) {
     });
     draft.start();
     let reply = "";
-    let errored = false;
+    let errorMessage;
     for await (const ev of opts.agentStream(
       { messages: [{ role: "user", content: opts.userText }] },
       { threadId, signal: opts.signal, configurable: opts.configurable }
@@ -732,15 +732,27 @@ async function runTelegramTurn(opts) {
       if (ev.type === "token") {
         reply += ev.text;
         draft.push(reply);
-      } else if (ev.type === "error") errored = true;
+      } else if (ev.type === "error") errorMessage = ev.message;
     }
-    if (errored) {
+    if (errorMessage !== void 0) {
+      log.error("telegram turn errored", {
+        chatId: opts.chatKey.chatId,
+        err: errorMessage
+      });
       draftTornDown = true;
       await draft.abort().catch(() => {
       });
       await opts.checkpointer.rollback(rollback.threadId, rollback.checkpointId).catch(
         (e) => log.error("telegram rollback failed", { err: String(e) })
       );
+      if (opts.errorNotice && !opts.signal?.aborted) {
+        await opts.client.sendMessage(
+          { chatId: opts.chatKey.chatId, text: opts.errorNotice },
+          opts.signal
+        ).catch(
+          (e) => log.error("telegram error notice failed", { err: String(e) })
+        );
+      }
       return;
     }
     draftTornDown = true;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "telegram-agent-kit",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "description": "Render markdown to Telegram, stream agent replies into live drafts, and drive a snapshot/rollback turn-loop — runtime-agnostic.",
   "type": "module",
   "license": "MIT",