wolli 0.0.3 → 0.0.5

package/built-in/plugins/telegram/index.ts

@@ -3,9 +3,10 @@
  *
  * This integration faces the network, holds the bot token, and emits a `message`
  * event per inbound Telegram message. It does not touch sessions or the agent; the
- * paired extension (`telegram-chat.ts`, declared under `wolli.extensions`) maps those
- * events into a chat loop and is resolved in place by the package manager. See
- * `INTEGRATION.md` for the transport-vs-mapping split.
+ * routing workflows (`telegram-chat.ts`, declared under `wolli.workflows`) map those
+ * events onto sessions and are resolved in place by the package manager. In-memory transport state that outlives a single call —
+ * the "typing…" keep-alive timers and the BotFather command menu — lives here, since
+ * workflow files hold no module state.
  *
  * Transport is grammY long polling (`@grammyjs/runner`'s `run`), so no public URL
  * or TLS is needed. The package brings its OWN grammy + @grammyjs/runner deps.
@@ -18,7 +19,7 @@
  * Onboarding asks for the BotFather token directly, verifies it with a live `getMe()`,
  * and stores the raw token in `~/.wolli/agents/<name>/integrations.json`:
  *
- *   { "telegram": { "default": { "botToken": "123456:ABC..." } } }
+ *   { "telegram": { "botToken": "123456:ABC..." } }
  *
  * `botToken` is still resolved on read, so a `$ENV` / `!cmd` reference placed there by
  * hand keeps working — onboarding just stores the literal token. `allowedChatIds` is an
@@ -36,15 +37,45 @@
  */
 
 import { run } from "@grammyjs/runner";
-// The integration types are host-provided via the loader's VIRTUAL_MODULES / aliases, so
-// @opsyhq/wolli is a peerDependency, not a dependency.
-import type { IntegrationOnboardContext, IntegrationsAPI } from "@opsyhq/wolli";
+// The integration surface is host-provided via the loader's VIRTUAL_MODULES / aliases, so
+// wolli is a peerDependency, not a dependency.
+import { defineIntegration, type IntegrationOnboardContext } from "wolli";
 import { Bot, GrammyError } from "grammy";
 import { Type } from "typebox";
 
 /** Telegram caps a single message at 4096 UTF-16 code units. */
 const TELEGRAM_MAX_LENGTH = 4096;
 
+/** Typing indicator refresh interval — Telegram clears the "typing…" state after a few seconds. */
+const TYPING_INTERVAL_MS = 4000;
+
+/** BotFather slash-command menu, registered at producer start. */
+const COMMANDS = [
+	{ command: "new", description: "Start a fresh session" },
+	{ command: "status", description: "Show the current session and model" },
+	{ command: "help", description: "List available commands" },
+];
+
+/**
+ * Live "typing…" keep-alive timers, keyed by chatId. Per-chat so parallel chats never
+ * stomp each other; cleared by `stopTyping` and by the producer's disposer on reload,
+ * so a reload can never orphan an interval.
+ */
+const typingTimers = new Map<number, ReturnType<typeof setInterval>>();
+
+function stopTypingTimer(chatId: number): void {
+	const timer = typingTimers.get(chatId);
+	if (timer) {
+		clearInterval(timer);
+		typingTimers.delete(chatId);
+	}
+}
+
+function clearAllTypingTimers(): void {
+	for (const timer of typingTimers.values()) clearInterval(timer);
+	typingTimers.clear();
+}
+
 /** BotFather walkthrough shown on the onboarding guide screen. */
 const ONBOARD_GUIDE = [
 	"## Connect Telegram",
@@ -160,152 +191,159 @@ async function onboard(ctx: IntegrationOnboardContext): Promise<{ botToken: stri
 	return { botToken: token };
 }
 
-export default function (wolli: IntegrationsAPI) {
-	wolli.registerIntegration({
-		name: "telegram",
-		account: Type.Object({
-			/** BotFather token. Onboarding stores it raw; a `$ENV`/`!cmd` reference also works. */
-			botToken: Type.String(),
-			/** Allowlist of chat ids. Empty/absent = allow all (logged as a warning). */
-			allowedChatIds: Type.Optional(Type.Array(Type.Number())),
-			/** Outbound formatting; `"plain"` disables parse mode. */
-			parseMode: Type.Optional(
-				Type.Union([Type.Literal("MarkdownV2"), Type.Literal("HTML"), Type.Literal("plain")]),
-			),
+export default defineIntegration({
+	account: Type.Object({
+		/** BotFather token. Onboarding stores it raw; a `$ENV`/`!cmd` reference also works. */
+		botToken: Type.String(),
+		/** Allowlist of chat ids. Empty/absent = allow all (logged as a warning). */
+		allowedChatIds: Type.Optional(Type.Array(Type.Number())),
+		/** Outbound formatting; `"plain"` disables parse mode. */
+		parseMode: Type.Optional(
+			Type.Union([Type.Literal("MarkdownV2"), Type.Literal("HTML"), Type.Literal("plain")]),
+		),
+	}),
+	events: {
+		message: Type.Object({
+			chatId: Type.Number(),
+			messageId: Type.Number(),
+			text: Type.String(),
+			from: Type.Object({
+				id: Type.Number(),
+				username: Type.Optional(Type.String()),
+				firstName: Type.Optional(Type.String()),
+			}),
+			chatType: Type.String(),
+			date: Type.Number(),
 		}),
-		events: {
-			message: Type.Object({
+	},
+	onboard,
+	actions: {
+		sendMessage: {
+			description: "Send a text message to a chat (chunked at 4096, with plain-text fallback).",
+			parameters: Type.Object({
 				chatId: Type.Number(),
-				messageId: Type.Number(),
 				text: Type.String(),
-				from: Type.Object({
-					id: Type.Number(),
-					username: Type.Optional(Type.String()),
-					firstName: Type.Optional(Type.String()),
-				}),
-				chatType: Type.String(),
-				date: Type.Number(),
+				replyToMessageId: Type.Optional(Type.Number()),
 			}),
-		},
-		onboard,
-		actions: {
-			sendMessage: {
-				description: "Send a text message to a chat (chunked at 4096, with plain-text fallback).",
-				parameters: Type.Object({
-					chatId: Type.Number(),
-					text: Type.String(),
-					replyToMessageId: Type.Optional(Type.Number()),
-				}),
-				execute: async (params, ctx) => {
-					const { chatId, text, replyToMessageId } = params as {
-						chatId: number;
-						text: string;
-						replyToMessageId?: number;
-					};
-					const account = ctx.account as TelegramAccount;
-					const parseMode = account.parseMode ?? "MarkdownV2";
-					const bot = getBot(account.botToken);
+			execute: async (params, ctx) => {
+				const { chatId, text, replyToMessageId } = params as {
+					chatId: number;
+					text: string;
+					replyToMessageId?: number;
+				};
+				const account = ctx.account as TelegramAccount;
+				const parseMode = account.parseMode ?? "MarkdownV2";
+				const bot = getBot(account.botToken);
 
-					const messageIds: number[] = [];
-					// Reply-to applies only to the first chunk; later chunks just continue.
-					let replyTo = replyToMessageId;
-					for (const chunk of chunkText(text)) {
-						messageIds.push(await sendChunk(bot, chatId, chunk, parseMode, replyTo));
-						replyTo = undefined;
-					}
-					return { messageIds };
-				},
+				const messageIds: number[] = [];
+				// Reply-to applies only to the first chunk; later chunks just continue.
+				let replyTo = replyToMessageId;
+				for (const chunk of chunkText(text)) {
+					messageIds.push(await sendChunk(bot, chatId, chunk, parseMode, replyTo));
+					replyTo = undefined;
+				}
+				return { messageIds };
 			},
-			sendChatAction: {
-				description: "Show a chat action (e.g. the 'typing…' indicator).",
-				parameters: Type.Object({
-					chatId: Type.Number(),
-					action: Type.String(),
-				}),
-				execute: async (params, ctx) => {
-					const { chatId, action } = params as { chatId: number; action: string };
-					const account = ctx.account as TelegramAccount;
-					const bot = getBot(account.botToken);
-					// grammY types `action` as a union; the runtime accepts any valid string.
-					await bot.api.sendChatAction(chatId, action as "typing");
-					return { ok: true };
-				},
+		},
+		startTyping: {
+			description: "Show the 'typing…' indicator in a chat and keep it alive on a timer until stopTyping.",
+			parameters: Type.Object({
+				chatId: Type.Number(),
+			}),
+			execute: async (params, ctx) => {
+				const { chatId } = params as { chatId: number };
+				const account = ctx.account as TelegramAccount;
+				const bot = getBot(account.botToken);
+				const send = () => {
+					void bot.api.sendChatAction(chatId, "typing").catch(() => {});
+				};
+				send(); // immediate first tick; Telegram would otherwise show nothing until the interval
+				stopTypingTimer(chatId); // replace any existing timer for this chat
+				typingTimers.set(chatId, setInterval(send, TYPING_INTERVAL_MS));
+				return { ok: true };
 			},
-			setCommands: {
-				description: "Register the bot's slash-command menu (BotFather command list).",
-				parameters: Type.Object({
-					commands: Type.Array(
-						Type.Object({
-							command: Type.String(),
-							description: Type.String(),
-						}),
-					),
-				}),
-				execute: async (params, ctx) => {
-					const { commands } = params as { commands: { command: string; description: string }[] };
-					const account = ctx.account as TelegramAccount;
-					const bot = getBot(account.botToken);
-					await bot.api.setMyCommands(commands);
-					return { ok: true };
-				},
+		},
+		stopTyping: {
+			description: "Stop the 'typing…' indicator in a chat.",
+			parameters: Type.Object({
+				chatId: Type.Number(),
+			}),
+			execute: async (params) => {
+				const { chatId } = params as { chatId: number };
+				stopTypingTimer(chatId);
+				return { ok: true };
 			},
 		},
-		run(ctx) {
-			const account = ctx.account as TelegramAccount;
-			const { botToken, allowedChatIds } = account;
-			const allowAll = !allowedChatIds || allowedChatIds.length === 0;
-			if (allowAll) {
-				console.warn("[telegram] no allowedChatIds configured — accepting messages from ANY chat.");
-			}
+	},
+	run(ctx) {
+		const account = ctx.account as TelegramAccount;
+		const { botToken, allowedChatIds } = account;
+		const allowAll = !allowedChatIds || allowedChatIds.length === 0;
+		if (allowAll) {
+			console.warn("[telegram] no allowedChatIds configured — accepting messages from ANY chat.");
+		}
 
-			const bot = getBot(botToken);
+		const bot = getBot(botToken);
 
-			bot.on("message:text", (c) => {
-				// Ignore our own messages and anything outside the allowlist.
-				if (c.from?.id === c.me.id) return;
-				const chatId = c.chat.id;
-				if (!allowAll && !allowedChatIds?.includes(chatId)) return;
+		// Register the BotFather slash-command menu — transport-level registration, re-run each
+		// reload. Fire-and-forget: a menu-registration failure must not block the poller.
+		void bot.api.setMyCommands(COMMANDS).catch((err) => {
+			console.error("[telegram] failed to register command menu:", err instanceof Error ? err.message : err);
+		});
 
-				ctx.emit("message", {
-					chatId,
-					messageId: c.msg.message_id,
-					text: c.msg.text,
-					from: {
-						id: c.from?.id ?? 0,
-						username: c.from?.username,
-						firstName: c.from?.first_name,
-					},
-					chatType: c.chat.type,
-					date: c.msg.date,
-				});
-			});
+		bot.on("message:text", (c) => {
+			// Ignore our own messages and anything outside the allowlist.
+			if (c.from?.id === c.me.id) return;
+			const chatId = c.chat.id;
+			if (!allowAll && !allowedChatIds?.includes(chatId)) return;
 
-			// Swallow producer-side errors so a transient poll failure can't crash the host.
-			bot.catch((err) => {
-				console.error("[telegram] bot error:", err.message);
+			ctx.emit("message", {
+				chatId,
+				messageId: c.msg.message_id,
+				text: c.msg.text,
+				from: {
+					id: c.from?.id ?? 0,
+					username: c.from?.username,
+					firstName: c.from?.first_name,
+				},
+				chatType: c.chat.type,
+				date: c.msg.date,
 			});
+		});
+
+		// Update-handler errors (middleware throwing while processing an inbound update) — log, don't rethrow.
+		bot.catch((err) => {
+			console.error("[telegram] bot error:", err.message);
+		});
 
-			// Fire-and-forget startup: drop any webhook + backlog, then start long polling.
-			// The runner never resolves, so we must NOT await it.
-			let runner: ReturnType<typeof run> | undefined;
-			void bot.api
-				.deleteWebhook({ drop_pending_updates: true })
-				.then(() => {
-					if (ctx.signal.aborted) return;
-					runner = run(bot);
-				})
-				.catch((err) => {
-					console.error("[telegram] failed to start long polling:", err instanceof Error ? err.message : err);
+		// Fire-and-forget startup: drop any webhook + backlog, then start long polling.
+		// The runner never resolves, so we must NOT await it.
+		let runner: ReturnType<typeof run> | undefined;
+		void bot.api
+			.deleteWebhook({ drop_pending_updates: true })
+			.then(() => {
+				if (ctx.signal.aborted) return;
+				runner = run(bot);
+				// A fatal getUpdates error (e.g. a 409 conflict from a poll overlap on reload) rejects the
+				// runner task. bot.catch does NOT cover the runner's fetch loop, so catch it here — otherwise
+				// the rejection is unhandled and crashes the whole daemon, not just the poller.
+				runner.task()?.catch((err) => {
+					console.error("[telegram] long polling stopped:", err instanceof Error ? err.message : err);
 				});
+			})
+			.catch((err) => {
+				console.error("[telegram] failed to start long polling:", err instanceof Error ? err.message : err);
+			});
 
-			// Belt and suspenders: stop the runner on abort and via the returned disposer.
-			// The stop-before-start swap on reload relies on this to avoid Telegram's 409
-			// ("two pollers on one token") conflict.
-			const dispose = () => {
-				if (runner?.isRunning()) void runner.stop();
-			};
-			ctx.signal.addEventListener("abort", dispose);
-			return dispose;
-		},
-	});
-}
+		// Belt and suspenders: stop the runner on abort and via the returned disposer.
+		// The stop-before-start swap on reload relies on this to avoid Telegram's 409
+		// ("two pollers on one token") conflict.
+		const dispose = () => {
+			// Clear typing timers here so a reload can never orphan an interval.
+			clearAllTypingTimers();
+			if (runner?.isRunning()) void runner.stop();
+		};
+		ctx.signal.addEventListener("abort", dispose);
+		return dispose;
+	},
+});

package/built-in/plugins/telegram/package.json

@@ -5,13 +5,13 @@
 	"type": "module",
 	"wolli": {
 		"integrations": ["./index.ts"],
-		"extensions": ["./telegram-chat.ts"]
+		"workflows": ["./telegram-chat.ts"]
 	},
 	"dependencies": {
 		"grammy": "1.44.0",
 		"@grammyjs/runner": "2.0.3"
 	},
 	"peerDependencies": {
-		"@opsyhq/wolli": "*"
+		"wolli": "*"
 	}
 }

package/built-in/plugins/telegram/telegram-chat.ts

@@ -1,169 +1,93 @@
 /**
- * Telegram chat extension — the mapping half (paired with `index.ts`).
- *
- * The integration (`index.ts`) is the transport (long-poll, token, `message` events);
- * this extension maps that transport onto a Wolli session:
- *
- *   - inbound:  `telegram.on("message")` routes the text into this chat's own session by
- *               `wolli.findSessions({ "telegram:chat": <id> })` → `openSession` the match (or
- *               `createSession` + tag a fresh one) → `session.sendUserMessage(text)`
- *   - outbound: `wolli.on("agent_end")` reads the PRODUCING session's tag off
- *               `ctx.session.getTags()` → final assistant text → `sendMessage`
- *   - typing:   `agent_start`/`agent_end` toggle the Telegram "typing…" indicator
- *   - commands: `/new`, `/status`, `/help` are handled here, not sent to the model
- *
- * Session binding via tags: each chat gets its OWN Wolli session, bound by a `{ "telegram:chat":
- * <id> }` tag. `findSessions` locates (and `createSession` lazily creates) the chat's session, so two
- * chats run in parallel and a reply returns to the chat that started the turn — located by any
- * extension with `wolli.findSessions({ "telegram:chat": <id> })`.
- *
- * This file is declared under the package's `wolli.extensions` and is resolved in place by the
- * package manager when the integration is onboarded
- * (`wolli <agent> plugins configure telegram`); it activates on the next launch.
+ * Telegram chat routing, as one workflows file:
+ *  - `inbound` binds each chat to its own session by a `telegram:chat` tag and delivers
+ *    inbound text as a followUp. Slash commands (`/new`, `/status`, `/help`) are handled
+ *    locally, before the session lookup, and never reach the model.
+ *  - `typing` starts the "typing…" indicator on `agent_start`; the integration owns the
+ *    keep-alive timer.
+ *  - `reply` ships the turn's final assistant text back on `agent_end`, riding the
+ *    producing session's `telegram:chat` tag; typing stops first so a pure tool-call turn
+ *    still clears the indicator.
  */
 
-import type { AgentMessage } from "@opsyhq/agent";
-import type { ExtensionAPI } from "@opsyhq/wolli";
-
-const TYPING_INTERVAL_MS = 4000;
-
-const COMMANDS = [
-	{ command: "new", description: "Start a fresh session" },
-	{ command: "status", description: "Show the current session and model" },
-	{ command: "help", description: "List available commands" },
-];
+import { type WorkflowContext, wolli } from "wolli";
+import telegram from "./index.ts";
 
 interface TelegramMessage {
 	chatId: number;
-	messageId: number;
 	text: string;
-	from: { id: number; username?: string; firstName?: string };
-	chatType: string;
-	date: number;
 }
 
-/** Concatenate the text blocks of the last assistant message; "" for a pure tool-call turn. */
-function finalAssistantText(messages: AgentMessage[]): string {
-	for (let i = messages.length - 1; i >= 0; i--) {
-		const m = messages[i];
-		if (m.role !== "assistant") continue;
-		return m.content
-			.filter((c): c is { type: "text"; text: string } => c.type === "text")
-			.map((c) => c.text)
-			.join("")
-			.trim();
-	}
-	return "";
-}
-
-export default function (wolli: ExtensionAPI) {
-	const tg = wolli.getIntegration("telegram", "default");
-
-	// Model id from the most recent turn, surfaced by /status.
-	let lastModel: string | undefined;
-	let typingTimer: ReturnType<typeof setInterval> | undefined;
-
-	const reply = async (chatId: number, text: string): Promise<void> => {
-		await tg.call("sendMessage", { chatId, text });
-	};
-
-	// Register the BotFather slash-command menu on startup.
-	void tg.call("setCommands", { commands: COMMANDS }).catch((err) => {
-		console.error("[telegram-chat] setCommands failed:", err instanceof Error ? err.message : err);
-	});
-
-	// Slash commands are handled locally instead of being sent to the model.
-	async function handleCommand(chatId: number, text: string): Promise<void> {
-		// Strip a leading "/" and an optional "@botname" suffix (groups append it).
-		const command = text.slice(1).split(/\s+/)[0].split("@")[0].toLowerCase();
-		switch (command) {
-			case "new": {
-				// A fresh session tagged with this chat becomes the newest match, so future messages
-				// route to it (the prior session stays addressable but is no longer the newest).
-				await wolli.createSession({
-					setup: async (sessionManager) => {
-						await sessionManager.appendTags({ "telegram:chat": String(chatId) });
-					},
-				});
-				await reply(chatId, "Started a fresh session.");
-				return;
-			}
-			case "status": {
-				const matches = await wolli.findSessions({ "telegram:chat": String(chatId) });
-				const name = (matches[0] && wolli.getSession(matches[0].id)?.getSessionName()) ?? "(unnamed)";
-				const model = lastModel ?? "(unknown until first reply)";
-				await reply(chatId, `Session: ${name}\nModel: ${model}`);
-				return;
-			}
-			case "help": {
-				const lines = COMMANDS.map((c) => `/${c.command} — ${c.description}`).join("\n");
-				await reply(chatId, `Commands:\n${lines}`);
-				return;
-			}
-			default:
-				await reply(chatId, `Unknown command: /${command}. Try /help.`);
-		}
-	}
-
-	tg.on("message", async (data) => {
-		const m = data as TelegramMessage;
-
-		if (m.text.startsWith("/")) {
-			await handleCommand(m.chatId, m.text);
+/** Slash commands are handled locally instead of being sent to the model. */
+async function handleCommand(msg: TelegramMessage, ctx: WorkflowContext): Promise<void> {
+	const tg = ctx.integration(telegram);
+	// Strip the leading "/" and an optional "@botname" suffix (groups append it).
+	const command = msg.text.slice(1).split(/\s+/)[0].split("@")[0].toLowerCase();
+	const chatTag = { "telegram:chat": String(msg.chatId) };
+	switch (command) {
+		case "new": {
+			// A fresh session tagged with this chat becomes the newest match, so future messages
+			// route to it (the prior session stays addressable but is no longer the newest).
+			await ctx.agent.createSession({ setup: (s) => s.appendTags(chatTag) });
+			await tg.sendMessage({ chatId: msg.chatId, text: "Started a fresh session." });
 			return;
 		}
-
-		// Route into this chat's own session: rehydrate the tag-bound one, or create + tag a fresh one.
-		const chatTag = { "telegram:chat": String(m.chatId) };
-		const [match] = await wolli.findSessions(chatTag);
-		const session = match
-			? await wolli.openSession(match.id)
-			: await wolli.createSession({
-					setup: async (sessionManager) => {
-						await sessionManager.appendTags(chatTag);
-					},
-				});
-
-		// followUp so a message arriving mid-stream queues cleanly instead of interrupting.
-		void session.sendUserMessage(m.text, { deliverAs: "followUp" });
-	});
-
-	// Typing indicator: kept alive on a timer while a turn runs (Telegram clears the
-	// "typing…" state after a few seconds, so it must be re-sent).
-	const stopTyping = (): void => {
-		if (typingTimer) {
-			clearInterval(typingTimer);
-			typingTimer = undefined;
+		case "status": {
+			const [match] = await ctx.agent.findSessions(chatTag);
+			const session = match ? await ctx.agent.openSession(match.id) : undefined;
+			const name = session?.getSessionName() ?? "(none yet)";
+			const model = session?.model?.id ?? "(none yet)";
+			await tg.sendMessage({ chatId: msg.chatId, text: `Session: ${name}\nModel: ${model}` });
+			return;
 		}
-	};
-
-	wolli.on("agent_start", async (_event, ctx) => {
-		const chat = ctx.session.getTags()["telegram:chat"];
-		if (!chat) return; // not a telegram-bound session
-		const chatId = Number(chat);
-		const sendTyping = () => {
-			void tg.call("sendChatAction", { chatId, action: "typing" }).catch(() => {});
-		};
-		sendTyping();
-		stopTyping();
-		typingTimer = setInterval(sendTyping, TYPING_INTERVAL_MS);
-	});
-
-	wolli.on("agent_end", async ({ messages }, ctx) => {
-		stopTyping();
-
-		const assistantMsgs = messages as AgentMessage[];
-		for (const m of assistantMsgs) {
-			if (m.role === "assistant") lastModel = m.model;
+		case "help": {
+			const lines = [
+				"/new — Start a fresh session",
+				"/status — Show the current session and model",
+				"/help — List available commands",
+			].join("\n");
+			await tg.sendMessage({ chatId: msg.chatId, text: `Commands:\n${lines}` });
+			return;
 		}
-
-		// Reply rides the producing session's binding, so the answer returns to the chat that
-		// started this turn — not whoever messaged last.
-		const chat = ctx.session.getTags()["telegram:chat"];
-		if (!chat) return; // not a telegram-bound session
-
-		const text = finalAssistantText(assistantMsgs);
-		if (!text) return; // pure tool-call turn — nothing to send
-		await reply(Number(chat), text);
-	});
+		default:
+			await tg.sendMessage({ chatId: msg.chatId, text: `Unknown command: /${command}. Try /help.` });
+	}
 }
+
+// msg is typed from the event schema
+export const inbound = telegram.on("message", async (msg, ctx) => {
+	if (msg.text.startsWith("/")) return handleCommand(msg, ctx);
+	const chatTag = { "telegram:chat": String(msg.chatId) };
+	const [match] = await ctx.agent.findSessions(chatTag);
+	const session = match
+		? await ctx.agent.openSession(match.id)
+		: await ctx.agent.createSession({
+				setup: (s) => s.appendTags(chatTag),
+			});
+	// followUp queues behind a running turn instead of interrupting it.
+	await session.sendUserMessage(msg.text, { deliverAs: "followUp" });
+});
+
+export const typing = wolli.on("agent_start", async (_evt, ctx) => {
+	const chat = ctx.session.getTags()["telegram:chat"];
+	if (!chat) return; // not a telegram-bound session
+	await ctx.integration(telegram).startTyping({ chatId: Number(chat) });
+});
+
+export const reply = wolli.on("agent_end", async (evt, ctx) => {
+	const chat = ctx.session.getTags()["telegram:chat"];
+	if (!chat) return; // not a telegram-bound session
+	const chatId = Number(chat);
+	// Stop the typing indicator before the empty-text early return, so a pure tool-call
+	// turn still clears it.
+	await ctx.integration(telegram).stopTyping({ chatId });
+	const text = evt.messages
+		.filter((m) => m.role === "assistant")
+		.at(-1)
+		?.content.filter((c) => c.type === "text")
+		.map((c) => c.text)
+		.join("")
+		.trim();
+	if (!text) return; // a pure tool-call turn sends nothing
+	await ctx.integration(telegram).sendMessage({ chatId, text });
+});