@segmentstream/agent 0.6.8 → 0.6.11

package/dist/extension/lib/conversation-runtime.mjs

@@ -4,113 +4,5 @@ import { createRequire as __eveCreateRequire } from "node:module";
 const __filename = __eveFileURLToPath(import.meta.url);
 __eveDirname(__filename);
 __eveCreateRequire(import.meta.url);
-import { memberIdOf } from "./telegram/principal.mjs";
-import { conversationEvent, conversations, summarizeArguments } from "./conversations.mjs";
-import { parseAddress } from "./telegram/sessions.mjs";
-import { completionKind } from "./telegram/silent.mjs";
-function conversationCoordinates(context) {
-	const principal = context.session.auth.current;
-	const telegram = principal?.authenticator === "segmentstream-telegram" || context.channel.kind?.includes("telegram");
-	const address = context.channel.continuationToken;
-	const attributes = principal?.attributes;
-	const fields = address?.split(":");
-	const localAddress = telegram && fields?.length === 4 ? fields.slice(1).join(":") : address;
-	const parsed = telegram && localAddress !== void 0 && /^-?\d+:\d*:\d*$/u.test(localAddress) ? parseAddress(localAddress) : void 0;
-	const attributeChatId = typeof attributes?.chatId === "string" && (!telegram || /^-?\d+$/u.test(attributes.chatId)) ? attributes.chatId : void 0;
-	const chatId = telegram ? parsed?.chatId ?? attributeChatId : attributeChatId !== void 0 ? attributeChatId : address;
-	if (!chatId) return;
-	const memberId = memberIdOf(principal);
-	const chatType = attributes?.chatType;
-	return {
-		provider: telegram ? "telegram" : context.channel.kind ?? "eve",
-		chatId,
-		chatType: chatType === "group" || chatType === "supergroup" || chatType === void 0 && telegram && chatId.startsWith("-") ? "group" : chatType === "channel" ? "channel" : "private",
-		threadId: !telegram ? null : parsed !== void 0 ? parsed.messageThreadId || null : typeof attributes?.messageThreadId === "string" ? attributes.messageThreadId : null,
-		participantIds: memberId === void 0 ? [] : [memberId],
-		senderId: principal?.subject ?? null
-	};
-}
-function conversationRecorder(archive = conversations()) {
-	return async (event, context) => {
-		const coordinates = conversationCoordinates(context);
-		if (coordinates === void 0) return;
-		const base = {
-			...coordinates,
-			sessionId: context.session.id,
-			turnId: context.session.turn.id,
-			at: event.meta.at
-		};
-		const eventId = `eve:${context.session.id}:${event.meta.id}`;
-		if (event.type === "actions.requested") for (const action of event.data.actions) {
-			const name = "toolName" in action ? action.toolName : action.name;
-			await archive.append(conversationEvent({
-				...base,
-				eventId: `${eventId}:${action.callId}`,
-				kind: "tool_call",
-				toolCallId: action.callId,
-				toolName: name,
-				argsSummary: summarizeArguments(action.input),
-				status: "requested"
-			}));
-		}
-		else if (event.type === "action.result") {
-			const result = event.data.result;
-			const name = "toolName" in result ? result.toolName : "name" in result ? result.name : result.kind;
-			await archive.append(conversationEvent({
-				...base,
-				eventId,
-				kind: "tool_result",
-				toolCallId: result.callId,
-				toolName: name,
-				status: event.data.status
-			}));
-		} else if (event.type === "task.started" || event.type === "task.settled") await archive.append(conversationEvent({
-			...base,
-			eventId,
-			kind: event.type === "task.started" ? "tool_call" : "tool_result",
-			toolCallId: event.data.callId,
-			toolName: event.data.name ?? "task",
-			argsSummary: "{}",
-			status: event.type === "task.started" ? "requested" : event.data.status === "cancelled" ? "cancelled" : event.data.status === "failed" ? "failed" : "completed"
-		}));
-		else if (event.type === "message.completed" && event.data.finishReason !== "tool-calls") {
-			const kind = completionKind(event.data.message, event.data.finishReason);
-			const silent = kind !== "reply";
-			const note = kind === "silent_marker" ? "Model returned an explicit silence marker; no message delivery." : kind === "empty" ? "Model completed without final text; no message delivery." : kind === "whitespace" ? "Model returned only whitespace; no message delivery." : "Model produced a reply; transport delivery is recorded separately.";
-			await archive.append(conversationEvent({
-				...base,
-				eventId,
-				kind: "decision",
-				decision: silent ? "silent" : "reply",
-				reason: kind === "reply" ? "model_reply" : `model_${kind}_output`,
-				text: note,
-				argsSummary: JSON.stringify({
-					outputKind: kind,
-					outputCharacters: event.data.message?.length ?? 0,
-					finishReason: event.data.finishReason
-				})
-			}));
-			if (coordinates.provider !== "telegram" && !silent) await archive.append(conversationEvent({
-				...base,
-				eventId: `${eventId}:outbound`,
-				kind: "outbound",
-				text: event.data.message,
-				senderId: "agent",
-				senderIsBot: true,
-				status: "completed"
-			}));
-		} else if (event.type === "message.received" && coordinates.provider !== "telegram") await archive.append(conversationEvent({
-			...base,
-			eventId,
-			kind: "inbound",
-			text: event.data.message,
-			attachments: (event.data.parts ?? []).filter((part) => part.type === "file").map((part, index) => ({
-				id: `${eventId}:file:${index}`,
-				kind: "file",
-				...part.filename ? { filename: part.filename } : {},
-				contentType: part.mediaType
-			}))
-		}));
-	};
-}
+import { n as conversationRecorder, t as conversationCoordinates } from "../../_chunks/conversation-runtime-ovs8IhXJ.mjs";
 export { conversationCoordinates, conversationRecorder };

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

@@ -1,6 +1,6 @@
 import { type Environment } from "./environment.js";
 import { type RuntimeToken } from "./runtime-token.js";
-/** Provider-neutral platform archive. Only references and summaries cross this boundary. */
+/** Provider-neutral platform archive. Content uses the shared redaction and byte-limit policy. */
 export interface ConversationEvent {
     readonly eventId: string;
     readonly provider: string;
@@ -22,6 +22,9 @@ export interface ConversationEvent {
     readonly toolCallId: string | null;
     readonly toolName: string | null;
     readonly argsSummary: string | null;
+    readonly argsText?: string | null;
+    readonly resultText?: string | null;
+    readonly errorText?: string | null;
     readonly status: "requested" | "completed" | "failed" | "rejected" | "cancelled" | "unknown" | "sent" | "uncertain" | null;
     readonly operationId?: string | null;
     readonly requestedBy?: {
@@ -52,12 +55,20 @@ export interface ConversationPage {
     readonly nextCursor: string | null;
 }
 export interface Conversations {
-    append(event: ConversationEvent): Promise<void>;
+    /** True only for the first insert of this event ID. Legacy custom archives may omit the result, but Telegram dispatch requires explicit true. */
+    append(event: ConversationEvent): Promise<boolean | void>;
     context(input: {
         readonly provider: string;
         readonly chatId: string;
         readonly threadId?: string;
         readonly limit?: number;
+        /** Read routing audit records as this chat's reader, rather than model transcript only. */
+        readonly includeDecisions?: boolean;
+        readonly participantId?: string;
+        readonly before?: string;
+        readonly from?: string;
+        readonly senderId?: string;
+        readonly messageId?: string;
     }): Promise<ConversationPage>;
 }
 /** Collapse delivery snapshots from older archives before building a user/model transcript. */

package/dist/extension/lib/conversations.mjs

@@ -66,14 +66,14 @@ function conversations(input = {}) {
 	}
 	return {
 		append: async (event) => {
-			await call("events", event);
+			return (await call("events", event)).stored;
 		},
-		context: async (search) => await call("search", {
+		context: async ({ includeDecisions, participantId, ...search }) => await call("search", {
 			search,
-			context: true,
+			context: !includeDecisions,
 			reader: {
-				participantId: null,
-				groups: false,
+				participantId: participantId ?? null,
+				groups: includeDecisions === true,
 				admin: false
 			}
 		})

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

@@ -13,10 +13,9 @@ import { agentAttachments, parseAttachmentUrl } from "../attachments.mjs";
 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 { d as failureText, g as withDeliveryLocale, h as safeTelegramFetch, i as withReplacedText, m as reportTelegramError, n as currentInboundRequest, r as runInboundRequest, t as InboundRequest } from "../../../_chunks/inbound-request-DRNPIIpb.mjs";
+import { captureRouteDecider, captureTelegramFetch, conversationIdentities, recordGateDecision, telegramConversationCapture } from "./conversations.mjs";
 import { runtimeTokenVerifier } from "../runtime-identity.mjs";
 import { botIdentityCache } from "./bot.mjs";
 import { confirmationLocale, confirmationRenderer } from "./confirmation-text.mjs";
@@ -125,6 +124,7 @@ function segmentstreamTelegram(options) {
 		return store;
 	}
 	const channel = telegramChannel({
+		turnPolicy: "queue",
 		api: {
 			apiBaseUrl: TELEGRAM_PROXY_ORIGIN,
 			fileBaseUrl: TELEGRAM_PROXY_ORIGIN,
@@ -201,7 +201,21 @@ function segmentstreamTelegram(options) {
 						connectUrl: (code) => `${appOrigin(environment)}/agent/connect?code=${encodeURIComponent(code)}`
 					}
 				});
-				if (inbound !== void 0 && result !== null) inbound.locale = confirmationLocale(result.auth);
+				if (inbound !== void 0 && result !== null) {
+					inbound.locale = confirmationLocale(result.auth);
+					inbound.deliveryFailed = async (error) => {
+						recordGateDecision("inbound_delivery_failed");
+						const errorId = reportTelegramError("inbound_delivery_failed", error, {
+							chatId: message.chat.id,
+							messageId: message.messageId
+						});
+						try {
+							await context.telegram.post(failureText(errorId));
+						} catch (noticeError) {
+							reportTelegramError("inbound_failure_notice_failed", noticeError, { errorId });
+						}
+					};
+				}
 				return result;
 			} catch (error) {
 				const errorId = reportTelegramError("inbound_message_failed", error, { chatId: message.chat.id });
@@ -305,8 +319,8 @@ function gatedRoute(input) {
 				args.waitUntil(task);
 			};
 			inbound.waitUntil = waitUntil;
-			return runInboundRequest(inbound, () => input.capture(request, async () => {
-				const response = await route.handler(request, {
+			return runInboundRequest(inbound, () => input.capture(request, async (routedRequest = request) => {
+				const response = await route.handler(routedRequest, {
 					...args,
 					waitUntil,
 					from: (address) => withReplacedText(args.from(inbound.address ?? scoped(address)), inbound)

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

@@ -12,7 +12,7 @@ import { runtimeToken } from "../runtime-token.mjs";
 import { ACT_AS_HEADER } from "../ontology-connection.mjs";
 import { AttachmentError, CONVERSATION_HEADER, SESSION_HEADER } from "../attachments.mjs";
 import { inTelegramSendQueue, telegramSendScope } from "./send-queue.mjs";
-import { customerCopy, customerMessage, formattingRefused, reportTelegramError } from "./customer-text.mjs";
+import { c as customerCopy, f as formattingRefused, l as customerMessage, m as reportTelegramError } from "../../../_chunks/inbound-request-DRNPIIpb.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";

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

@@ -17,10 +17,14 @@ export interface MessageAudience {
     readonly replyTo: (Recipient & {
         readonly messageId: string;
         readonly text: string;
+        /** A reply can quote evidence instead of addressing its uploader. */
+        readonly hasAttachments?: boolean;
+        readonly filename?: string;
+        readonly self?: boolean;
     }) | 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. */
+/** Explicit recipients win; quoting an upload or one's own message goes to smart inference. */
 export declare function otherRecipient(audience: MessageAudience | undefined): string | undefined;
 export {};

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

@@ -53,6 +53,7 @@ function messageAudience(message, bot) {
 		});
 	}
 	const rawReply = telegramRecord(message.raw.reply_to_message);
+	const documentName = telegramRecord(rawReply.document).file_name;
 	const author = message.replyToMessage?.from;
 	const replyId = message.replyToMessage?.messageId ?? rawReply.message_id;
 	const replyTo = replyId === void 0 ? null : {
@@ -63,7 +64,19 @@ function messageAudience(message, bot) {
 			first_name: author?.firstName
 		}, bot),
 		messageId: String(replyId),
-		text: messageContent(rawReply).text.slice(0, 1e3)
+		text: messageContent(rawReply).text.slice(0, 1e3),
+		...typeof documentName === "string" ? { filename: documentName } : {},
+		hasAttachments: [
+			"document",
+			"photo",
+			"voice",
+			"audio",
+			"video",
+			"video_note",
+			"sticker",
+			"animation"
+		].some((kind) => rawReply[kind] !== void 0),
+		self: message.from !== void 0 && String(telegramRecord(rawReply.from).id ?? author?.id) === message.from.id
 	};
 	return {
 		originalText: text,
@@ -74,7 +87,7 @@ function messageAudience(message, bot) {
 }
 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.";
+	if (audience.replyTo?.kind === "other_bot" || audience.replyTo?.kind === "human" && !audience.replyTo.hasAttachments && !audience.replyTo.self) return "Reply targets another person or bot; this bot was not addressed.";
 }
 export { messageAudience, otherRecipient };

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

@@ -9,8 +9,7 @@ import { chatPostOperationId, isChatPost } from "../chat-post-confirmation.mjs";
 import { chatPostCard, chatPostCardStatus, 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 { d as failureText, m as reportTelegramError, n as currentInboundRequest, o as currentLocale } from "../../../_chunks/inbound-request-DRNPIIpb.mjs";
 import { answerMarker, isPendingQuestion, pendingQuestions, questionKey } from "../questions.mjs";
 import { confirmationCopy, confirmationLocale, fallbackConfirmation } from "./confirmation-text.mjs";
 import { formatAddress, scopedAddress } from "./sessions.mjs";

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

@@ -10,7 +10,7 @@ export declare function captureTelegramWebhook(input: {
     readonly identities: AgentIdentities;
     readonly observed: ObservedMessages;
     readonly chats?: AgentChats;
-    readonly next: () => Promise<Response>;
+    readonly next: (request?: Request) => Promise<Response>;
 }): Promise<Response>;
 /** Additive inbound hook: the router keeps ownership of the reply policy. */
 export declare function recordGateDecision(reason: string, decision?: "reply" | "silent"): void;
@@ -27,4 +27,4 @@ export declare function telegramConversationCapture(input: {
     readonly observed: ObservedMessages;
     readonly chats: AgentChats;
     readonly verify: (request: Request) => boolean;
-}): (request: Request, next: () => Promise<Response>) => Promise<Response>;
+}): (request: Request, next: (request?: Request) => Promise<Response>) => Promise<Response>;

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

@@ -6,12 +6,11 @@ __eveDirname(__filename);
 __eveCreateRequire(import.meta.url);
 import { collapseConversationEvents, conversationEvent } from "../conversations.mjs";
 import { observedChatKey } from "./observed.mjs";
-import { currentInboundRequest } from "./inbound-request.mjs";
+import { n as currentInboundRequest, s as currentThreadId } from "../../../_chunks/inbound-request-DRNPIIpb.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";
+import { createHash, randomUUID } from "node:crypto";
 const captures = new WeakMap();
 const record = (value) => value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
 const id = (value) => typeof value === "number" || typeof value === "string" ? String(value) : null;
@@ -124,21 +123,37 @@ async function captureTelegramWebhook(input) {
 		chatId: message.chat.id,
 		...message.messageThreadId === void 0 ? {} : { messageThreadId: message.messageThreadId }
 	});
-	if (!(message.from === void 0 || message.from.isBot || message.chat.type === "channel") && edited === void 0) {
-		const history = await input.archive.context({
-			provider: "telegram",
-			chatId: message.chat.id,
-			...event.threadId === null ? {} : { threadId: event.threadId },
-			limit: 100
-		});
-		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 {
+	const automated = message.from === void 0 || message.from.isBot || message.chat.type === "channel";
+	const history = automated ? void 0 : await input.archive.context({
+		provider: "telegram",
+		chatId: message.chat.id,
+		...event.threadId === null ? {} : { threadId: event.threadId },
+		limit: 100,
+		includeDecisions: true,
+		...lookup?.status === "paired" ? { participantId: lookup.member.id } : {}
+	});
+	const routing = automated ? [] : (await input.archive.context({
+		provider: "telegram",
+		chatId: message.chat.id,
+		messageId: message.messageId,
+		includeDecisions: true,
+		limit: 100,
+		...lookup?.status === "paired" ? { participantId: lookup.member.id } : {}
+	})).events.filter((earlier) => earlier.kind === "decision" && earlier.senderId === event.senderId);
+	const previousClaim = routing.find((earlier) => earlier.reason === "turn_claimed");
+	const admitted = routing.some((earlier) => earlier.reason === "turn_admitted");
+	const released = previousClaim !== void 0 && routing.some((earlier) => earlier.eventId === `${previousClaim.eventId}:released`);
+	const dispatched = routing.some((earlier) => earlier.reason === "turn_dispatch_started");
+	const reserved = previousClaim !== void 0 && !released && Date.now() - Date.parse(previousClaim.at) < 6e5;
+	const alreadyHandled = admitted || dispatched || reserved;
+	if (!automated && edited === void 0 && !alreadyHandled) for (const earlier of (input.observed.recent(chat).length === 0 ? collapseConversationEvents(history?.events ?? []) : []).filter((item) => item.kind === "inbound" && item.eventId !== event.eventId && !history?.events.some((decision) => decision.kind === "decision" && decision.messageId === item.messageId && decision.reason === "turn_admitted")).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 if (automated || edited !== void 0) {
 		if (message.chat.type === "group" || message.chat.type === "supergroup") await input.chats?.seen({
 			chatId: message.chat.id,
 			title: message.chat.title ?? ""
@@ -150,13 +165,64 @@ async function captureTelegramWebhook(input) {
 			messageId: message.messageId
 		});
 		capture.decision = "silent";
-		capture.reason = edited !== void 0 ? "message_edit" : "automated_or_channel_message";
+		capture.reason = automated ? "automated_or_channel_message" : alreadyHandled ? "message_already_handled" : "message_edit";
+		if (alreadyHandled) capture.note = "This message already started a turn; edits and retries do not repeat its task.";
+	}
+	if (alreadyHandled) {
+		capture.decision = "silent";
+		capture.reason = "message_already_handled";
+	}
+	if (inbound !== void 0) {
+		inbound.edited = edited !== void 0;
+		const nextClaim = previousClaim === void 0 ? void 0 : createHash("sha256").update(previousClaim.eventId).digest("hex");
+		const claimId = previousClaim === void 0 ? `telegram:${message.chat.id}:${message.messageId}:turn` : `telegram:${message.chat.id}:${message.messageId}:turn:${nextClaim}`;
+		let claimed = false;
+		let accepted = false;
+		let dispatchStarted = false;
+		const claimEvent = (reason, status, suffix = "") => ({
+			...event,
+			eventId: `${claimId}${suffix}`,
+			kind: "decision",
+			decision: "reply",
+			reason,
+			status,
+			at: new Date().toISOString(),
+			text: null,
+			attachments: []
+		});
+		inbound.claimTurn = async () => {
+			if (alreadyHandled) return false;
+			claimed = await input.archive.append(claimEvent("turn_claimed", "requested")) !== false;
+			return claimed;
+		};
+		inbound.beginDispatch = async () => {
+			dispatchStarted = await input.archive.append({
+				...claimEvent("turn_dispatch_started", "requested"),
+				eventId: `telegram:${message.chat.id}:${message.messageId}:dispatch`
+			}) === true;
+			return dispatchStarted;
+		};
+		inbound.finishClaim = async (delivered) => {
+			if ((accepted || dispatchStarted) && !delivered) return;
+			accepted ||= delivered;
+			if (claimed) {
+				await input.archive.append(claimEvent(delivered ? "turn_admitted" : "turn_released", delivered ? "completed" : "failed", delivered ? ":admitted" : ":released"));
+				claimed = false;
+			}
+		};
 	}
 	let response;
 	try {
-		response = await input.next();
+		const routeEdit = edited !== void 0 && !automated && !alreadyHandled;
+		if (routeEdit) capture.reason = void 0;
+		response = await input.next(routeEdit ? new Request(input.request, { body: JSON.stringify({
+			...update,
+			edited_message: void 0,
+			message: messagePayload
+		}) }) : alreadyHandled ? new Request(input.request, { body: JSON.stringify({ update_id: update.update_id }) }) : void 0);
 	} catch (error) {
 		try {
+			await inbound?.finishClaim?.(false);
 			await input.archive.append({
 				...event,
 				eventId: `${event.eventId}:decision`,
@@ -174,6 +240,7 @@ async function captureTelegramWebhook(input) {
 		}
 		throw error;
 	}
+	await inbound?.finishClaim?.(false);
 	await input.archive.append({
 		...event,
 		eventId: `${event.eventId}:decision`,
@@ -192,6 +259,7 @@ function recordGateDecision(reason, decision = "silent") {
 	if (capture !== void 0) {
 		capture.reason = reason;
 		capture.decision = decision;
+		capture.note = void 0;
 	}
 }
 function recordRouteDecision(route, addressed, policy, audit) {
@@ -295,15 +363,31 @@ function conversationIdentities(identities) {
 	};
 }
 function telegramConversationCapture(input) {
+	const processing = new Map();
 	return async (request, next) => {
 		if (!input.verify(request)) return next();
 		try {
-			return await captureTelegramWebhook({
-				...input,
-				request,
-				identities: input.identities(),
-				next
-			});
+			const update = record(await request.clone().json().catch(() => null));
+			const payload = record(update.edited_message ?? update.message);
+			const chatId = id(record(payload.chat).id);
+			const messageId = id(payload.message_id);
+			const key = chatId === null || messageId === null ? void 0 : `${chatId}:${messageId}`;
+			const previous = key === void 0 ? void 0 : processing.get(key);
+			const task = (async () => {
+				await previous?.catch(() => void 0);
+				return captureTelegramWebhook({
+					...input,
+					request,
+					identities: input.identities(),
+					next
+				});
+			})();
+			if (key !== void 0) processing.set(key, task);
+			try {
+				return await task;
+			} finally {
+				if (key !== void 0 && processing.get(key) === task) processing.delete(key);
+			}
 		} catch (error) {
 			console.error("[segmentstream] conversation capture failed", { error });
 			return new Response("conversation storage unavailable", { status: 503 });

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

@@ -15,7 +15,7 @@ export declare function customerCopy(locale?: string): {
 export declare function isTechnicalText(text: string): boolean;
 /** Original failures stay in operator diagnostics, joined to the public notice by a short reference. */
 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 failureText(errorId: string, kind?: "failed" | "cancelled" | "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;