@segmentstream/agent 0.1.5 → 0.2.1

package/dist/extension/lib/telegram/inbound.mjs

@@ -6,8 +6,10 @@ __eveDirname(__filename);
 __eveCreateRequire(import.meta.url);
 import { telegramPrincipal } from "./principal.mjs";
 import { chatContext } from "./chats.mjs";
+import { attachmentsContext, stageFiles } from "./files.mjs";
 import { observedChatKey, observedContext } from "./observed.mjs";
-import { isAddressed, routeMessage } from "./router.mjs";
+import { addressingReason, routeMessage } from "./router.mjs";
+import { routingContext } from "./routing-context.mjs";
 import { messageAddress, scopedAddress } from "./sessions.mjs";
 import { voiceNote, voiceOf, voiceText } from "./voice.mjs";
 const UNKNOWN_PRIVATE = "Hi, I don't know you yet. Connect your Telegram account to the workspace and I'll act as you. The button works for ten minutes.";
@@ -38,6 +40,8 @@ function authorOf(user, member) {
 function observedMessage(message, text, member) {
 	return {
 		author: authorOf(message.from, member),
+		authorId: message.from.id,
+		...message.from.username === void 0 ? {} : { username: message.from.username },
 		text,
 		at: sentAt(message)
 	};
@@ -158,7 +162,7 @@ async function handleInboundMessage(input) {
 		from: message.from
 	};
 	const bot = await dependencies.bot(context.telegram);
-	const addressed = isAddressed(sent, bot);
+	const addressed = addressingReason(sent, bot);
 	const lookup = await dependencies.identities.lookup({
 		provider: "telegram",
 		externalId: sent.from.id
@@ -171,7 +175,7 @@ async function handleInboundMessage(input) {
 	}) : void 0;
 	if (report !== void 0) input.request?.waitUntil?.(report);
 	if (lookup.status !== "paired") {
-		if (addressed) await answerUnpaired({
+		if (addressed !== void 0) await answerUnpaired({
 			context,
 			message: sent,
 			lookup,
@@ -186,7 +190,7 @@ async function handleInboundMessage(input) {
 	const caption = sent.text || sent.caption;
 	const notes = [];
 	let text = caption;
-	if (voice !== void 0 && (addressed || dependencies.policy === "smart")) {
+	if (voice !== void 0 && (addressed !== void 0 || dependencies.policy === "smart")) {
 		const spoken = await voiceText({
 			voice,
 			model: dependencies.sttModel,
@@ -202,14 +206,25 @@ async function handleInboundMessage(input) {
 		...sent.messageThreadId === void 0 ? {} : { messageThreadId: sent.messageThreadId }
 	});
 	if (await routeMessage({
+		chatId: sent.chat.id,
+		memberId: lookup.member.id,
 		policy: dependencies.policy,
 		addressed,
 		decide: dependencies.decide,
-		question: async () => ({
-			agent: await input.request?.agentDescription() ?? "",
-			observed: dependencies.observed.list(chat),
-			message: observedMessage(sent, text, lookup.member)
-		})
+		question: async () => {
+			const recent = await routingContext({
+				address,
+				operations,
+				read: dependencies.readHistory,
+				remembered: dependencies.observed.recent(chat),
+				at: sentAt(sent)
+			});
+			return {
+				agent: await input.request?.agentDescription() ?? "",
+				recent,
+				message: observedMessage(sent, text, lookup.member)
+			};
+		}
 	}) === "observe") {
 		dependencies.observed.add(chat, observedMessage(sent, text === "" ? "[attachment]" : text, lookup.member));
 		return null;
@@ -222,11 +237,19 @@ async function handleInboundMessage(input) {
 			address,
 			operations,
 			...newest === void 0 ? {} : { activeAt: Date.parse(newest.at) || 0 }
-		}) === "cleared") dependencies.observed.take(chat);
+		}) === "cleared") dependencies.observed.clear(chat);
 		dependencies.sessionPolicy.delivered(address);
 	}
 	await context.telegram.startTyping();
+	const files = sent.attachments.length === 0 || dependencies.attachments === void 0 || input.request === void 0 ? new Map() : await stageFiles({
+		message: sent,
+		memberId: lookup.member.id,
+		attachments: dependencies.attachments,
+		download: dependencies.download
+	});
+	if (input.request !== void 0 && files.size > 0) input.request.files = files;
 	await report;
+	dependencies.observed.remember(chat, observedMessage(sent, text, lookup.member));
 	return {
 		auth: telegramPrincipal({
 			message: sent,
@@ -240,6 +263,10 @@ async function handleInboundMessage(input) {
 				member: lookup.member,
 				bot
 			}),
+			...attachmentsContext({
+				files,
+				group
+			}),
 			...notes
 		]
 	};

package/dist/extension/lib/telegram/observed.d.ts

@@ -1,7 +1,7 @@
 /**
- * The bounded ring of group messages the router observed without answering. The router shows it to
- * the decision model, and a reply carries it into the turn as context, so the agent knows what the
- * chat was talking about.
+ * Bounded group conversation context for routing, and the backlog observed without answering.
+ * A reply drains only the backlog: recent member messages and the agent's own replies remain
+ * available to decide whether a later unaddressed message answers one of the agent's questions.
  *
  * eve's `defineState` would be the durable home, but it is session state and needs an active eve
  * context; an observed message has neither, because observing must not start a session. The ring
@@ -15,14 +15,40 @@ export interface ObservedMessage {
     readonly text: string;
     /** ISO time the message was sent. */
     readonly at: string;
+    /** Stable Telegram identity, independent of changes to the member's display name or roles. */
+    readonly authorId?: string;
+    readonly username?: string;
 }
+export interface MessageRecipient {
+    readonly author: string;
+    readonly id?: string;
+    readonly username?: string;
+}
+export interface AgentMessage extends ObservedMessage {
+    readonly role: "agent";
+    /** Explicit @mentions take precedence over the member whose turn produced the reply. */
+    readonly addressedTo: ReadonlyArray<MessageRecipient>;
+    readonly inReplyTo?: MessageRecipient;
+}
+export type RecentMessage = ObservedMessage | AgentMessage;
 export interface ObservedMessages {
     add(chat: string, message: ObservedMessage): void;
+    /** Records a received message that starts a turn, or a successfully delivered agent reply. */
+    remember(chat: string, message: RecentMessage): void;
     list(chat: string): ReadonlyArray<ObservedMessage>;
+    recent(chat: string): ReadonlyArray<RecentMessage>;
     /** Returns and forgets the chat's ring, once a reply has carried it into a turn. */
     take(chat: string): ReadonlyArray<ObservedMessage>;
+    /** An idle reset forgets both the backlog and the earlier conversation. */
+    clear(chat: string): void;
 }
 export declare function observedMessages(capacity?: number): ObservedMessages;
+/** Recipient metadata for an agent reply; explicit mentions are visible even in proactive turns. */
+export declare function agentMessage(input: {
+    readonly text: string;
+    readonly at: string;
+    readonly inReplyTo?: MessageRecipient;
+}): AgentMessage;
 /** The key of a chat's ring: the chat and, in a forum, the topic. */
 export declare function observedChatKey(input: {
     readonly chatId: string;

package/dist/extension/lib/telegram/observed.mjs

@@ -9,29 +9,63 @@ const MAXIMUM_CHATS = 500;
 const MAXIMUM_TEXT_LENGTH = 1e3;
 function observedMessages(capacity = 30) {
 	const chats = new Map();
+	function remember(chat, message, observe) {
+		const previous = chats.get(chat);
+		const bounded = {
+			...message,
+			text: message.text.slice(0, MAXIMUM_TEXT_LENGTH)
+		};
+		const backlog = previous?.observed ?? [];
+		chats.delete(chat);
+		chats.set(chat, {
+			observed: observe ? [...backlog, bounded].slice(-capacity) : backlog,
+			recent: [...previous?.recent ?? [], bounded].slice(-capacity)
+		});
+		if (chats.size > MAXIMUM_CHATS) {
+			const oldest = chats.keys().next();
+			if (oldest.done !== true) chats.delete(oldest.value);
+		}
+	}
 	return {
 		add(chat, message) {
-			const ring = [...chats.get(chat) ?? [], {
-				...message,
-				text: message.text.slice(0, MAXIMUM_TEXT_LENGTH)
-			}];
-			chats.delete(chat);
-			chats.set(chat, ring.slice(-capacity));
-			if (chats.size > MAXIMUM_CHATS) {
-				const oldest = chats.keys().next();
-				if (oldest.done !== true) chats.delete(oldest.value);
-			}
+			remember(chat, message, true);
+		},
+		remember(chat, message) {
+			remember(chat, message, false);
 		},
 		list(chat) {
-			return chats.get(chat) ?? [];
+			return chats.get(chat)?.observed ?? [];
+		},
+		recent(chat) {
+			return chats.get(chat)?.recent ?? [];
 		},
 		take(chat) {
-			const ring = chats.get(chat) ?? [];
+			const previous = chats.get(chat);
+			if (previous !== void 0) chats.set(chat, {
+				...previous,
+				observed: []
+			});
+			return previous?.observed ?? [];
+		},
+		clear(chat) {
 			chats.delete(chat);
-			return ring;
 		}
 	};
 }
+function agentMessage(input) {
+	const usernames = Array.from(input.text.matchAll(/(?:^|[^A-Za-z0-9_])@([A-Za-z0-9_]+)/gu), (match) => match[1] ?? "");
+	const addressedTo = usernames.length > 0 ? [...new Set(usernames)].map((username) => ({
+		author: `@${username}`,
+		username
+	})) : input.inReplyTo === void 0 ? [] : [input.inReplyTo];
+	return {
+		...input,
+		text: input.text.slice(0, MAXIMUM_TEXT_LENGTH),
+		author: "the agent",
+		role: "agent",
+		addressedTo
+	};
+}
 function observedChatKey(input) {
 	return input.messageThreadId === void 0 ? input.chatId : `${input.chatId}:${input.messageThreadId}`;
 }
@@ -44,4 +78,4 @@ function observedContext(messages) {
 		"</observed_messages>"
 	].join("\n")];
 }
-export { OBSERVED_MESSAGES, observedChatKey, observedContext, observedMessages };
+export { OBSERVED_MESSAGES, agentMessage, observedChatKey, observedContext, observedMessages };

package/dist/extension/lib/telegram/proxy-fetch.mjs

@@ -53,13 +53,14 @@ function hasNullBody(status) {
 function telegramProxyFetch(proxy) {
 	return async (input, init) => {
 		const route = telegramProxyRoute(requestUrl(input));
-		const reply = await proxy.request({
+		const call = {
 			api: route.api,
 			method: proxyMethod(init?.method),
 			path: route.path,
 			headers: headerPairs(init?.headers),
 			body: await bodyBytes(init?.body)
-		});
+		};
+		const reply = route.api === "file" ? await proxy.download(call) : await proxy.request(call);
 		return new Response(hasNullBody(reply.status) ? null : Buffer.from(reply.body), {
 			status: reply.status,
 			headers: reply.headers.map(([name, value]) => [name, value])

package/dist/extension/lib/telegram/router.d.ts

@@ -1,6 +1,6 @@
 import type { TelegramMessage } from "eve/channels/telegram";
 import type { TelegramPolicy } from "../../config.js";
-import type { ObservedMessage } from "./observed.js";
+import type { ObservedMessage, RecentMessage } from "./observed.js";
 /**
  * The inbound router (`agent-design.md`, section 4): every message from a paired member is either
  * answered or observed before eve starts a turn. A private chat, a mention, a reply to the bot and
@@ -8,18 +8,22 @@ import type { ObservedMessage } from "./observed.js";
  * policy, put to one decision on the decision model.
  */
 export type Route = "observe" | "reply";
+export type AddressingReason = "private" | "mention" | "reply-to-bot" | "command";
 /** The bot, as Telegram's `getMe` describes it. Unknown when `getMe` failed. */
 export interface BotIdentity {
     readonly id: string;
     readonly username: string | undefined;
 }
+/** Why the message is for the bot without asking any model. */
+export declare function addressingReason(message: TelegramMessage, bot: BotIdentity | undefined): AddressingReason | undefined;
 /** Whether the message is for the bot without asking any model. */
 export declare function isAddressed(message: TelegramMessage, bot: BotIdentity | undefined): boolean;
 /** What the decision model sees. */
 export interface RouteQuestion {
     /** The agent's own description, so the model knows what it can be asked for. */
     readonly agent: string;
-    readonly observed: ReadonlyArray<ObservedMessage>;
+    /** Recent received messages and delivered agent replies, oldest first. */
+    readonly recent: ReadonlyArray<RecentMessage>;
     readonly message: ObservedMessage;
 }
 /** Decides whether a group message not addressed to the bot is still for it. */
@@ -51,6 +55,8 @@ export type DecideFunction = (options: {
         };
     };
 }>;
+/** An unthreaded answer minutes later may continue a question, but old questions are not hints. */
+export declare const FOLLOW_UP_WINDOW_MS: number;
 /** A {@link RouteDecider} that asks one `decide` question on the configured decision model. */
 export declare function decisionRouter(input: {
     readonly decide: DecideFunction;
@@ -61,8 +67,10 @@ export declare function decisionRouter(input: {
  * mistake in a group chat.
  */
 export declare function routeMessage(input: {
+    readonly chatId: string;
+    readonly memberId: string;
     readonly policy: TelegramPolicy;
-    readonly addressed: boolean;
+    readonly addressed: AddressingReason | undefined;
     /** Builds the question only when a decision is needed: it reads the agent's description. */
     readonly question: () => Promise<RouteQuestion>;
     readonly decide: RouteDecider;

package/dist/extension/lib/telegram/router.mjs

@@ -22,43 +22,119 @@ function repliesToBot(message, bot) {
 	if (author === void 0) return false;
 	return bot !== void 0 && author.id === bot.id;
 }
-function isAddressed(message, bot) {
+function addressingReason(message, bot) {
 	const text = message.text || message.caption;
-	return message.chat.type === "private" || isCommand(text, bot) || mentions(text, bot) || repliesToBot(message, bot);
+	if (message.chat.type === "private") return "private";
+	if (isCommand(text, bot)) return "command";
+	if (mentions(text, bot)) return "mention";
+	return repliesToBot(message, bot) ? "reply-to-bot" : void 0;
+}
+function isAddressed(message, bot) {
+	return addressingReason(message, bot) !== void 0;
 }
 const DECISION_TIMEOUT_MS = 15e3;
+const FOLLOW_UP_WINDOW_MS = 18e5;
+function isAgentMessage(message) {
+	return "role" in message && message.role === "agent";
+}
+function recipientLine(recipient) {
+	const identity = [...recipient.id === void 0 ? [] : [`user_id ${recipient.id}`], ...recipient.username === void 0 || recipient.author === `@${recipient.username}` ? [] : [`@${recipient.username}`]];
+	return identity.length === 0 ? recipient.author : `${recipient.author} (${identity.join(", ")})`;
+}
 function line(message) {
-	return `${message.author}: ${message.text}`;
+	if (isAgentMessage(message)) {
+		const addressedTo = message.addressedTo.map(recipientLine).join(", ");
+		const replyingTo = message.inReplyTo === void 0 ? void 0 : recipientLine(message.inReplyTo);
+		const recipients = addressedTo === "" ? "recipient unspecified" : `addressed to ${addressedTo}`;
+		const reply = replyingTo === void 0 ? "" : `; responding to ${replyingTo}`;
+		return `[${message.at}] THE AGENT (${recipients}${reply}): ${message.text}`;
+	}
+	const author = recipientLine({
+		author: message.author,
+		...message.authorId === void 0 ? {} : { id: message.authorId },
+		...message.username === void 0 ? {} : { username: message.username }
+	});
+	return `[${message.at}] ${author}: ${message.text}`;
+}
+function recentlyAddressed(message, sender) {
+	return message.addressedTo.some((recipient) => recipient.id !== void 0 ? recipient.id === sender.authorId : recipient.username !== void 0 && sender.username !== void 0 && recipient.username.toLowerCase() === sender.username.toLowerCase());
 }
 function decisionRouter(input) {
 	return async (question) => {
+		const sentAt = Date.parse(question.message.at);
+		const recent = question.recent.filter((message) => {
+			if (!isAgentMessage(message)) return true;
+			const age = sentAt - Date.parse(message.at);
+			return age >= 0 && age <= 18e5;
+		});
+		const followUps = recent.filter((message) => isAgentMessage(message) && recentlyAddressed(message, question.message));
+		const abortSignal = AbortSignal.timeout(DECISION_TIMEOUT_MS);
 		return (await input.decide({
 			model: input.model,
 			state: {
 				agent: question.agent,
-				recent_messages: question.observed.map(line),
+				recent_messages: recent.map(line),
+				possible_follow_up_to: followUps.map(line),
 				message: line(question.message)
 			},
 			questions: { route: {
 				type: "choice",
-				instructions: "A group chat message arrived that does not mention the agent. Decide whether the agent should answer it, given what the agent does and what the chat was talking about.",
+				instructions: "A group chat message arrived that does not mention the agent. Decide whether the agent should answer it, given what the agent does and the recent conversation. THE AGENT marks the agent's own messages; recipient metadata identifies who it addressed or replied to. possible_follow_up_to lists agent messages addressed to this sender within 30 minutes. Check whether the message answers or follows up on an open question the agent asked, including numbered questions, short confirmations, corrections, and where to find data. Such answers should receive a reply without a mention or Telegram reply. Consider explicit recipients in the text; a matching sender or recent message alone does not make unrelated chatter a follow-up.",
 				criteria: {
-					observe: "The message is people talking among themselves, or nothing the agent can help with.",
-					reply: "The message asks the agent, or asks for something the agent does, even without naming it."
+					observe: "The message is unrelated chatter or people talking among themselves, and does not answer or follow up on an open question the agent asked.",
+					reply: "The message asks the agent, asks for something the agent does, or answers or follows up on an open question the agent asked, even without naming or replying to it."
 				}
 			} },
-			abortSignal: AbortSignal.timeout(DECISION_TIMEOUT_MS)
+			abortSignal
+		}).catch((error) => {
+			if (abortSignal.aborted) throw new RoutingTimeoutError(error);
+			throw error;
 		})).answers.route.choice;
 	};
 }
+var RoutingTimeoutError = class extends Error {
+	constructor(cause) {
+		super("Telegram routing decision timed out after 15 seconds.", { cause });
+		this.name = "TimeoutError";
+	}
+};
 async function routeMessage(input) {
-	if (input.addressed) return "reply";
-	if (input.policy === "mention") return "observe";
+	const identity = {
+		chatId: input.chatId,
+		memberId: input.memberId
+	};
+	if (input.addressed !== void 0) {
+		console.info("[segmentstream] telegram route", {
+			...identity,
+			route: "reply",
+			reason: input.addressed
+		});
+		return "reply";
+	}
+	if (input.policy === "mention") {
+		console.info("[segmentstream] telegram route", {
+			...identity,
+			route: "observe",
+			reason: "mention-policy"
+		});
+		return "observe";
+	}
 	try {
-		return await input.decide(await input.question());
+		const route = await input.decide(await input.question());
+		console.info("[segmentstream] telegram route", {
+			...identity,
+			route,
+			reason: "decision-model"
+		});
+		return route;
 	} catch (error) {
-		console.error("[segmentstream] inbound routing decision failed; observing the message", { error });
+		console.error("[segmentstream] telegram route", {
+			...identity,
+			route: "observe",
+			reason: error instanceof Error && error.name === "TimeoutError" ? "decision-timeout" : "decision-failure",
+			error
+		});
 		return "observe";
 	}
 }
-export { decisionRouter, isAddressed, routeMessage };
+export { FOLLOW_UP_WINDOW_MS, addressingReason, decisionRouter, isAddressed, routeMessage };

package/dist/extension/lib/telegram/routing-context.d.ts

@@ -0,0 +1,13 @@
+import { type RecentMessage } from "./observed.js";
+import type { HistoryReader, SessionOperations } from "./sessions.js";
+/**
+ * Recover the agent's questions from the existing session without starting a turn. The local
+ * ring supplements this with recipient identities and chatter not written to Eve's stream.
+ */
+export declare function routingContext(input: {
+    readonly address: string;
+    readonly operations: SessionOperations | undefined;
+    readonly read: HistoryReader;
+    readonly remembered: ReadonlyArray<RecentMessage>;
+    readonly at: string;
+}): Promise<ReadonlyArray<RecentMessage>>;

package/dist/extension/lib/telegram/routing-context.mjs

@@ -0,0 +1,40 @@
+import { fileURLToPath as __eveFileURLToPath } from "node:url";
+import { dirname as __eveDirname } from "node:path";
+import { createRequire as __eveCreateRequire } from "node:module";
+const __filename = __eveFileURLToPath(import.meta.url);
+__eveDirname(__filename);
+__eveCreateRequire(import.meta.url);
+import { agentMessage } from "./observed.mjs";
+import "./router.mjs";
+import { isSilentReply } from "./silent.mjs";
+const DELIVERY_CLOCK_TOLERANCE_MS = 6e4;
+async function routingContext(input) {
+	if (input.operations === void 0) return input.remembered;
+	try {
+		const session = await input.operations.resolveSession(input.address);
+		if (session === void 0) return input.remembered;
+		const events = await input.read(session.id);
+		const sentAt = Date.parse(input.at);
+		const recovered = [];
+		let resetAt = 0;
+		for (const event of events) {
+			if (event.type === "context.cleared" || event.type === "session.started") {
+				recovered.length = 0;
+				resetAt = Date.parse(event.meta.at);
+			}
+			const age = sentAt - Date.parse(event.meta.at);
+			const data = event.data;
+			if (event.type === "message.completed" && data !== void 0 && data.finishReason !== "tool-calls" && data.message.trim() !== "" && !isSilentReply(data.message) && age >= 0 && age <= 18e5) recovered.push(agentMessage({
+				text: data.message,
+				at: event.meta.at
+			}));
+		}
+		const remembered = input.remembered.filter((message) => Date.parse(message.at) >= resetAt);
+		const knownReplies = remembered.filter((message) => "role" in message);
+		return [...recovered.filter((message) => !knownReplies.some((known) => known.text === message.text && Math.abs(Date.parse(known.at) - Date.parse(message.at)) <= DELIVERY_CLOCK_TOLERANCE_MS)), ...remembered].sort((first, second) => Date.parse(first.at) - Date.parse(second.at)).slice(-30);
+	} catch (error) {
+		console.warn("[segmentstream] routing context could not read the session; using recent messages", { error });
+		return input.remembered;
+	}
+}
+export { routingContext };

package/dist/extension/lib/telegram/sessions.d.ts

@@ -43,6 +43,11 @@ export interface RecordedEvent {
     readonly meta: {
         readonly at: string;
     };
+    /** Visible assistant message content, also used to recover smart-routing context. */
+    readonly data?: {
+        readonly message: string;
+        readonly finishReason: string;
+    };
 }
 /** The last events of a session, oldest first. Production reads eve's durable stream. */
 export type HistoryReader = (sessionId: string) => Promise<ReadonlyArray<RecordedEvent>>;

package/dist/extension/lib/telegram/silent.d.ts

@@ -1,9 +1,11 @@
 import type { TelegramChannelEvents } from "eve/channels/telegram";
+import { type ObservedMessages } from "./observed.js";
 export declare function isSilentReply(text: string): boolean;
 type MessageCompleted = NonNullable<TelegramChannelEvents["message.completed"]>;
 /**
  * The channel's `message.completed` handler: eve's default delivery (plain text through
  * `sendMessage`, nothing for a tool-call step) unless the reply is a silence marker.
  */
+export declare function replyDelivery(observed?: ObservedMessages): MessageCompleted;
 export declare const deliverUnlessSilent: MessageCompleted;
 export {};

package/dist/extension/lib/telegram/silent.mjs

@@ -4,12 +4,37 @@ import { createRequire as __eveCreateRequire } from "node:module";
 const __filename = __eveFileURLToPath(import.meta.url);
 __eveDirname(__filename);
 __eveCreateRequire(import.meta.url);
+import "./principal.mjs";
+import { agentMessage, observedChatKey } from "./observed.mjs";
 const SILENT_MARKERS = new Set(["[silent]", "no_reply"]);
 function isSilentReply(text) {
 	return SILENT_MARKERS.has(text.trim().toLowerCase());
 }
-const deliverUnlessSilent = async (event, channel) => {
-	if (event.finishReason === "tool-calls" || !event.message || isSilentReply(event.message)) return;
-	await channel.telegram.post(event.message);
-};
-export { deliverUnlessSilent, isSilentReply };
+function replyDelivery(observed) {
+	return async (event, channel, context) => {
+		if (event.finishReason === "tool-calls" || !event.message || isSilentReply(event.message)) return;
+		await channel.telegram.post(event.message);
+		if (observed === void 0 || channel.telegram.chatType === "private") return;
+		const principal = context.session.auth.current;
+		const sender = principal?.authenticator === "segmentstream-telegram" ? principal.subject : void 0;
+		const username = principal?.attributes.username;
+		const name = principal?.attributes.memberName;
+		const author = typeof name === "string" ? name : typeof username === "string" ? `@${username}` : sender;
+		const inReplyTo = sender === void 0 || author === void 0 ? void 0 : {
+			id: sender,
+			author,
+			...typeof username === "string" ? { username } : {}
+		};
+		const chat = observedChatKey({
+			chatId: channel.telegram.chatId,
+			...channel.telegram.messageThreadId === void 0 ? {} : { messageThreadId: channel.telegram.messageThreadId }
+		});
+		observed.remember(chat, agentMessage({
+			text: event.message,
+			at: new Date().toISOString(),
+			...inReplyTo === void 0 ? {} : { inReplyTo }
+		}));
+	};
+}
+const deliverUnlessSilent = replyDelivery();
+export { deliverUnlessSilent, isSilentReply, replyDelivery };

package/dist/extension/lib/telegram/turn-errors.d.ts

@@ -0,0 +1,9 @@
+import type { TelegramChannelEvents, TelegramChannelState } from "eve/channels/telegram";
+import type { SessionContext } from "eve/context";
+/** The adapter callback shape; Eve's public channel handler is wrapped inside this callback. */
+export type TurnFailedHandler = (event: Parameters<NonNullable<TelegramChannelEvents["turn.failed"]>>[0], context: {
+    readonly state: TelegramChannelState;
+    readonly session: Pick<SessionContext["session"], "id" | "auth">;
+}) => void | Promise<void>;
+/** Log the original failure before Eve delivers its existing customer-visible error notice. */
+export declare function withTurnErrorLogging(deliver: TurnFailedHandler): TurnFailedHandler;

package/dist/extension/lib/telegram/turn-errors.mjs

@@ -0,0 +1,20 @@
+import { fileURLToPath as __eveFileURLToPath } from "node:url";
+import { dirname as __eveDirname } from "node:path";
+import { createRequire as __eveCreateRequire } from "node:module";
+const __filename = __eveFileURLToPath(import.meta.url);
+__eveDirname(__filename);
+__eveCreateRequire(import.meta.url);
+import { memberIdOf } from "./principal.mjs";
+function withTurnErrorLogging(deliver) {
+	return async (event, context) => {
+		console.error("[segmentstream] telegram turn failed", {
+			chatId: context.state.chatId,
+			memberId: memberIdOf(context.session.auth.current) ?? null,
+			sessionId: context.session.id,
+			turnId: event.turnId,
+			error: event
+		});
+		await deliver(event, context);
+	};
+}
+export { withTurnErrorLogging };

package/dist/extension/lib/telegram/voice.d.ts

@@ -41,8 +41,8 @@ export interface VoiceText {
     readonly note: string;
 }
 /**
- * Turns a voice message into text. When it cannot (transcription is off, the file exceeds what the
- * proxy forwards, or a call fails), the text says so, so the agent can ask for a typed message.
+ * Turns a voice message into text. When it cannot (transcription is off, the file exceeds what a
+ * bot may download, or a call fails), the text says so, so the agent can ask for a typed message.
  */
 export declare function voiceText(input: {
     readonly voice: VoiceMessage;

package/dist/extension/lib/telegram/voice.mjs

@@ -67,7 +67,7 @@ async function downloadTelegramFile(input) {
 		throw new TelegramFileError("Telegram answered getFile with an invalid body.", { cause: error });
 	}
 	if (metadata.status !== 200 || typeof filePath !== "string" || filePath === "") throw new TelegramFileError(`Telegram refused getFile with HTTP ${metadata.status}${description ? `: ${description}` : "."}`);
-	const file = await input.proxy.request({
+	const file = await input.proxy.download({
 		api: "file",
 		method: "GET",
 		path: `/${filePath}`,
@@ -84,7 +84,7 @@ async function voiceText(input) {
 		text: voiceNote(voice, "voice transcription is off"),
 		note
 	};
-	if (voice.size !== void 0 && voice.size > 2097152) return {
+	if (voice.size !== void 0 && voice.size > 20971520) return {
 		text: voiceNote(voice, "too long to transcribe"),
 		note
 	};