telegram-agent-kit 0.2.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/deepagents/index.d.ts

@@ -1,15 +1,9 @@
-import { R as RenderEvent, A as AgentStream } from '../interfaces-FQIM1SDq.js';
+import { S as StreamInput, R as RenderEvent, A as AgentStream } from '../interfaces-DhF4n199.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>;
+declare function streamAgent(agent: Agent$1, input: StreamInput, config: RunnableConfig, signal?: AbortSignal): AsyncIterable<RenderEvent>;
 
 type Agent = Parameters<typeof streamAgent>[0];
 /** Adapt a deepagents agent to the kit's runtime-agnostic AgentStream: merge the
@@ -19,4 +13,4 @@ type Agent = Parameters<typeof streamAgent>[0];
  *  the ONLY place the langgraph config shape lives. */
 declare function toAgentStream(agent: Agent): AgentStream;
 
-export { RenderEvent, type StreamAgentInput, streamAgent, toAgentStream };
+export { RenderEvent, StreamInput, streamAgent, toAgentStream };

package/dist/deepagents/index.js

@@ -8,20 +8,7 @@ function extractText(content) {
   }
   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,
@@ -33,24 +20,6 @@ async function* streamAgent(agent, input, config, signal) {
         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) {

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { B as BotClient, L as Logger, C as ChatKey, A as AgentStream, a as Checkpointer, T as ThreadStore } from './interfaces-FQIM1SDq.js';
-export { b as AgentStreamContext, R as RenderEvent, S as StreamInput } from './interfaces-FQIM1SDq.js';
+import { B as BotClient, L as Logger, C as ChatKey, A as AgentStream, a as Checkpointer, T as ThreadStore } from './interfaces-DhF4n199.js';
+export { b as AgentStreamContext, R as RenderEvent, S as StreamInput } from './interfaces-DhF4n199.js';
 
 type SendOpts = {
     rich: boolean;
@@ -76,9 +76,12 @@ type RunTelegramTurnOpts = {
         beforeTurn?: (ctx: TurnContext) => void | Promise<void>;
         afterTurn?: (ctx: TurnContext) => void | Promise<void>;
     };
-    makeDraftStreamer?: (deps: DraftStreamerDeps) => DraftStreamer;
     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

@@ -170,7 +170,7 @@ function renderLinks(text, autoClose) {
     rest = rest.slice(m.index + m.length);
   }
 }
-function renderCode(text, autoClose) {
+function renderInline(text, autoClose) {
   let out = "";
   let rest = text;
   for (; ; ) {
@@ -193,9 +193,6 @@ function renderCode(text, autoClose) {
     rest = rest.slice(close + 1);
   }
 }
-function renderInline(line, autoClose) {
-  return renderCode(line, autoClose);
-}
 var FENCE_OPEN_RE = /^(`{3,}|~{3,})\s*(.*)$/;
 var TICK_CLOSE_RE = /^`{3,}\s*$/;
 var TILDE_CLOSE_RE = /^~{3,}\s*$/;
@@ -691,7 +688,6 @@ var NOOP_LOG = { warn: () => {
 async function runTelegramTurn(opts) {
   const now = opts.now ?? (() => Date.now());
   const log = opts.log ?? NOOP_LOG;
-  const makeDraftStreamer = opts.makeDraftStreamer ?? createDraftStreamer;
   const ctx = { chatKey: opts.chatKey, userText: opts.userText };
   let rollback = null;
   let turnCompleted = false;
@@ -718,7 +714,7 @@ async function runTelegramTurn(opts) {
     const threadId = await opts.threadStore.resolve(opts.chatKey, now());
     const checkpointId = await opts.checkpointer.snapshot(threadId);
     rollback = { threadId, checkpointId };
-    draft = makeDraftStreamer({
+    draft = createDraftStreamer({
       client: opts.client,
       chatId: opts.chatKey.chatId,
       draftId: opts.draftId,
@@ -728,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 }
@@ -736,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/dist/{interfaces-FQIM1SDq.d.ts → interfaces-DhF4n199.d.ts}

@@ -5,7 +5,6 @@ type ChatKey = {
 type Logger = {
     warn(msg: string, data?: unknown): void;
     error(msg: string, data?: unknown): void;
-    info?(msg: string, data?: unknown): void;
 };
 /** Raw Bot API transport primitives — one HTTP call each, NO chunking /
  *  rendering / fallback (the kit owns those). Each throws TelegramApiError
@@ -44,16 +43,6 @@ type BotClient = {
 type RenderEvent = {
     type: 'token';
     text: string;
-} | {
-    type: 'tool_start';
-    id: string;
-    name: string;
-    args: unknown;
-} | {
-    type: 'tool_end';
-    id: string;
-    durationMs: number;
-    error?: string;
 } | {
     type: 'error';
     message: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "telegram-agent-kit",
-  "version": "0.2.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",