@segmentstream/agent 0.5.3 → 0.6.3

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

@@ -5,7 +5,10 @@ const __filename = __eveFileURLToPath(import.meta.url);
 __eveDirname(__filename);
 __eveCreateRequire(import.meta.url);
 import { conversationLanguage, memberIdOf, telegramPrincipal } from "./principal.mjs";
+import { chatPostOperationId, isChatPost } from "../chat-post-confirmation.mjs";
+import { chatPostCard, chatPostCopy, chatPostReceipt, withChatPostCard } from "./chat-post-card.mjs";
 import { confirmations } from "../confirmations.mjs";
+import { conversationEvent } from "../conversations.mjs";
 import { currentInboundRequest } from "./inbound-request.mjs";
 import { currentLocale, failureText, reportTelegramError } from "./customer-text.mjs";
 import { answerMarker, isPendingQuestion, pendingQuestions, questionKey } from "../questions.mjs";
@@ -18,7 +21,8 @@ function shortHash(value) {
 	return createHash("sha256").update(value).digest("hex").slice(0, 20);
 }
 function confirmationCallback(requestId, memberId, decision) {
-	return `${PREFIX}${shortHash(requestId)}:${shortHash(memberId)}:${decision === "approve" ? "y" : "n"}`;
+	const choice = decision === "approve" ? "y" : decision === "edit" ? "e" : "n";
+	return `${PREFIX}${shortHash(requestId)}:${shortHash(memberId)}:${choice}`;
 }
 function object(value) {
 	return typeof value === "object" && value !== null ? value : {};
@@ -34,7 +38,9 @@ function openConfirmations(events) {
 			if (request.kind === "tool-approval" && typeof request.requestId === "string" && typeof action.callId === "string") open.set(request.requestId, {
 				requestId: request.requestId,
 				callId: action.callId,
-				at: Date.parse(event.meta.at)
+				at: Date.parse(event.meta.at),
+				toolName: String(action.toolName ?? ""),
+				input: object(action.input)
 			});
 		}
 		if (event.type === "input.resolved" && Array.isArray(data.resolutions)) for (const item of data.resolutions) {
@@ -49,6 +55,10 @@ function questionFromHistory(events, owner) {
 	for (const event of events) {
 		const data = object(event.data);
 		if (event.type === "context.cleared") pending.clear();
+		if (event.type === "input.resolved" && Array.isArray(data.resolutions)) for (const resolution of data.resolutions) {
+			const question = chatPostEditQuestion(object(resolution));
+			if (question !== void 0) pending.set(questionKey(question), question);
+		}
 		if (event.type === "action.result") {
 			const result = object(data.result);
 			const candidate = object(result.output).pendingQuestion;
@@ -60,6 +70,16 @@ function questionFromHistory(events, owner) {
 	}
 	return owner === void 0 ? [...pending.values()].at(-1) : pending.get(questionKey(owner));
 }
+function chatPostEditQuestion(resolution) {
+	const text = object(resolution.response).text;
+	if (resolution.outcome !== "cancelled" || typeof text !== "string") return;
+	try {
+		const question = object(JSON.parse(text)).pendingChatPostEdit;
+		return isPendingQuestion(question) ? question : void 0;
+	} catch {
+		return;
+	}
+}
 function questionAddress(owner) {
 	return formatAddress({
 		...owner,
@@ -111,12 +131,17 @@ async function handleConfirmationCallback(input) {
 	}), input.scope);
 	const session = await (currentInboundRequest()?.sessions)?.resolveSession(address);
 	const prompt = session === void 0 ? void 0 : openConfirmations(await input.read(session.id)).find((candidate) => shortHash(candidate.requestId) === requestHash);
-	if (prompt === void 0 || choice !== "y" && choice !== "n") {
+	if (prompt === void 0 || ![
+		"y",
+		"n",
+		"e"
+	].includes(choice ?? "") || choice === "e" && !isChatPost(prompt.toolName)) {
 		await notice("This confirmation is no longer pending.");
 		return;
 	}
 	const expired = !Number.isFinite(prompt.at) || prompt.at + 6e5 <= (input.now ?? Date.now());
-	const decision = expired || choice === "n" ? "cancel" : "approve";
+	const decision = expired || choice !== "y" ? "cancel" : "approve";
+	const edit = !expired && choice === "e";
 	const principal = telegramPrincipal({
 		member: lookup.member,
 		message: {
@@ -130,17 +155,58 @@ async function handleConfirmationCallback(input) {
 	});
 	const source = currentInboundRequest()?.respond;
 	if (source === void 0) throw new Error("Confirmation callback has no session continuation.");
+	const editQuestion = edit ? {
+		id: `edit-${prompt.callId}`,
+		memberId: lookup.member.id,
+		chatId: query.message.chat.id,
+		messageThreadId: String(query.message.messageThreadId ?? ""),
+		address,
+		question: chatPostCopy(language).changes,
+		task: `The previous chat post was cancelled for editing. Apply the member's changes to this draft, then make a NEW chat_post_message call and confirmation. Never reuse the cancelled call. Previous input: ${JSON.stringify(prompt.input)}`
+	} : void 0;
 	await source(address, prompt.requestId, decision, {
 		...principal,
 		attributes: {
 			...principal.attributes,
 			confirmationRequestId: prompt.requestId,
-			confirmationDecision: decision
+			confirmationDecision: decision,
+			...expired ? { confirmationReason: "expired" } : edit ? { confirmationReason: "edit" } : {}
 		}
-	});
+	}, editQuestion === void 0 ? void 0 : JSON.stringify({ pendingChatPostEdit: editQuestion }));
 	await notice(expired ? "This confirmation expired; nothing executed." : decision === "cancel" ? "Cancellation received." : "Confirmation received.");
 }
-function telegramConfirmationEvents(render = async (description, locale) => fallbackConfirmation(description, locale)) {
+function telegramConfirmationEvents(render = async (description, locale) => fallbackConfirmation(description, locale), archive) {
+	const record = async (callId, phase, text, status, ctx) => {
+		const saved = confirmations.get()[callId];
+		if (archive === void 0 || saved?.description?.chatPost === void 0 || saved.source === void 0) return;
+		const operationId = chatPostOperationId(ctx.session.id, callId);
+		const source = saved.source;
+		const append = () => archive.append(conversationEvent({
+			eventId: `chat-post:${operationId}:${phase}`,
+			provider: "telegram",
+			chatId: source.chatId,
+			chatType: source.chatId.startsWith("-") ? "group" : "private",
+			threadId: source.threadId || null,
+			participantIds: [saved.memberId],
+			kind: "tool_result",
+			operationId,
+			toolCallId: operationId,
+			toolName: saved.action,
+			sessionId: ctx.session.id,
+			text,
+			status,
+			reason: phase
+		}));
+		if (phase === "preview") await append();
+		else try {
+			await append();
+		} catch (error) {
+			reportTelegramError("chat_post_source_archive_failed", error, {
+				operationId,
+				phase
+			});
+		}
+	};
 	return {
 		"context.cleared"(_data, channel) {
 			confirmations.update(() => ({}));
@@ -176,18 +242,30 @@ function telegramConfirmationEvents(render = async (description, locale) => fall
 				}
 				const memberId = confirmations.get()[request.action.callId]?.memberId ?? memberIdOf(ctx.session.auth.current);
 				if (memberId === void 0) throw new Error("Confirmation requires a member.");
-				const copy = await render(confirmations.get()[request.action.callId]?.description, confirmationLocale(ctx.session.auth.current));
+				const description = confirmations.get()[request.action.callId]?.description;
+				const exactPost = isChatPost(request.action.toolName);
+				if (exactPost && description?.chatPost === void 0) throw new Error("An exact chat post cannot show a generic confirmation.");
+				const copy = description?.chatPost === void 0 ? await render(description, confirmationLocale(ctx.session.auth.current)) : chatPostCard(description.chatPost, confirmationLocale(ctx.session.auth.current));
 				const text = copy.text;
-				const sent = await channel.telegram.post({
+				await record(request.action.callId, "preview", text, "requested", ctx);
+				const send = () => channel.telegram.post({
 					text,
-					reply_markup: { inline_keyboard: [[{
-						text: copy.confirm,
-						callback_data: confirmationCallback(request.requestId, memberId, "approve")
-					}, {
-						text: copy.cancel,
-						callback_data: confirmationCallback(request.requestId, memberId, "cancel")
-					}]] }
+					reply_markup: { inline_keyboard: [[
+						{
+							text: copy.confirm,
+							callback_data: confirmationCallback(request.requestId, memberId, "approve")
+						},
+						...exactPost ? [{
+							text: chatPostCopy(confirmationLocale(ctx.session.auth.current)).edit,
+							callback_data: confirmationCallback(request.requestId, memberId, "edit")
+						}] : [],
+						{
+							text: copy.cancel,
+							callback_data: confirmationCallback(request.requestId, memberId, "cancel")
+						}
+					]] }
 				});
+				const sent = await (exactPost ? withChatPostCard(text, send) : send());
 				const state = channel.state;
 				state.confirmationMessages = {
 					...state.confirmationMessages,
@@ -196,7 +274,8 @@ function telegramConfirmationEvents(render = async (description, locale) => fall
 						messageId: sent.id,
 						text,
 						copy,
-						locale: confirmationLocale(ctx.session.auth.current)
+						locale: confirmationLocale(ctx.session.auth.current),
+						exactPost
 					}
 				};
 			}
@@ -221,12 +300,39 @@ function telegramConfirmationEvents(render = async (description, locale) => fall
 				}
 				const [callId, message] = entry;
 				const copy = message.copy ?? confirmationCopy(message.locale ?? confirmationLocale(ctx.session.auth.current, currentLocale()));
-				const text = resolution.outcome === "approved" ? copy.executing : copy.cancelled;
-				await channel.telegram.editMessageText({
+				const reason = confirmations.get()[callId]?.cancellationReason;
+				const status = resolution.outcome === "approved" ? copy.executing : reason === "expired" ? chatPostCopy(message.locale ?? "en").expired : copy.cancelled;
+				const text = message.exactPost ? `${message.text}\n\n${status}` : status;
+				const edit = () => channel.telegram.editMessageText({
 					messageId: message.messageId,
 					replyMarkup: { inline_keyboard: [] },
 					text
 				});
+				await (message.exactPost ? withChatPostCard(text, edit) : edit());
+				await record(callId, reason ?? resolution.outcome, text, resolution.outcome === "approved" ? "completed" : "cancelled", ctx);
+				const question = chatPostEditQuestion(resolution);
+				if (message.exactPost && reason === "edit" && question !== void 0) {
+					pendingQuestions.update((all) => ({
+						...all,
+						[questionKey(question)]: question
+					}));
+					state.pendingQuestions = {
+						...state.pendingQuestions,
+						[questionKey(question)]: question
+					};
+					channel.continuation?.alias(questionAddress(question));
+					channel.continuation?.alias(formatAddress({
+						...question,
+						conversationId: ""
+					}));
+					await channel.telegram.post({
+						text: question.question,
+						reply_markup: {
+							force_reply: true,
+							selective: true
+						}
+					});
+				}
 				if (resolution.outcome !== "approved") {
 					delete state.confirmationMessages?.[callId];
 					confirmations.update((all) => ({
@@ -239,7 +345,7 @@ function telegramConfirmationEvents(render = async (description, locale) => fall
 				}
 			}
 		},
-		async "action.result"(data, channel) {
+		async "action.result"(data, channel, ctx) {
 			const state = channel.state;
 			if (data.result.kind === "tool-result") {
 				const question = object(data.result.output).pendingQuestion;
@@ -278,7 +384,20 @@ function telegramConfirmationEvents(render = async (description, locale) => fall
 			}
 			const message = state.confirmationMessages?.[data.result.callId];
 			if (message === void 0) return;
-			if (data.status !== "completed" || data.result.kind === "tool-result" && (data.result.isError === true || object(data.result.output).isError === true || object(object(data.result.output).validation).ok === false)) {
+			const failed = data.status !== "completed" || data.result.kind === "tool-result" && (data.result.isError === true || object(data.result.output).isError === true || object(object(data.result.output).validation).ok === false);
+			if (message.exactPost) {
+				const locale = message.locale ?? currentLocale();
+				const receipt = !failed && data.result.kind === "tool-result" ? chatPostReceipt(data.result.output, locale) : void 0;
+				const errorId = failed ? reportTelegramError("confirmed_chat_post_failed", data, { callId: data.result.callId }) : void 0;
+				const status = receipt ?? (failed ? `${message.copy?.failed ?? "Chat posting failed."} ${errorId}\n${chatPostCopy(locale).uncertain}` : chatPostCopy(locale).uncertain);
+				const text = `${message.text}\n\n${status}`;
+				await withChatPostCard(text, () => channel.telegram.editMessageText({
+					messageId: message.messageId,
+					replyMarkup: { inline_keyboard: [] },
+					text
+				}));
+				await record(data.result.callId, "receipt", text, failed ? "failed" : object(data.result.kind === "tool-result" ? data.result.output : void 0).status === "sent" ? "completed" : "unknown", ctx);
+			} else if (failed) {
 				const errorId = reportTelegramError("confirmed_action_failed", data, { callId: data.result.callId });
 				await channel.telegram.editMessageText({
 					messageId: message.messageId,

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

@@ -0,0 +1,29 @@
+/** Telegram entities annotate UTF-16 text ranges; they never contain the missing message body. */
+export interface ContentEntity {
+    readonly type: string;
+    readonly offset: number;
+    readonly length: number;
+    readonly user?: Readonly<Record<string, unknown>>;
+    readonly username?: string;
+}
+export interface MessageContent {
+    readonly text: string;
+    readonly entities: ReadonlyArray<ContentEntity>;
+    readonly source: "text" | "caption" | "rich_message" | "none";
+    readonly truncated: boolean;
+}
+export declare function telegramRecord(value: unknown): Readonly<Record<string, unknown>>;
+/** Text/caption stay verbatim, including forwarded messages; rich bodies need flattening. */
+export declare function messageContent(raw: Readonly<Record<string, unknown>>): MessageContent;
+/** Only shape/size diagnostics: do not retain/log raw webhook bodies, URLs or credential values. */
+export declare function contentShape(raw: Readonly<Record<string, unknown>>, content?: MessageContent): {
+    contentSource: "text" | "caption" | "rich_message" | "none";
+    textType: "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function";
+    captionType: "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function";
+    hasRichMessage: boolean;
+    entityCount: number;
+    captionEntityCount: number;
+    textLength: number;
+    truncated: boolean;
+    forwarded: boolean;
+};

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

@@ -0,0 +1,161 @@
+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);
+function telegramRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value) ? value : {};
+}
+function entities(value, text) {
+	return (Array.isArray(value) ? value : []).flatMap((item) => {
+		const entity = telegramRecord(item);
+		const { offset, length, type } = entity;
+		return typeof type === "string" && typeof offset === "number" && Number.isInteger(offset) && offset >= 0 && typeof length === "number" && Number.isInteger(length) && length > 0 && offset + length <= text.length ? [{
+			type,
+			offset,
+			length,
+			...entity.user ? { user: telegramRecord(entity.user) } : {}
+		}] : [];
+	});
+}
+function richContent(value) {
+	let text = "";
+	let nodes = 0;
+	let truncated = false;
+	const mentions = [];
+	const append = (part) => {
+		const remaining = 16384 - text.length;
+		truncated ||= part.length > remaining;
+		text += part.slice(0, remaining);
+	};
+	const enter = (depth) => {
+		nodes += 1;
+		if (nodes > 2048 || depth > 24 || text.length >= 16384) {
+			truncated = true;
+			return false;
+		}
+		return true;
+	};
+	function inline(value, depth) {
+		if (value === void 0 || value === null) return;
+		if (!enter(depth)) return;
+		if (typeof value === "string") {
+			append(value);
+			return;
+		}
+		if (Array.isArray(value)) {
+			for (const item of value) {
+				if (!enter(depth + 1)) break;
+				inline(item, depth + 1);
+			}
+			return;
+		}
+		const item = telegramRecord(value);
+		const offset = text.length;
+		if (item.type === "custom_emoji" && typeof item.alternative_text === "string") append(item.alternative_text);
+		else if (item.type === "mathematical_expression" && typeof item.expression === "string") append(item.expression);
+		else if (item.type === "button") inline(telegramRecord(item.button).text, depth + 1);
+		else inline(item.text, depth + 1);
+		if ([
+			"mention",
+			"text_mention",
+			"code"
+		].includes(String(item.type)) && text.length > offset) mentions.push({
+			type: String(item.type),
+			offset,
+			length: text.length - offset,
+			...item.type === "text_mention" ? { user: telegramRecord(item.user) } : {},
+			...typeof item.username === "string" ? { username: item.username } : {}
+		});
+	}
+	function blocks(value, depth) {
+		if (!Array.isArray(value) || !enter(depth)) return;
+		for (const entry of value) {
+			if (!enter(depth + 1)) break;
+			const item = telegramRecord(entry);
+			const offset = text.length;
+			if (text !== "" && !text.endsWith("\n")) append("\n");
+			if (item.type === "divider") append("---");
+			else if (item.type === "mathematical_expression" && typeof item.expression === "string") append(item.expression);
+			else {
+				inline(item.text, depth + 1);
+				inline(item.title, depth + 1);
+				blocks(item.blocks, depth + 1);
+				if (Array.isArray(item.items)) for (const entry of item.items) {
+					if (!enter(depth + 1)) break;
+					const child = telegramRecord(entry);
+					if (text !== "" && !text.endsWith("\n")) append("\n");
+					if (typeof child.label === "string") append(`${child.label} `);
+					blocks(child.blocks, depth + 1);
+				}
+				if (Array.isArray(item.cells)) for (const row of item.cells) {
+					if (!enter(depth + 1)) break;
+					if (!Array.isArray(row)) continue;
+					if (text !== "" && !text.endsWith("\n")) append("\n");
+					for (const [index, cell] of row.entries()) {
+						if (!enter(depth + 1)) break;
+						if (index > 0) append(" | ");
+						inline(telegramRecord(cell).text, depth + 1);
+					}
+				}
+				if (item.caption !== void 0) {
+					if (text !== "" && !text.endsWith("\n")) append("\n");
+					const caption = telegramRecord(item.caption);
+					inline(caption.text ?? item.caption, depth + 1);
+					inline(caption.credit, depth + 1);
+				}
+				inline(item.credit, depth + 1);
+			}
+			if ([
+				"blockquote",
+				"expandable_blockquote",
+				"pullquote",
+				"pre"
+			].includes(String(item.type)) && text.length > offset) mentions.push({
+				type: "blockquote",
+				offset,
+				length: text.length - offset
+			});
+		}
+	}
+	blocks(telegramRecord(value).blocks, 0);
+	return {
+		text,
+		entities: mentions,
+		source: "rich_message",
+		truncated
+	};
+}
+function messageContent(raw) {
+	for (const source of ["text", "caption"]) {
+		const text = raw[source];
+		if (typeof text === "string" && text !== "") return {
+			text,
+			entities: entities(raw[source === "text" ? "entities" : "caption_entities"], text),
+			source,
+			truncated: false
+		};
+	}
+	if (raw.rich_message !== void 0) return richContent(raw.rich_message);
+	return {
+		text: "",
+		entities: [],
+		source: "none",
+		truncated: false
+	};
+}
+function contentShape(raw, content = messageContent(raw)) {
+	return {
+		contentSource: content.source,
+		textType: typeof raw.text,
+		captionType: typeof raw.caption,
+		hasRichMessage: raw.rich_message !== void 0,
+		entityCount: Array.isArray(raw.entities) ? raw.entities.length : 0,
+		captionEntityCount: Array.isArray(raw.caption_entities) ? raw.caption_entities.length : 0,
+		textLength: content.text.length,
+		truncated: content.truncated,
+		forwarded: raw.forward_origin !== void 0
+	};
+}
+export { contentShape, messageContent, telegramRecord };

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

@@ -2,7 +2,7 @@ import type { AgentIdentities } from "../identities.js";
 import { type Conversations } from "../conversations.js";
 import type { AgentChats } from "./chats.js";
 import type { ObservedMessages } from "./observed.js";
-import type { AddressingReason, RouteDecider } from "./router.js";
+import type { AddressingReason, RouteDecider, RouteDecision } from "./router.js";
 /** Runs after webhook verification, before eve drops bot/channel/service updates. */
 export declare function captureTelegramWebhook(input: {
     readonly request: Request;
@@ -14,7 +14,7 @@ export declare function captureTelegramWebhook(input: {
 }): Promise<Response>;
 /** Additive inbound hook: the router keeps ownership of the reply policy. */
 export declare function recordGateDecision(reason: string, decision?: "reply" | "silent"): void;
-export declare function recordRouteDecision(route: "reply" | "observe", addressed: boolean | AddressingReason | undefined, policy: string): void;
+export declare function recordRouteDecision(route: "reply" | "observe", addressed: boolean | AddressingReason | undefined, policy: string, audit?: Pick<RouteDecision, "reason" | "note">): void;
 export declare function captureRouteDecider(decide: RouteDecider): RouteDecider;
 /** Captures message sends and button/status edits, including pairing and proactive replies. */
 export declare function captureTelegramFetch(fetchImpl: typeof fetch, archive: Conversations, identities: () => AgentIdentities): typeof fetch;

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

@@ -4,11 +4,12 @@ import { createRequire as __eveCreateRequire } from "node:module";
 const __filename = __eveFileURLToPath(import.meta.url);
 __eveDirname(__filename);
 __eveCreateRequire(import.meta.url);
-import { conversationEvent } from "../conversations.mjs";
+import { collapseConversationEvents, conversationEvent } from "../conversations.mjs";
 import { observedChatKey } from "./observed.mjs";
 import { currentInboundRequest } from "./inbound-request.mjs";
 import { reportMembership } from "./membership.mjs";
 import { currentThreadId } from "./customer-text.mjs";
+import { contentShape, messageContent } from "./content.mjs";
 import { parseTelegramUpdate } from "eve/channels/telegram";
 import { randomUUID } from "node:crypto";
 const captures = new WeakMap();
@@ -81,7 +82,9 @@ async function captureTelegramWebhook(input) {
 	const parsed = parseTelegramUpdate({ message: messagePayload });
 	if (parsed?.kind !== "message") return input.next();
 	const message = parsed.message;
-	const sentAt = typeof message.raw.date === "number" ? message.raw.date * 1e3 : Date.now();
+	const content = messageContent(message.raw);
+	const time = edited === void 0 ? message.raw.date : message.raw.edit_date ?? message.raw.date;
+	const sentAt = typeof time === "number" ? time * 1e3 : Date.now();
 	const senderChat = record(message.raw.sender_chat);
 	let lookup;
 	const event = conversationEvent({
@@ -96,7 +99,8 @@ async function captureTelegramWebhook(input) {
 		chatType: message.chat.type === "supergroup" ? "group" : message.chat.type,
 		threadId: message.messageThreadId === void 0 ? null : String(message.messageThreadId),
 		kind: "inbound",
-		text: message.text || message.caption || null,
+		text: content.text || null,
+		argsSummary: JSON.stringify(contentShape(message.raw, content)),
 		messageId: message.messageId,
 		replyToMessageId: message.replyToMessage?.messageId ?? null,
 		senderId: id(senderChat.id) ?? message.from?.id ?? null,
@@ -127,10 +131,11 @@ async function captureTelegramWebhook(input) {
 			...event.threadId === null ? {} : { threadId: event.threadId },
 			limit: 100
 		});
-		for (const earlier of (input.observed.recent(chat).length === 0 ? history.events : []).filter((item) => item.kind === "inbound" && item.eventId !== event.eventId).slice(0, 30).reverse()) input.observed.add(chat, {
+		for (const earlier of (input.observed.recent(chat).length === 0 ? collapseConversationEvents(history.events) : []).filter((item) => item.kind === "inbound" && item.eventId !== event.eventId).slice(0, 30).reverse()) input.observed.add(chat, {
 			author: earlier.senderName ?? earlier.senderId ?? "automated post",
 			text: earlier.text ?? "[attachment or service message]",
 			at: earlier.at,
+			...earlier.messageId === null ? {} : { messageId: earlier.messageId },
 			...earlier.senderId === null ? {} : { authorId: earlier.senderId }
 		});
 	} else {
@@ -141,7 +146,8 @@ async function captureTelegramWebhook(input) {
 		input.observed.add(chat, {
 			author: event.senderName ?? event.senderId ?? "automated post",
 			text: event.text ?? "[attachment or service message]",
-			at: event.at
+			at: event.at,
+			messageId: message.messageId
 		});
 		capture.decision = "silent";
 		capture.reason = edited !== void 0 ? "message_edit" : "automated_or_channel_message";
@@ -172,7 +178,8 @@ async function captureTelegramWebhook(input) {
 		...event,
 		eventId: `${event.eventId}:decision`,
 		kind: "decision",
-		text: null,
+		argsSummary: null,
+		text: capture.note ?? (edited !== void 0 ? "Message edit recorded as context; no agent turn started." : null),
 		decision: capture.decision ?? "silent",
 		reason: capture.reason ?? (message.raw.left_chat_member ? "member_departure" : message.raw.migrate_to_chat_id || message.raw.migrate_from_chat_id ? "chat_migration" : "unpaired_refused_or_empty_message"),
 		attachments: []
@@ -187,12 +194,13 @@ function recordGateDecision(reason, decision = "silent") {
 		capture.decision = decision;
 	}
 }
-function recordRouteDecision(route, addressed, policy) {
+function recordRouteDecision(route, addressed, policy, audit) {
 	const inbound = currentInboundRequest();
 	const capture = inbound === void 0 ? void 0 : captures.get(inbound);
 	if (capture !== void 0) {
 		capture.decision = route === "reply" ? "reply" : "silent";
-		capture.reason ??= typeof addressed === "string" ? addressed : addressed ? "addressed_message" : policy === "mention" ? "mention_policy" : `decision_model_${route}`;
+		capture.reason ??= audit?.reason ?? (typeof addressed === "string" ? addressed : addressed ? "addressed_message" : policy === "mention" ? "mention_policy" : `decision_model_${route}`);
+		capture.note = audit?.note.slice(0, 500);
 	}
 }
 function captureRouteDecider(decide) {

package/dist/extension/lib/telegram/customer-text.mjs

@@ -4,6 +4,7 @@ import { createRequire as __eveCreateRequire } from "node:module";
 const __filename = __eveFileURLToPath(import.meta.url);
 __eveDirname(__filename);
 __eveCreateRequire(import.meta.url);
+import { isExactChatPostCard } from "./chat-post-card.mjs";
 import { redactDiagnostic } from "../diagnostics.mjs";
 import { currentInboundRequest } from "./inbound-request.mjs";
 import { randomBytes } from "node:crypto";
@@ -47,7 +48,6 @@ const TECHNICAL_PATTERNS = [
 	/\b[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\b/iu,
 	/\b[0-9a-hjkmnp-tv-z]{26}\b/iu,
 	/\b\w+__\w+/u,
-	/\b[a-z][a-z0-9]*_[a-z][a-z0-9_]*\b(?!\.[a-z0-9])/iu,
 	/\b(?:Serialization|Type|Reference|Syntax|Tool|Provider|API|Workflow|InternalServer)Error\b/u,
 	/\bError:\s|(?:^|\n)\s*at\s+\S+|\b(?:stack trace|traceback|SQLSTATE|node_modules)\b/imu,
 	/\b(?:duplicate key|ECONN\w+|HTTP [45]\d\d)\b/iu,
@@ -56,7 +56,8 @@ const TECHNICAL_PATTERNS = [
 function isTechnicalText(text) {
 	if (/https?:\/\/[^\s/@]+:[^\s/@]+@|[?&](?:token|access_token|api_key|secret|password)=/iu.test(text)) return true;
 	const visible = text.replace(/https?:\/\/[^\s)<>]+/giu, "link");
-	return TECHNICAL_PATTERNS.some((pattern) => pattern.test(visible));
+	const prose = visible.replace(/(?<![\w@])@[a-z][a-z0-9_]{4,31}(?!\w)/giu, "recipient");
+	return TECHNICAL_PATTERNS.some((pattern) => pattern.test(visible)) || /\b[a-z][a-z0-9]*_[a-z][a-z0-9_]*\b(?!\.[a-z0-9])/iu.test(prose);
 }
 function redactCredentials(value) {
 	if (typeof value === "string") return value.replace(/\bBearer [A-Za-z0-9_.~+/-]+=*/giu, "Bearer [redacted]").replace(/(https?:\/\/)[^/@\s]+:[^/@\s]+@/gu, "$1[redacted]@").replace(/([?&](?:token|access_token|api_key|secret|password)=)[^&#\s]*/giu, "$1[redacted]").replace(/("(?:token|api_key|password|secret)"\s*:\s*)"(?:\\.|[^"\\])*"/giu, "$1\"[redacted]\"");
@@ -97,7 +98,7 @@ function safeTelegramFetch(fetchImpl) {
 		const url = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
 		if (!methods.has(url.split("/").at(-1) ?? "") || typeof init?.body !== "string") return fetchImpl(input, init);
 		const body = JSON.parse(init.body);
-		for (const field of ["text", "caption"]) if (typeof body[field] === "string") body[field] = customerText(body[field]);
+		for (const field of ["text", "caption"]) if (typeof body[field] === "string" && !isExactChatPostCard(body[field])) body[field] = customerText(body[field]);
 		if (Array.isArray(body.media)) body.media = body.media.map((item) => ({
 			...item,
 			...typeof item.caption === "string" ? { caption: customerText(item.caption) } : {}

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

@@ -1,6 +1,8 @@
 import type { TelegramMessage } from "eve/channels/telegram";
 import { type AgentAttachments } from "../attachments.js";
 import type { StagedFile } from "./inbound-request.js";
+import { type ImageDescriber } from "./images.js";
+import type { MediaPlan } from "./media-policy.js";
 /**
  * Photos and documents a member sends the agent (`docs/agent.md`, "Attachments"). Before the turn
  * starts, each file is downloaded through the connection and stored once as a temporary attachment
@@ -17,6 +19,8 @@ export declare function stageFiles(input: {
     readonly memberId: string;
     readonly attachments: AgentAttachments;
     readonly download: (fileId: string) => Promise<Uint8Array>;
+    readonly imagePlan?: MediaPlan;
+    readonly describeImage?: ImageDescriber;
 }): Promise<ReadonlyMap<string, StagedFile>>;
 /** The `<attachments>` block that tells the model which attachments the message carries. */
 export declare function attachmentsContext(input: {