@segmentstream/agent 0.5.4 → 0.6.4

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

@@ -14,6 +14,7 @@ import { agentIdentities } from "../identities.mjs";
 import { conversations } from "../conversations.mjs";
 import { observedMessages } from "./observed.mjs";
 import { InboundRequest, currentInboundRequest, runInboundRequest, withReplacedText } from "./inbound-request.mjs";
+import { telegramSendScope } from "./send-queue.mjs";
 import { failureText, reportTelegramError, safeTelegramFetch, withDeliveryLocale } from "./customer-text.mjs";
 import { captureRouteDecider, captureTelegramFetch, conversationIdentities, telegramConversationCapture } from "./conversations.mjs";
 import { runtimeTokenVerifier } from "../runtime-identity.mjs";
@@ -29,7 +30,6 @@ import { replyDelivery } from "./silent.mjs";
 import { downloadTelegramFile, gatewayTranscriber } from "./voice.mjs";
 import { handleInboundMessage } from "./inbound.mjs";
 import { TELEGRAM_PLACEHOLDER_TOKEN, TELEGRAM_PROXY_ORIGIN, telegramProxyFetch } from "./proxy-fetch.mjs";
-import { messagesRoute } from "./requests.mjs";
 import { healthRoute } from "./health.mjs";
 import { telegramFailureEvents } from "./turn-errors.mjs";
 import { telegramWebhookVerifier } from "./webhook.mjs";
@@ -128,7 +128,7 @@ function segmentstreamTelegram(options) {
 		api: {
 			apiBaseUrl: TELEGRAM_PROXY_ORIGIN,
 			fileBaseUrl: TELEGRAM_PROXY_ORIGIN,
-			fetch: (input, init) => safeTelegramFetch(captureTelegramFetch(telegramProxyFetch(proxy()), archive, pairing))(input, init)
+			fetch: (input, init) => safeTelegramFetch(captureTelegramFetch(telegramProxyFetch(proxy(), telegramSendScope(environment, settings().connection)), archive, pairing), telegramSendScope(environment, settings().connection))(input, init)
 		},
 		credentials: {
 			botToken: TELEGRAM_PLACEHOLDER_TOKEN,
@@ -228,8 +228,8 @@ function segmentstreamTelegram(options) {
 		},
 		events: {
 			...telegramFailureEvents,
-			...telegramConfirmationEvents(confirmationRenderer({ model: () => options.models().decision })),
-			"message.completed": replyDelivery(observed)
+			...telegramConfirmationEvents(confirmationRenderer({ model: () => options.models().decision }), archive),
+			"message.completed": replyDelivery(observed, () => telegramSendScope(environment, settings().connection))
 		}
 	});
 	const adapter = channel.adapter;
@@ -263,28 +263,17 @@ function segmentstreamTelegram(options) {
 				}, context.state.messageThreadId === null ? void 0 : String(context.state.messageThreadId));
 			}]))
 		} },
-		routes: [
-			...channel.routes.map((route) => gatedRoute({
-				route,
-				options,
-				environment,
-				capture
-			})),
-			messagesRoute({
-				channel,
-				enabled: () => channelsEnabled(environment),
-				configured: () => options.settings() !== null,
-				verify: () => verify ??= runtimeTokenVerifier(runtimeIdentityEnvironment(environment)),
-				sessionPolicy: policy,
-				scope: () => options.sessions().scope
-			}),
-			healthRoute({
-				chats,
-				enabled: () => channelsEnabled(environment),
-				configured: () => options.settings() !== null,
-				verify: () => verify ??= runtimeTokenVerifier(runtimeIdentityEnvironment(environment))
-			})
-		]
+		routes: [...channel.routes.map((route) => gatedRoute({
+			route,
+			options,
+			environment,
+			capture
+		})), healthRoute({
+			chats,
+			enabled: () => channelsEnabled(environment),
+			configured: () => options.settings() !== null,
+			verify: () => verify ??= runtimeTokenVerifier(runtimeIdentityEnvironment(environment))
+		})]
 	};
 }
 function sessionIdOf(context) {
@@ -305,9 +294,10 @@ function gatedRoute(input) {
 				resolveSession: args.resolveSession,
 				from: args.from
 			};
-			inbound.respond = (address, requestId, decision, auth) => args.from(scoped(address)).respond([{
+			inbound.respond = (address, requestId, decision, auth, text) => args.from(scoped(address)).respond([{
 				requestId,
-				optionId: decision
+				optionId: decision,
+				...text === void 0 ? {} : { text }
 			}], { auth });
 			const tasks = [];
 			const waitUntil = (task) => {

package/dist/extension/lib/telegram/attachments-send.d.ts

@@ -24,7 +24,7 @@ export interface SentFile {
 /** Bare ids are document records; explicit references select other entities and file properties. */
 export declare function sendAttachmentsInput(value: Record<string, unknown>): SendAttachmentsInput;
 /** All destinations and credentials come from the channel's turn and mounted configuration. */
-export declare function sendAttachments(options: {
+interface SendOptions {
     readonly input: SendAttachmentsInput;
     readonly principal: SessionAuthContext | null;
     readonly sessionId: string;
@@ -32,10 +32,14 @@ export declare function sendAttachments(options: {
     readonly environment?: Environment;
     readonly token?: RuntimeToken;
     readonly fetch?: typeof fetch;
-}): Promise<{
+}
+type SendResult = {
     readonly files: ReadonlyArray<SentFile>;
 } | {
     readonly error: string;
     readonly detail: string;
     readonly reference: string;
-}>;
+};
+/** Reserve the chat before downloading, and keep every album/batch in the same queue slot. */
+export declare function sendAttachments(options: SendOptions): Promise<SendResult>;
+export {};

package/dist/extension/lib/telegram/attachments-send.mjs

@@ -11,7 +11,8 @@ import { redactDiagnostic } from "../diagnostics.mjs";
 import { runtimeToken } from "../runtime-token.mjs";
 import { ACT_AS_HEADER } from "../ontology-connection.mjs";
 import { AttachmentError, CONVERSATION_HEADER, SESSION_HEADER } from "../attachments.mjs";
-import { customerCopy, customerText, reportTelegramError } from "./customer-text.mjs";
+import { inTelegramSendQueue, telegramSendScope } from "./send-queue.mjs";
+import { customerCopy, customerMessage, formattingRefused, reportTelegramError } from "./customer-text.mjs";
 import { confirmationLocale } from "./confirmation-text.mjs";
 import { TELEGRAM_PLACEHOLDER_TOKEN, TELEGRAM_PROXY_ORIGIN, telegramProxyFetch } from "./proxy-fetch.mjs";
 import { attachmentOwner } from "../attachment-tools.mjs";
@@ -74,7 +75,11 @@ async function boundedDownload(response, maximum) {
 	}
 	return new Uint8Array(Buffer.concat(chunks));
 }
-async function sendAttachments(options) {
+function sendAttachments(options) {
+	const chatId = options.principal?.attributes.chatId;
+	return typeof chatId === "string" && options.connection !== void 0 ? inTelegramSendQueue(telegramSendScope(options.environment ?? process.env, options.connection), chatId, () => sendAttachmentsInOrder(options)) : sendAttachmentsInOrder(options);
+}
+async function sendAttachmentsInOrder(options) {
 	const environment = options.environment ?? process.env;
 	const principal = options.principal;
 	const locale = confirmationLocale(principal);
@@ -117,7 +122,7 @@ async function sendAttachments(options) {
 		connection: options.connection,
 		token,
 		fetch: fetchImpl
-	}));
+	}), telegramSendScope(environment, options.connection));
 	const results = options.input.documentIds.map(({ id }) => ({
 		id,
 		filename: ""
@@ -196,12 +201,18 @@ async function sendAttachments(options) {
 		if (files.length === 1) {
 			const file = files[0];
 			form.set(file.type, file.blob, file.filename);
-			if (caption !== void 0) form.set("caption", caption);
+			if (caption !== void 0) {
+				form.set("caption", caption.text);
+				if (caption.entities.length > 0) form.set("caption_entities", JSON.stringify(caption.entities));
+			}
 		} else {
 			form.set("media", JSON.stringify(files.map((file, index) => ({
 				type: file.type,
 				media: `attach://file${index}`,
-				...index === 0 && caption !== void 0 ? { caption } : {}
+				...index === 0 && caption !== void 0 ? {
+					caption: caption.text,
+					...caption.entities.length > 0 ? { caption_entities: caption.entities } : {}
+				} : {}
 			}))));
 			files.forEach((file, index) => form.set(`file${index}`, file.blob, file.filename));
 		}
@@ -211,7 +222,7 @@ async function sendAttachments(options) {
 			body: form
 		});
 	}
-	let caption = options.input.caption === void 0 ? void 0 : customerText(options.input.caption, locale);
+	let caption = options.input.caption === void 0 ? void 0 : customerMessage(options.input.caption, locale);
 	let cursor = 0;
 	while (cursor < uploads.length) {
 		const batch = [uploads[cursor++]];
@@ -227,7 +238,14 @@ async function sendAttachments(options) {
 		}
 		try {
 			if (size > 2097152) throw refused("too_large", PROXY_LIMIT);
-			const response = await telegram(request);
+			let response = await telegram(request);
+			if (caption !== void 0 && caption.entities.length > 0 && await formattingRefused(response)) {
+				caption = {
+					text: caption.text,
+					entities: []
+				};
+				response = await telegram(multipart(batch, caption));
+			}
 			const answer = await response.json();
 			if (!response.ok || !isRecord(answer) || answer.ok !== true) {
 				console.error("[segmentstream] Telegram attachment upload refused", {

package/dist/extension/lib/telegram/chat-post-card.d.ts

@@ -0,0 +1,15 @@
+import type { ChatPostPreview } from "../chat-post-confirmation.js";
+import type { ConfirmationText } from "./confirmation-text.js";
+/** Only the frozen deterministic card may bypass the generic technical-prose filter. */
+export declare function withChatPostCard<T>(text: string, run: () => T): T;
+export declare function isExactChatPostCard(text: string): boolean;
+export declare function chatPostCopy(locale: string): {
+    edit: string;
+    changes: string;
+    uncertain: string;
+    sent: string;
+    history: string;
+    expired: string;
+};
+export declare function chatPostCard(preview: ChatPostPreview, locale: string): ConfirmationText;
+export declare function chatPostReceipt(output: unknown, locale: string): string | undefined;

package/dist/extension/lib/telegram/chat-post-card.mjs

@@ -0,0 +1,65 @@
+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 { AsyncLocalStorage } from "node:async_hooks";
+const MAX_PREVIEW_LENGTH = 3584;
+const exactText = new AsyncLocalStorage();
+function withChatPostCard(text, run) {
+	if (text.length > 4096) throw new Error("The complete chat confirmation cannot fit in one Telegram message.");
+	return exactText.run(text, run);
+}
+function isExactChatPostCard(text) {
+	return exactText.getStore() === text;
+}
+function chatPostCopy(locale) {
+	return locale.startsWith("ru") ? {
+		edit: "Изменить",
+		changes: "Что изменить в сообщении?",
+		uncertain: "Неизвестно, отправлено ли сообщение. Не отправляйте его повторно автоматически.",
+		sent: "Отправлено.",
+		history: "Не удалось записать квитанцию в историю.",
+		expired: "Срок подтверждения истёк. Ничего не отправлено."
+	} : {
+		edit: "Edit",
+		changes: "What would you like to change in the message?",
+		uncertain: "Delivery is uncertain. Do not resend automatically.",
+		sent: "Sent.",
+		history: "The receipt could not be recorded in history.",
+		expired: "This confirmation expired. Nothing was sent."
+	};
+}
+function chatPostCard(preview, locale) {
+	const russian = locale.startsWith("ru");
+	const text = [
+		russian ? "Отправить сообщение?" : "Send message?",
+		`${russian ? "Чат" : "Chat"}: ${preview.title} (${preview.provider})`,
+		...preview.replyTo === null ? [] : [`${russian ? "В ответ на" : "Reply to"}: ${preview.replyTo}`],
+		"",
+		preview.finalText
+	].join("\n");
+	if (text.length > MAX_PREVIEW_LENGTH) throw new Error("The full message and receipt cannot fit in one Telegram confirmation. Make a shorter draft.");
+	return {
+		text,
+		confirm: russian ? "Отправить" : "Confirm",
+		cancel: russian ? "Отмена" : "Cancel",
+		executing: russian ? "Подтверждено." : "Confirmed.",
+		cancelled: russian ? "Отменено." : "Cancelled.",
+		completed: chatPostCopy(locale).sent,
+		failed: russian ? "Ошибка отправки сообщения." : "Chat posting failed."
+	};
+}
+function chatPostReceipt(output, locale) {
+	const value = typeof output === "object" && output !== null ? output : {};
+	if (value.status !== "sent" && value.status !== "uncertain" || typeof value.history_recorded !== "boolean" || typeof value.duplicate !== "boolean" || value.message_id !== null && typeof value.message_id !== "string" || value.url !== null && typeof value.url !== "string") return;
+	const copy = chatPostCopy(locale);
+	const url = typeof value.url === "string" && value.url.length <= 256 && /^https:\/\/t\.me\/[A-Za-z0-9_/-]+$/u.test(value.url) ? value.url : null;
+	return [
+		value.status === "sent" ? copy.sent : copy.uncertain,
+		...url === null ? [] : [url],
+		...value.history_recorded ? [] : [copy.history]
+	].join("\n");
+}
+export { chatPostCard, chatPostCopy, chatPostReceipt, isExactChatPostCard, withChatPostCard };

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

@@ -1,10 +1,11 @@
 import type { ChannelEvents } from "eve/channels";
 import type { TelegramCallbackQuery, TelegramChannelEvents, TelegramContext, TelegramEventContext } from "eve/channels/telegram";
+import { type Conversations } from "../conversations.js";
 import type { AgentIdentities } from "../identities.js";
 import { type PendingQuestion } from "../questions.js";
 import { type ConfirmationRenderer } from "./confirmation-text.js";
 import { type HistoryReader, type RecordedEvent } from "./sessions.js";
-export declare function confirmationCallback(requestId: string, memberId: string, decision: "approve" | "cancel"): string;
+export declare function confirmationCallback(requestId: string, memberId: string, decision: "approve" | "cancel" | "edit"): string;
 export declare function questionFromHistory(events: readonly RecordedEvent[], owner?: Pick<PendingQuestion, "memberId" | "chatId" | "messageThreadId">): PendingQuestion | undefined;
 export declare function questionAddress(owner: Pick<PendingQuestion, "memberId" | "chatId" | "messageThreadId">): string;
 /** Custom callback data avoids Eve's default, unpaired Telegram callback principal. */
@@ -16,5 +17,5 @@ export declare function handleConfirmationCallback(input: {
     readonly scope: "chat" | "thread";
     readonly now?: number;
 }): Promise<void>;
-export declare function telegramConfirmationEvents(render?: ConfirmationRenderer): TelegramChannelEvents & Pick<ChannelEvents<TelegramEventContext>, "context.cleared">;
+export declare function telegramConfirmationEvents(render?: ConfirmationRenderer, archive?: Conversations): TelegramChannelEvents & Pick<ChannelEvents<TelegramEventContext>, "context.cleared">;
 export declare const confirmationEvents: TelegramChannelEvents & Pick<ChannelEvents<TelegramEventContext>, "context.cleared">;

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/conversations.mjs

@@ -272,12 +272,14 @@ function captureTelegramFetch(fetchImpl, archive, identities) {
 			}
 			throw error;
 		}
-		const result = record(await response.clone().json());
+		const result = record(await response.clone().json().catch(() => null));
+		const messageId = id(record(result.result).message_id);
+		const acknowledged = edit || messageId !== null && /^[1-9]\d*$/u.test(messageId);
 		await archive.append({
 			...event,
 			eventId: `${event.eventId}:result`,
-			status: response.ok && result.ok === true ? "completed" : "failed",
-			messageId: id(record(result.result).message_id) ?? event.messageId
+			status: response.ok && result.ok === true && acknowledged ? "completed" : result.ok === false ? "failed" : "unknown",
+			messageId: messageId ?? event.messageId
 		});
 		return response;
 	};

package/dist/extension/lib/telegram/customer-text.d.ts

@@ -1,3 +1,4 @@
+import { type TelegramText } from "./format.js";
 export declare function withDeliveryLocale<T>(locale: string, run: () => T, threadId?: string): T;
 export declare function currentLocale(): string;
 export declare function currentThreadId(): string | undefined;
@@ -16,5 +17,16 @@ export declare function isTechnicalText(text: string): boolean;
 export declare function reportTelegramError(operation: string, error: unknown, metadata?: Record<string, unknown>, secrets?: ReadonlySet<string>): string;
 export declare function failureText(errorId: string, kind?: "failed" | "recovery" | "attachment" | "authorization" | "response", locale?: string): string;
 export declare function customerText(text: string, locale?: string): string;
+/** Check what Telegram will display, including hidden link destinations, after removing markup. */
+export declare function customerMessage(text: string, locale?: string): TelegramText;
+/** Only a definite formatting refusal permits resending; network/unknown failures never do. */
+export declare function formattingRefused(response: Response): Promise<boolean>;
+export declare class TelegramDeliveryError extends Error {
+    readonly reference: string;
+    readonly delivery: "failed" | "unknown";
+    readonly messageIds: readonly number[];
+    readonly name = "TelegramDeliveryError";
+    constructor(reference: string, delivery: "failed" | "unknown", messageIds: readonly number[]);
+}
 /** Covers framework defaults, edits and callback notices as well as ordinary agent replies. */
-export declare function safeTelegramFetch(fetchImpl: typeof fetch): typeof fetch;
+export declare function safeTelegramFetch(fetchImpl: typeof fetch, scope?: string): typeof fetch;