telegram-agent-kit 0.4.0 → 0.5.0

package/README.md

@@ -157,9 +157,12 @@ 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 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.
+A `RenderEvent` is one of `token`, `tool_start` or `error`. `token` text is appended to
+the live draft *and* to the reply that gets sent. `tool_start` shows a transient
+`🔧 \`name\`…` line under the draft so the user sees which tool is running instead of a
+frozen draft — it is cleared by the next token and **never** becomes part of the sent
+message. 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
 
@@ -189,6 +192,7 @@ the user in the chat instead of going silent.
   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.
+  `opts` is `{ rich: boolean, log: Logger }`, with the same `rich` semantics as above.
 - Types: `BotClient`, `AgentStream`, `Checkpointer`, `ThreadStore`, `RenderEvent`, `ChatKey`, `Logger`.
 
 **Errors**
@@ -204,6 +208,10 @@ the user in the chat instead of going silent.
   `__pregel_*` LangGraph internal-execution key — are stripped so the kit retains full control over
   checkpoint routing and execution.
 - `streamAgent(agent, input, config, signal?)` — lower-level event stream if you need direct control.
+  Yields tokens from the **root** agent only: a delegated agent (a `subagents` entry, or the built-in
+  `task` tool) runs its own model node and LangChain replays its events into the parent stream, so
+  without this its monologue would interleave with the reply. Naming the root agent does not change
+  what streams.
 
 > `@langchain/core` and `deepagents` are **type-only, optional** peers. The built
 > `/deepagents` bundle contains no runtime import of either, so the core stays

package/dist/deepagents/index.d.ts

@@ -1,4 +1,4 @@
-import { S as StreamInput, R as RenderEvent, A as AgentStream } from '../interfaces-DhF4n199.js';
+import { S as StreamInput, R as RenderEvent, A as AgentStream } from '../interfaces-BluM8MeB.js';
 import { RunnableConfig } from '@langchain/core/runnables';
 import { createDeepAgent } from 'deepagents';
 

package/dist/deepagents/index.js

@@ -1,4 +1,7 @@
 // src/deepagents/stream-agent.ts
+function isNested(ev) {
+  return ev.metadata?.checkpoint_ns?.includes("|") ?? false;
+}
 function extractText(content) {
   if (typeof content === "string") return content;
   if (Array.isArray(content)) {
@@ -18,8 +21,12 @@ async function* streamAgent(agent, input, config, signal) {
     for await (const ev of iter) {
       if (ev.event === "on_chat_model_stream") {
         if (ev.metadata?.langgraph_node !== "model_request") continue;
+        if (isNested(ev)) continue;
         const text = extractText(ev.data?.chunk?.content);
         if (text) yield { type: "token", text };
+      } else if (ev.event === "on_tool_start") {
+        if (isNested(ev)) continue;
+        yield { type: "tool_start", name: ev.name ?? "unknown" };
       }
     }
   } 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-DhF4n199.js';
-export { b as AgentStreamContext, R as RenderEvent, S as StreamInput } from './interfaces-DhF4n199.js';
+import { B as BotClient, L as Logger, C as ChatKey, A as AgentStream, a as Checkpointer, T as ThreadStore } from './interfaces-BluM8MeB.js';
+export { b as AgentStreamContext, R as RenderEvent, S as StreamInput } from './interfaces-BluM8MeB.js';
 
 type SendOpts = {
     rich: boolean;

package/dist/index.js

@@ -737,6 +737,7 @@ async function runTelegramTurn(opts) {
     });
     draft.start();
     let reply = "";
+    let status = "";
     let errorMessage;
     for await (const ev of opts.agentStream(
       { messages: [{ role: "user", content: opts.userText }] },
@@ -744,7 +745,13 @@ async function runTelegramTurn(opts) {
     )) {
       if (ev.type === "token") {
         reply += ev.text;
+        status = "";
         draft.push(reply);
+      } else if (ev.type === "tool_start") {
+        status = `\u{1F527} \`${ev.name}\`\u2026`;
+        draft.push(reply ? `${reply}
+
+${status}` : status);
       } else if (ev.type === "error") errorMessage = ev.message;
     }
     if (errorMessage !== void 0) {
@@ -771,6 +778,14 @@ async function runTelegramTurn(opts) {
     draftTornDown = true;
     await draft.finalize().catch(() => {
     });
+    if (status) {
+      await opts.client.sendMessageDraft(
+        { chatId: opts.chatKey.chatId, draftId: opts.draftId, text: reply },
+        opts.signal
+      ).catch(
+        (e) => log.warn("telegram draft status clear failed", { err: String(e) })
+      );
+    }
     turnCompleted = true;
     if (reply.trim().length > 0) {
       await sendReply(

package/dist/{interfaces-DhF4n199.d.ts → interfaces-BluM8MeB.d.ts}

@@ -43,6 +43,12 @@ type BotClient = {
 type RenderEvent = {
     type: 'token';
     text: string;
+}
+/** The agent started a tool call. Surfaced in the live draft as a transient
+ *  status line and NEVER folded into the reply — see runTelegramTurn. */
+ | {
+    type: 'tool_start';
+    name: string;
 } | {
     type: 'error';
     message: string;

package/package.json

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