@segmentstream/agent 0.5.3 → 0.6.3

package/dist/extension/lib/conversations.mjs

@@ -9,11 +9,12 @@ import { runtimeToken } from "./runtime-token.mjs";
 function collapseConversationEvents(events) {
 	const latest = new Map();
 	for (const event of events) {
-		const key = event.kind === "outbound" && /^telegram:(send|edit):/u.test(event.eventId) ? event.eventId.replace(/:result$/u, "") : event.eventId;
+		const key = event.kind === "outbound" && event.operationId != null ? `chat-delivery:${event.operationId}` : event.kind === "inbound" && event.provider === "telegram" && event.messageId !== null ? `telegram:${event.chatId}:${event.messageId}:message` : event.kind === "outbound" && /^telegram:(send|edit):/u.test(event.eventId) ? event.eventId.replace(/:result$/u, "") : event.eventId;
 		const previous = latest.get(key);
 		if (previous === void 0 || (/^\d+$/u.test(event.sequence) && /^\d+$/u.test(previous.sequence) ? BigInt(event.sequence) > BigInt(previous.sequence) : event.storedAt > previous.storedAt)) latest.set(key, {
 			...event,
-			eventId: key
+			eventId: key,
+			...event.kind === "outbound" && event.operationId != null && event.status === "requested" ? { status: "uncertain" } : {}
 		});
 	}
 	return [...latest.values()];
@@ -95,7 +96,7 @@ async function storedConversationContext(archive, coordinates) {
 		chatId: coordinates.chatId,
 		...coordinates.threadId === null ? {} : { threadId: coordinates.threadId },
 		limit: 100
-	})).events).filter((event) => event.kind === "inbound" || event.kind === "outbound" && event.status === "completed");
+	})).events).filter((event) => event.kind === "inbound" || event.kind === "outbound" && ["completed", "sent"].includes(event.status ?? ""));
 	const selected = [];
 	let characters = 0;
 	for (const event of messages) {

package/dist/extension/lib/ontology-connection.d.ts

@@ -34,4 +34,8 @@ export declare function ontologyConnection(input: {
     readonly environment?: Environment;
     readonly token?: RuntimeToken;
     readonly fetch?: typeof fetch;
+    /** Set only by the authenticated catalog handshake, never by model input. */
+    readonly chatPosting?: boolean;
 }): McpClientConnectionDefinition | null;
+/** Negotiate before opening Eve's client: old strict schemas never receive the new envelope. */
+export declare function ontologyConnectionForTurn(input: Parameters<typeof ontologyConnection>[0]): Promise<McpClientConnectionDefinition | null>;

package/dist/extension/lib/ontology-connection.mjs

@@ -6,7 +6,8 @@ __eveDirname(__filename);
 __eveCreateRequire(import.meta.url);
 import { appOrigin } from "./environment.mjs";
 import { memberIdOf } from "./telegram/principal.mjs";
-import { actionApproval } from "./confirmations.mjs";
+import { CHAT_POST_ENVELOPE, chatPostDigest, chatPostOperationId, isChatPost } from "./chat-post-confirmation.mjs";
+import { actionApproval, confirmations } from "./confirmations.mjs";
 import { runtimeToken, tokenExpiry } from "./runtime-token.mjs";
 import { ontologyTools } from "./ontology-tools.mjs";
 import { defineMcpClientConnection } from "eve/connections";
@@ -29,8 +30,36 @@ function ontologyConnection(input) {
 	return defineMcpClientConnection({
 		url: `${origin}/mcp`,
 		description: DESCRIPTION,
-		instanceKey: `${origin}/mcp#member:${memberId}`,
+		instanceKey: `${origin}/mcp#member:${memberId}${input.chatPosting ? ":chat-post-v1" : ""}`,
 		approval: actionApproval(ontologyTools(input)),
+		...input.chatPosting ? { toolCall: { providedArguments: { [CHAT_POST_ENVELOPE]: (ctx) => {
+			actAsHeaders({
+				principal: ctx.session.auth.current,
+				expectedMemberId: memberId
+			});
+			const base = {
+				version: 1,
+				session_id: ctx.session.id,
+				call_id: ctx.callId
+			};
+			if (!isChatPost(ctx.toolName)) return base;
+			const saved = confirmations.get()[ctx.callId];
+			const preview = saved?.description?.chatPost;
+			if (saved?.status !== "consumed" || saved.memberId !== memberId || saved.action.split("__").at(-1) !== ctx.toolName || saved.expiresAt <= Date.now() || preview === void 0 || saved.source === void 0) throw new Error("Exact chat posting requires the original unexpired confirmed call.");
+			return {
+				...base,
+				operation_id: chatPostOperationId(ctx.session.id, ctx.callId),
+				source: {
+					provider: "telegram",
+					chat_id: saved.source.chatId,
+					thread_id: saved.source.threadId
+				},
+				expected: {
+					chat_id: preview.chatId,
+					digest: chatPostDigest(preview)
+				}
+			};
+		} } } } : {},
 		auth: {
 			credentialOwner: "app",
 			getToken: async () => {
@@ -48,4 +77,18 @@ function ontologyConnection(input) {
 		})
 	});
 }
-export { ACT_AS_HEADER, MemberRequiredError, actAsHeaders, ontologyConnection };
+async function ontologyConnectionForTurn(input) {
+	const memberId = memberIdOf(input.principal);
+	if (memberId === void 0) return null;
+	let chatPosting = false;
+	try {
+		chatPosting = await ontologyTools(input).supportsChatPosting(memberId);
+	} catch (error) {
+		console.warn("Chat posting capability unavailable; keeping the compatible ontology connection.", error);
+	}
+	return ontologyConnection({
+		...input,
+		chatPosting
+	});
+}
+export { ACT_AS_HEADER, MemberRequiredError, actAsHeaders, ontologyConnection, ontologyConnectionForTurn };

package/dist/extension/lib/ontology-tools.d.ts

@@ -7,6 +7,7 @@ export declare function ontologyTools(options?: {
     readonly token?: RuntimeToken;
     readonly fetch?: typeof fetch;
 }): {
+    supportsChatPosting(memberId: string): Promise<boolean>;
     labels(memberId: string, action: string): Promise<ActionAnnotations>;
     describe(memberId: string, action: string, input: Readonly<Record<string, unknown>>): Promise<import("./confirmation-description.js").ConfirmationDescription>;
 };

package/dist/extension/lib/ontology-tools.mjs

@@ -6,6 +6,7 @@ __eveDirname(__filename);
 __eveCreateRequire(import.meta.url);
 import { appOrigin } from "./environment.mjs";
 import { describeConfirmation, object } from "./confirmation-description.mjs";
+import { describeChatPost, isChatPost, supportsChatPost } from "./chat-post-confirmation.mjs";
 import { redactDiagnostic } from "./diagnostics.mjs";
 import { runtimeToken } from "./runtime-token.mjs";
 function ontologyTools(options = {}) {
@@ -31,10 +32,12 @@ function ontologyTools(options = {}) {
 				signal: signal ?? AbortSignal.timeout(15e3),
 				redirect: "error"
 			});
-			if (!response.ok) throw new Error(`Cannot check action permission (HTTP ${response.status}).`);
+			if (!response.ok) throw new Error(`Cannot check action permission (HTTP ${response.status}).`, { cause: await response.text() });
 			const body = object(await response.json());
 			if (body.error !== void 0) throw new Error("Ontology metadata unavailable.", { cause: body.error });
-			return object(body.result);
+			const result = object(body.result);
+			if (result.isError === true) throw new Error("The ontology preview read failed.", { cause: result });
+			return result;
 		} catch (error) {
 			throw new Error("The ontology metadata request failed.", { cause: redactDiagnostic(error, secrets) });
 		}
@@ -51,12 +54,34 @@ function ontologyTools(options = {}) {
 		};
 	}
 	return {
+		async supportsChatPosting(memberId) {
+			const result = await rpc(memberId, "tools/list", {});
+			return Array.isArray(result.tools) && result.tools.map(object).some(supportsChatPost);
+		},
 		async labels(memberId, action) {
 			return object((await toolFor(memberId, action)).tool.annotations);
 		},
 		async describe(memberId, action, input) {
 			const signal = AbortSignal.timeout(15e3);
 			const { tool, tools } = await toolFor(memberId, action, signal);
+			if (isChatPost(action)) {
+				if (!supportsChatPost(tool)) throw new Error("The ontology does not support exact chat confirmations.");
+				const read = async (name, args) => {
+					if (!tools.some((candidate) => candidate.name === name && object(candidate.annotations).readOnlyHint === true)) throw new Error("The chat preview reads are unavailable.");
+					const result = await rpc(memberId, "tools/call", {
+						name,
+						arguments: args
+					}, signal);
+					if (result.isError === true) throw new Error("The chat preview could not be resolved.");
+					return object(result.structuredContent);
+				};
+				const [caller, destinations] = await Promise.all([read("me", {}), read("chat_list", { chat: input.chat })]);
+				return describeChatPost({
+					values: input,
+					caller,
+					destinations
+				});
+			}
 			let entities = [];
 			try {
 				const catalog = await rpc(memberId, "resources/read", { uri: "ontology://catalog" }, signal);

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

@@ -1,10 +1,12 @@
 import { type TelegramChannel } from "eve/channels/telegram";
-import type { SessionSettings, TelegramSettings } from "../../config.js";
+import type { ChatModelChoice, SessionSettings, TelegramSettings } from "../../config.js";
 import { type AgentAttachments } from "../attachments.js";
 import { type Environment } from "../environment.js";
 import { type Conversations } from "../conversations.js";
 import { type RuntimeTokenVerifier } from "../runtime-identity.js";
 import { type RuntimeToken } from "../runtime-token.js";
+import { type ImageDescriber } from "./images.js";
+import { type CapabilityLookup } from "./media-policy.js";
 import { type ObservedMessages } from "./observed.js";
 import { type DecideFunction } from "./router.js";
 import { type HistoryReader } from "./sessions.js";
@@ -20,6 +22,8 @@ export interface TelegramAdapterOptions {
     readonly models: () => {
         readonly stt: string | false;
         readonly decision: string;
+        readonly chat?: ChatModelChoice | null;
+        readonly imageDescription?: string | false | null;
     };
     /** The mounted `sessions`. */
     readonly sessions: () => SessionSettings;
@@ -29,8 +33,10 @@ export interface TelegramAdapterOptions {
     /** For the proxy and the ontology service; tests pass a fake. */
     readonly fetch?: typeof fetch;
     readonly transcribe?: Transcriber;
+    readonly describeImage?: ImageDescriber;
+    readonly modelCapabilities?: CapabilityLookup;
     readonly observed?: ObservedMessages;
-    /** Verifies callers of the messages route; tests pass one on a local key set. */
+    /** Verifies callers of the health route; tests pass one on a local key set. */
     readonly verify?: RuntimeTokenVerifier;
     /** Reads session events for routing, policy and interactions; tests pass a fake. */
     readonly history?: HistoryReader;

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

@@ -5,7 +5,8 @@ const __filename = __eveFileURLToPath(import.meta.url);
 __eveDirname(__filename);
 __eveCreateRequire(import.meta.url);
 import { appOrigin, channelsEnabled, proxyEnvironment, runtimeIdentityEnvironment, webhookSecret } from "../environment.mjs";
-import { conversationLanguage } from "./principal.mjs";
+import { conversationLanguage, telegramPrincipal } from "./principal.mjs";
+import { chooseModel } from "../../model.mjs";
 import { MAXIMUM_DOWNLOAD_BYTES, connectionProxy } from "../connection-proxy.mjs";
 import { runtimeToken } from "../runtime-token.mjs";
 import { agentAttachments, parseAttachmentUrl } from "../attachments.mjs";
@@ -20,13 +21,14 @@ import { botIdentityCache } from "./bot.mjs";
 import { confirmationLocale, confirmationRenderer } from "./confirmation-text.mjs";
 import { scopedAddress, sessionPolicy } from "./sessions.mjs";
 import { handleConfirmationCallback, telegramConfirmationEvents } from "./confirmations.mjs";
+import { gatewayImageDescriber } from "./images.mjs";
+import { gatewayMediaCapabilities, planMedia } from "./media-policy.mjs";
 import { agentChats } from "./chats.mjs";
 import { decisionRouter } from "./router.mjs";
 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";
@@ -40,7 +42,7 @@ const eveHistory = async (sessionId) => {
 	})) events.push({
 		type: event.type,
 		meta: { at: event.meta.at },
-		...event.type === "message.completed" ? { data: {
+		...event.type === "step.started" ? { data: { modelId: event.data.modelId } } : event.type === "message.completed" ? { data: {
 			message: event.data.message,
 			finishReason: event.data.finishReason
 		} } : {}
@@ -63,6 +65,7 @@ function segmentstreamTelegram(options) {
 	const observed = options.observed ?? observedMessages();
 	const readHistory = options.history ?? eveHistory;
 	const readInteractions = options.history ?? eveInteractions;
+	const capabilities = options.modelCapabilities ?? gatewayMediaCapabilities(options.fetch);
 	const archive = options.conversations ?? conversations({
 		environment,
 		token,
@@ -147,6 +150,37 @@ function segmentstreamTelegram(options) {
 						sessions: options.sessions,
 						sessionPolicy: policy,
 						sttModel: options.models().stt,
+						describeImage: options.describeImage ?? gatewayImageDescriber,
+						mediaPlan: async (member, sessionId) => {
+							let selected;
+							if (sessionId !== void 0) try {
+								for (const event of await readHistory(sessionId)) {
+									const data = event.data;
+									if (event.type === "step.started" && typeof data?.modelId === "string") selected = data.modelId;
+								}
+							} catch (error) {
+								reportTelegramError("media_session_model_lookup_failed", error, { sessionId });
+							}
+							else {
+								const choice = options.models().chat;
+								if (choice) selected = chooseModel({
+									choice,
+									principal: telegramPrincipal({
+										message: {
+											...message,
+											from: message.from
+										},
+										member
+									}),
+									environment
+								});
+							}
+							return planMedia(selected === void 0 ? {
+								known: false,
+								images: false,
+								audio: false
+							} : await capabilities(selected), options.models().imageDescription ?? null);
+						},
 						identities: conversationIdentities(pairing()),
 						bot,
 						decide: captureRouteDecider(decisionRouter({
@@ -193,7 +227,7 @@ function segmentstreamTelegram(options) {
 		},
 		events: {
 			...telegramFailureEvents,
-			...telegramConfirmationEvents(confirmationRenderer({ model: () => options.models().decision })),
+			...telegramConfirmationEvents(confirmationRenderer({ model: () => options.models().decision }), archive),
 			"message.completed": replyDelivery(observed)
 		}
 	});
@@ -228,28 +262,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) {
@@ -270,9 +293,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/audience.d.ts

@@ -0,0 +1,26 @@
+import type { TelegramMessage } from "eve/channels/telegram";
+import type { BotIdentity } from "./router.js";
+type TargetKind = "bot" | "human" | "other_bot" | "unknown";
+interface Recipient {
+    readonly kind: TargetKind;
+    readonly id?: string;
+    readonly username?: string;
+    readonly name?: string;
+}
+export interface MessageAudience {
+    readonly originalText: string;
+    readonly botTagged: boolean;
+    readonly mentions: ReadonlyArray<Recipient & {
+        readonly type: "mention" | "text_mention";
+        readonly text: string;
+    }>;
+    readonly replyTo: (Recipient & {
+        readonly messageId: string;
+        readonly text: string;
+    }) | null;
+}
+/** Current-message entities only; mentions inside a quoted/code range are not addressees. */
+export declare function messageAudience(message: TelegramMessage, bot: BotIdentity | undefined): MessageAudience;
+/** A known human reply or an explicit other recipient takes precedence over smart follow-ups. */
+export declare function otherRecipient(audience: MessageAudience | undefined): string | undefined;
+export {};

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

@@ -0,0 +1,80 @@
+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 { messageContent, telegramRecord } from "./content.mjs";
+function recipient(user, bot) {
+	const id = typeof user.id === "string" || typeof user.id === "number" ? String(user.id) : void 0;
+	const username = typeof user.username === "string" ? user.username : void 0;
+	return {
+		kind: bot !== void 0 && (id === bot.id || username !== void 0 && bot.username !== void 0 && username.toLowerCase() === bot.username.toLowerCase()) ? "bot" : user.is_bot === false ? "human" : user.is_bot === true && bot !== void 0 ? "other_bot" : "unknown",
+		...id === void 0 ? {} : { id },
+		...username === void 0 ? {} : { username },
+		...typeof user.first_name === "string" ? { name: user.first_name } : {}
+	};
+}
+function messageAudience(message, bot) {
+	const content = messageContent(message.raw);
+	const text = content.source === "none" ? message.text || message.caption : content.text;
+	const mentions = [];
+	const quoted = (offset) => content.entities.some((entity) => [
+		"code",
+		"pre",
+		"blockquote",
+		"expandable_blockquote"
+	].includes(entity.type) && offset >= entity.offset && offset < entity.offset + entity.length);
+	for (const entity of content.entities) {
+		if (entity.type !== "mention" && entity.type !== "text_mention" || quoted(entity.offset)) continue;
+		const label = text.slice(entity.offset, entity.offset + entity.length);
+		if (entity.type === "text_mention") mentions.push({
+			...recipient(entity.user ?? {}, bot),
+			type: "text_mention",
+			text: label
+		});
+		else {
+			const username = entity.username ?? /^@([A-Za-z0-9_]+)$/u.exec(label)?.[1];
+			if (username !== void 0) mentions.push({
+				...recipient({ username }, bot),
+				type: "mention",
+				text: label
+			});
+		}
+	}
+	for (const match of text.matchAll(/(?<![A-Za-z0-9_@])@([A-Za-z0-9_]{1,32})(?![A-Za-z0-9_])/gu)) {
+		if (quoted(match.index)) continue;
+		const username = match[1];
+		if (mentions.some((item) => item.username?.toLowerCase() === username.toLowerCase())) continue;
+		mentions.push({
+			...recipient({ username }, bot),
+			type: "mention",
+			text: match[0]
+		});
+	}
+	const rawReply = telegramRecord(message.raw.reply_to_message);
+	const author = message.replyToMessage?.from;
+	const replyId = message.replyToMessage?.messageId ?? rawReply.message_id;
+	const replyTo = replyId === void 0 ? null : {
+		...recipient(Object.keys(telegramRecord(rawReply.from)).length > 0 ? telegramRecord(rawReply.from) : {
+			id: author?.id,
+			username: author?.username,
+			is_bot: author?.isBot,
+			first_name: author?.firstName
+		}, bot),
+		messageId: String(replyId),
+		text: messageContent(rawReply).text.slice(0, 1e3)
+	};
+	return {
+		originalText: text,
+		mentions: mentions.slice(0, 50),
+		botTagged: mentions.some((item) => item.kind === "bot"),
+		replyTo
+	};
+}
+function otherRecipient(audience) {
+	if (audience === void 0 || audience.botTagged || audience.replyTo?.kind === "bot") return;
+	if (audience.replyTo?.kind === "human" || audience.replyTo?.kind === "other_bot") return "Reply targets another person or bot; this bot was not addressed.";
+	if (audience.mentions.some((item) => item.kind !== "bot")) return "Message tags another recipient; this bot was not addressed.";
+}
+export { messageAudience, otherRecipient };

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">;