@segmentstream/agent 0.6.8 → 0.6.11

package/README.md

@@ -381,11 +381,25 @@ Apache-2.0
 
 Production Telegram webhooks archive every receivable message in the platform database,
 including automated posts and unanswered messages. The extension also records replies,
-reply/silent decisions, tool names and redacted argument summaries, results' status, and
+reply/silent decisions, tool names, redacted arguments/results/errors, and
 attachment references. It reloads stored context for the same chat/topic each turn, including
-across cold starts and compaction. File bytes and tool output bodies are not archived.
-
-Retention defaults to 365 days per workspace. Platform REST reads, the workspace ontology's
+across cold starts and compaction. File bytes are replaced by markers.
+
+The Eve hook sanitizes tool arguments, results and failure messages in `argsText`,
+`resultText` and `errorText`; ingestion re-sanitizes them. UTF-8 caps are 16/32/4 KiB, with explicit JSON
+truncation markers. Content and argument summaries expire within 30 days of the original event
+timestamp (clamped to server time); replay cannot renew that window after archive deletion.
+Embedded JSON objects and arrays are sanitized recursively. Strings under text/content/body/csv/tsv
+and file/email body fields are omitted unless they parse as JSON objects or arrays. This includes
+all CSV/TSV documents, with or without headers. `argsSummary` keeps its pre-log semantics: the SDK
+applies bounded credential and file-byte redaction, and ingestion preserves the supplied summary.
+Deploy backend migration 0043/API before upgrading to agent SDK 0.6.10.
+`segmentstream agent logs` and its `show`/`call` commands read this content
+with a human Cloud session; all members with workspace access can read DMs too.
+Runtime/model/MCP conversation readers never receive these new fields.
+
+Archive metadata and message text retain the workspace policy (365 days by default).
+Platform REST reads, the workspace ontology's
 `chat_history` and `chat_search`, and the member REST facade enforce workspace/group
 permissions and DM participant/admin scope. Deploy the backend migration/API and upgrade the
 ontology SDK along with this extension. See the repository's

package/dist/_chunks/conversation-runtime-ovs8IhXJ.mjs

@@ -0,0 +1,212 @@
+import { fileURLToPath as __eveFileURLToPath } from "node:url";
+import { dirname as __eveDirname } from "node:path";
+import { createRequire as __eveCreateRequire } from "node:module";
+const __filename = __eveFileURLToPath(import.meta.url);
+__eveDirname(__filename);
+__eveCreateRequire(import.meta.url);
+import { memberIdOf } from "../extension/lib/telegram/principal.mjs";
+import { conversationEvent, conversations, summarizeArguments } from "../extension/lib/conversations.mjs";
+import { parseAddress } from "../extension/lib/telegram/sessions.mjs";
+import { completionKind } from "../extension/lib/telegram/silent.mjs";
+const CONTENT_CAPS = {
+	args: 16384,
+	result: 32768,
+	error: 4096
+};
+const sensitive = /token|password|passwd|secret|authorization|cookie|credential|api.?key|private.?key|session|iban|card|cvv|ssn|email|phone|address|birth|document.?text|raw.?content|body|bytes|base64/i;
+const encoder = new TextEncoder();
+function luhn(value) {
+	const digits = value.replace(/\D/g, "");
+	if (digits.length < 13 || digits.length > 19) return false;
+	let sum = 0;
+	let double = false;
+	for (let i = digits.length - 1; i >= 0; i--) {
+		let n = Number(digits[i]);
+		if (double && (n *= 2) > 9) n -= 9;
+		sum += n;
+		double = !double;
+	}
+	return sum % 10 === 0;
+}
+function redactText(value) {
+	return value.replace(/[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f-\u009f]/g, "[binary data]").replace(/-----BEGIN [^-\r\n]+-----[\s\S]*?(?:-----END [^-\r\n]+-----|$)/g, "[redacted PEM]").replace(/data:[^\s"']+/gi, "[binary data]").replace(/\b(?:Bearer|Basic)\s+[A-Za-z0-9+/_=.:~\-]+/gi, "[redacted authorization]").replace(/\beyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\b/g, "[redacted JWT]").replace(/\b(?:ssw_|sscli_|sk[-_]|rk[-_])[A-Za-z0-9._~\-]+/gi, "[redacted key]").replace(/\b([a-z][a-z0-9+.-]*:\/\/)[^\s/@]+@/gi, "$1[redacted]@").replace(/([?&](?:[^=&#\s]*(?:token|password|secret|key|signature|credential|session|auth|cookie)[^=&#\s]*|sig)=)[^&#\s"']*/gi, "$1[redacted]").replace(/((?:["']?)(?:[\w-]*(?:token|password|passwd|secret|authorization|cookie|credential|api.?key|private.?key|session|iban|card|cvv|ssn)[\w-]*)(?:["']?)\s*[:=]\s*)(?:"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|[^\s,;})]+)/gi, "$1[redacted]").replace(/\b[A-Z]{2}\d{2}(?:[ -]?[A-Z0-9]){11,30}\b/gi, "[redacted IBAN]").replace(/\b\d(?:[ -]?\d){12,18}\b/g, (candidate) => luhn(candidate) ? "[redacted card]" : candidate).replace(/[A-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[A-Z0-9](?:[A-Z0-9.-]*[A-Z0-9])?\.[A-Z]{2,}/gi, "[email]").replace(/\b\d{3}-\d{2}-\d{4}\b/g, "[redacted SSN]").replace(/\b[A-Za-z0-9+/]{128,}={0,2}/g, "[binary data]");
+}
+const documentField = /^(?:text|content|body|csv|tsv|file[_-]?body|email[_-]?body)$/i;
+const omittedDocument = "[omitted: unstructured document content]";
+function redactContent(value) {
+	const seen = new WeakSet();
+	let nodes = 0;
+	const visit = (item, depth, field) => {
+		if (++nodes > 5e3 || depth > 12) return "[omitted: content complexity]";
+		if (typeof item === "string") {
+			try {
+				const embedded = JSON.parse(item);
+				if (embedded !== null && typeof embedded === "object") return JSON.stringify(visit(embedded, depth + 1, field));
+			} catch {}
+			if (documentField.test(field ?? "")) return omittedDocument;
+			return redactText(item);
+		}
+		if (typeof item === "bigint") return item.toString();
+		if (item === null || typeof item !== "object") return item;
+		if (ArrayBuffer.isView(item) || item instanceof ArrayBuffer) return "[binary data]";
+		if (seen.has(item)) return "[omitted: circular]";
+		seen.add(item);
+		if (Array.isArray(item)) {
+			const entries = item.slice(0, 200).map((entry) => visit(entry, depth + 1, field));
+			if (item.length > 200) entries.push("[omitted: array entries]");
+			return entries;
+		}
+		const entries = Object.entries(item);
+		return Object.fromEntries([...entries.slice(0, 200).map(([key, entry]) => [redactText(key), sensitive.test(key) && !documentField.test(key) ? "[redacted]" : visit(entry, depth + 1, key)]), ...entries.length > 200 ? [["_omitted", "[omitted: object entries]"]] : []]);
+	};
+	return visit(value, 0);
+}
+function contentText(value, cap) {
+	if (value == null) return null;
+	let parsed = value;
+	if (typeof value === "string") try {
+		parsed = JSON.parse(value);
+	} catch {}
+	const redacted = redactContent(parsed);
+	const text = typeof redacted === "string" ? redacted : JSON.stringify(redacted) ?? "[omitted]";
+	if (encoder.encode(text).length <= cap) return text;
+	let preview = text;
+	while (true) {
+		const result = JSON.stringify({
+			truncated: true,
+			preview
+		});
+		const bytes = encoder.encode(result).length;
+		if (bytes <= cap) return result;
+		const available = Math.max(0, encoder.encode(preview).length - (bytes - cap) - 4);
+		preview = new TextDecoder().decode(encoder.encode(preview).slice(0, available), { stream: true });
+	}
+}
+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: event.data !== void 0 && "turnId" in event.data ? event.data.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),
+				argsText: contentText(action.input, CONTENT_CAPS.args),
+				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.subagentName;
+			await archive.append(conversationEvent({
+				...base,
+				eventId,
+				kind: "tool_result",
+				toolCallId: result.callId,
+				toolName: name,
+				status: event.data.status,
+				resultText: contentText("output" in result ? result.output : null, CONTENT_CAPS.result),
+				errorText: contentText(event.data.error?.message ?? (event.data.status === "failed" ? resultErrorMessage(result.output) : null), CONTENT_CAPS.error)
+			}));
+		} 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: "{}",
+			...event.type === "task.settled" ? {
+				resultText: contentText(event.data.output, CONTENT_CAPS.result),
+				errorText: contentText(event.data.error?.message, CONTENT_CAPS.error)
+			} : {},
+			status: event.type === "task.started" ? "requested" : event.data.status === "cancelled" ? "cancelled" : event.data.status === "failed" ? "failed" : "completed"
+		}));
+		else if (event.type === "turn.failed" || event.type === "step.failed") await archive.append(conversationEvent({
+			...base,
+			turnId: event.data.turnId,
+			eventId,
+			kind: "decision",
+			decision: "silent",
+			reason: event.type,
+			status: "failed",
+			errorText: contentText(event.data.message, CONTENT_CAPS.error)
+		}));
+		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
+			}))
+		}));
+	};
+}
+function resultErrorMessage(output) {
+	if (typeof output === "string") return output;
+	if (output !== null && typeof output === "object" && "message" in output && typeof output.message === "string") return output.message;
+	return null;
+}
+export { conversationRecorder as n, conversationCoordinates as t };

package/dist/_chunks/inbound-request-DRNPIIpb.mjs

@@ -0,0 +1,325 @@
+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 { isExactChatPostCard } from "../extension/lib/telegram/chat-post-card.mjs";
+import { redactDiagnostic } from "../extension/lib/diagnostics.mjs";
+import { plainTelegramText, splitTelegramText, telegramMarkdown } from "../extension/lib/telegram/format.mjs";
+import { inTelegramSendQueue } from "../extension/lib/telegram/send-queue.mjs";
+import { randomBytes } from "node:crypto";
+import { AsyncLocalStorage } from "node:async_hooks";
+const deliveryLocale = new AsyncLocalStorage();
+function withDeliveryLocale(locale, run, threadId) {
+	return deliveryLocale.run({
+		locale,
+		threadId
+	}, run);
+}
+function currentLocale() {
+	return deliveryLocale.getStore()?.locale ?? currentInboundRequest()?.locale ?? "en";
+}
+function currentThreadId() {
+	return deliveryLocale.getStore()?.threadId ?? currentInboundRequest()?.threadId;
+}
+function customerCopy(locale = currentLocale()) {
+	return locale.toLowerCase().split(/[-_]/)[0] === "ru" ? {
+		failed: "Не удалось выполнить запрос. Попробуйте ещё раз.",
+		recovery: "Не удалось продолжить разговор. Отправьте новое сообщение.",
+		attachment: "Не удалось обработать файл. Попробуйте ещё раз.",
+		authorization: "Не удалось подключиться. Попробуйте ещё раз.",
+		response: "Не удалось показать ответ. Попробуйте ещё раз.",
+		reference: "Код ошибки",
+		connected: "Доступ подключён.",
+		disconnected: "Подключение отменено."
+	} : {
+		failed: "I couldn't complete the request. Please try again.",
+		recovery: "I couldn't continue the conversation. Please send a new message.",
+		attachment: "I couldn't process the file. Please try again.",
+		authorization: "I couldn't connect. Please try again.",
+		response: "I couldn't display the response. Please try again.",
+		reference: "Error reference",
+		connected: "Access connected.",
+		disconnected: "Connection cancelled."
+	};
+}
+const TECHNICAL_PATTERNS = [
+	/[{}]|```/u,
+	/\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(?: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,
+	/\[\s*(?:"[^"]*"|\d+|true|false|null)\s*[,\]]/u
+];
+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");
+	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]\"");
+	if (Array.isArray(value)) return value.map(redactCredentials);
+	if (value !== null && typeof value === "object") return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, /^(?:token|password|secret|authorization|cookie|api_?key|access_?token|refresh_?token)$/iu.test(key) && typeof item === "string" ? "[redacted]" : redactCredentials(item)]));
+	return value;
+}
+function reportTelegramError(operation, error, metadata = {}, secrets = new Set()) {
+	const errorId = randomBytes(4).toString("hex").toUpperCase();
+	const credentials = new Set([...secrets, ...[process.env.AI_GATEWAY_API_KEY, process.env.VERCEL_OIDC_TOKEN].filter((value) => value !== void 0)]);
+	console.error("[segmentstream] Telegram delivery diagnostic", {
+		...metadata,
+		errorId,
+		operation,
+		error: redactCredentials(redactDiagnostic(error, credentials))
+	});
+	return errorId;
+}
+function failureText(errorId, kind = "failed", locale = currentLocale()) {
+	if (kind === "cancelled") return `⏹ ${errorId}`;
+	const copy = customerCopy(locale);
+	return `${copy[kind]} ${copy.reference}: ${errorId}.`;
+}
+function customerText(text, locale = currentLocale()) {
+	if (!isTechnicalText(text)) return text;
+	return failureText(reportTelegramError("technical_text_blocked", { text }), "response", locale);
+}
+function customerMessage(text, locale = currentLocale()) {
+	let message;
+	try {
+		message = telegramMarkdown(text);
+	} catch (error) {
+		reportTelegramError("markdown_render_failed", error);
+		message = {
+			text: plainTelegramText(text),
+			entities: []
+		};
+	}
+	const links = message.entities.flatMap((entity) => entity.url === void 0 ? [] : [entity.url]);
+	const visible = customerText(message.text, locale);
+	if (visible !== message.text) return {
+		text: visible,
+		entities: []
+	};
+	if (links.some(isTechnicalText)) return {
+		text: failureText(reportTelegramError("unsafe_markdown_link", new Error("Credential-bearing link refused.")), "response", locale),
+		entities: []
+	};
+	return message;
+}
+async function formattingRefused(response) {
+	if (response.status !== 400) return false;
+	const body = await response.clone().json().catch(() => null);
+	return body?.ok === false && typeof body.description === "string" && (/can't parse entities|cannot parse entities|entity (?:bounds|offset|length)|entities (?:are|too)/iu.test(body.description) || /unsupported (?:start tag|parse mode)/iu.test(body.description));
+}
+var TelegramDeliveryError = class extends Error {
+	reference;
+	delivery;
+	messageIds;
+	name = "TelegramDeliveryError";
+	constructor(reference, delivery, messageIds) {
+		super(`Telegram delivery ${delivery}; reference ${reference}. Do not automatically resend.`);
+		this.reference = reference;
+		this.delivery = delivery;
+		this.messageIds = messageIds;
+	}
+};
+function safeTelegramFetch(fetchImpl, scope = "telegram") {
+	const methods = new Set([
+		"sendMessage",
+		"editMessageText",
+		"editMessageCaption",
+		"answerCallbackQuery",
+		"sendPhoto",
+		"sendDocument",
+		"sendMediaGroup"
+	]);
+	return async (input, init) => {
+		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" && isExactChatPostCard(body[field])) body.parse_mode = "MarkdownV2";
+			if (typeof body[field] === "string" && !isExactChatPostCard(body[field])) {
+				const entityField = field === "text" ? "entities" : "caption_entities";
+				const existing = body[entityField];
+				const message = Array.isArray(existing) ? {
+					text: body[field],
+					entities: existing
+				} : customerMessage(body[field]);
+				const guarded = customerText(message.text);
+				body[field] = message.entities.some((entity) => typeof entity.url === "string" && isTechnicalText(entity.url)) ? failureText(reportTelegramError("unsafe_entity_link", new Error("Credential-bearing link refused.")), "response") : guarded;
+				if (!url.endsWith("/answerCallbackQuery")) body[entityField] = body[field] === message.text ? message.entities : [];
+				delete body.parse_mode;
+			}
+		}
+		if (Array.isArray(body.media)) body.media = body.media.map((item) => ({
+			...item,
+			...typeof item.caption === "string" ? { caption: customerText(item.caption) } : {}
+		}));
+		const markup = body.reply_markup;
+		if (Array.isArray(markup?.inline_keyboard)) markup.inline_keyboard = markup.inline_keyboard.map((row) => row.map((button) => {
+			if (typeof button.text !== "string" || !isTechnicalText(button.text)) return button;
+			reportTelegramError("technical_button_label_blocked", { text: button.text });
+			return {
+				...button,
+				text: currentLocale().startsWith("ru") ? "Продолжить" : "Continue"
+			};
+		}));
+		const send = async () => {
+			const parts = url.endsWith("/sendMessage") && typeof body.text === "string" && !isExactChatPostCard(body.text) ? splitTelegramText({
+				text: body.text,
+				entities: body.entities ?? []
+			}) : [null];
+			let first;
+			const messageIds = [];
+			const attempt = async (outgoing) => {
+				try {
+					return await fetchImpl(input, {
+						...init,
+						body: JSON.stringify(outgoing)
+					});
+				} catch (error) {
+					throw new TelegramDeliveryError(reportTelegramError("telegram_send_unknown", error, { messageIds }), "unknown", messageIds);
+				}
+			};
+			for (const [index, part] of parts.entries()) {
+				const outgoing = part === null ? { ...body } : {
+					...body,
+					text: part.text,
+					entities: part.entities
+				};
+				if (index < parts.length - 1) delete outgoing.reply_markup;
+				let response = await attempt(outgoing);
+				const entityField = typeof outgoing.text === "string" ? "entities" : "caption_entities";
+				if (Array.isArray(outgoing[entityField]) && outgoing[entityField].length > 0 && await formattingRefused(response)) {
+					delete outgoing[entityField];
+					delete outgoing.parse_mode;
+					response = await attempt(outgoing);
+				}
+				const result = await response.clone().json().catch(() => null);
+				if (url.endsWith("/sendMessage")) {
+					const id = result?.result?.message_id;
+					if (!response.ok || result?.ok !== true || typeof id !== "number" || !Number.isSafeInteger(id) || id < 1) {
+						const delivery = result?.ok === false ? "failed" : "unknown";
+						throw new TelegramDeliveryError(reportTelegramError("telegram_send_unacknowledged", {
+							status: response.status,
+							result,
+							messageIds,
+							delivery
+						}), delivery, messageIds);
+					}
+					messageIds.push(id);
+				} else if (!response.ok || result?.ok !== true) return response;
+				first ??= response;
+			}
+			if (first === void 0) throw new Error("Telegram message has no visible text; nothing was sent.");
+			return first;
+		};
+		return typeof body.chat_id === "string" || typeof body.chat_id === "number" ? inTelegramSendQueue(scope, String(body.chat_id), send) : send();
+	};
+}
+var InboundRequest = class {
+	agentDescription;
+	edited = false;
+	deliveryFailed;
+	claimTurn;
+	beginDispatch;
+	finishClaim;
+	locale;
+	threadId;
+	text;
+	files;
+	extraFiles;
+	sessions;
+	waitUntil;
+	address;
+	respond;
+	constructor(agentDescription) {
+		this.agentDescription = agentDescription;
+	}
+};
+const storage = new AsyncLocalStorage();
+function runInboundRequest(request, run) {
+	return storage.run(request, run);
+}
+function currentInboundRequest() {
+	return storage.getStore();
+}
+function replaceText(message, text) {
+	if (typeof message === "string") return text;
+	return [{
+		type: "text",
+		text
+	}, ...message.filter((part) => part.type !== "text")];
+}
+function telegramFileId(data) {
+	const href = data instanceof URL ? data.href : typeof data === "string" ? data : void 0;
+	if (href === void 0 || !href.startsWith("telegram-file:")) return;
+	try {
+		return decodeURIComponent(new URL(href).pathname);
+	} catch {
+		return;
+	}
+}
+function replaceFiles(message, files) {
+	if (typeof message === "string") return message;
+	return message.map((part) => {
+		if (part.type !== "file") return part;
+		const fileId = telegramFileId(part.data);
+		const staged = fileId === void 0 ? void 0 : files.get(fileId);
+		if (staged === void 0) return part;
+		if (staged.status === "refused") return {
+			type: "text",
+			text: `[file ${staged.filename} was not received: ${staged.reason}]`
+		};
+		if (staged.imageInput === "text") return {
+			type: "text",
+			text: `[image ${staged.attachment.filename}: ${staged.description ?? "see attachment context"}]`
+		};
+		return {
+			...part,
+			data: staged.url
+		};
+	});
+}
+function withReplacedText(source, request) {
+	return {
+		...source,
+		async send(message, options) {
+			const text = request.text === void 0 ? message : replaceText(message, request.text);
+			const files = request.files === void 0 ? text : replaceFiles(text, request.files);
+			const content = request.extraFiles === void 0 || request.extraFiles.length === 0 ? files : [...typeof files === "string" ? [{
+				type: "text",
+				text: files
+			}] : files, ...request.extraFiles];
+			let result;
+			try {
+				result = await source.send(content, {
+					...options,
+					turnPolicy: "queue"
+				});
+			} catch (error) {
+				try {
+					await request.finishClaim?.(false);
+					await request.deliveryFailed?.(error);
+				} catch (cleanupError) {
+					console.error("[segmentstream] inbound delivery cleanup failed", {
+						cleanupError,
+						cause: error
+					});
+				}
+				throw error;
+			}
+			try {
+				await request.finishClaim?.(true);
+			} catch (error) {
+				reportTelegramError("turn_admission_recording_failed", error);
+			}
+			return result;
+		}
+	};
+}
+export { TelegramDeliveryError as a, customerCopy as c, failureText as d, formattingRefused as f, withDeliveryLocale as g, safeTelegramFetch as h, withReplacedText as i, customerMessage as l, reportTelegramError as m, currentInboundRequest as n, currentLocale as o, isTechnicalText as p, runInboundRequest as r, currentThreadId as s, InboundRequest as t, customerText as u };

package/dist/extension/hooks/conversations.mjs

@@ -4,7 +4,7 @@ import { createRequire as __eveCreateRequire } from "node:module";
 const __filename = __eveFileURLToPath(import.meta.url);
 __eveDirname(__filename);
 __eveCreateRequire(import.meta.url);
-import { conversationRecorder } from "../lib/conversation-runtime.mjs";
+import { n as conversationRecorder } from "../../_chunks/conversation-runtime-ovs8IhXJ.mjs";
 import { defineHook } from "eve/hooks";
 var conversations_default = defineHook({ events: { "*": conversationRecorder() } });
 export { conversations_default as default };

package/dist/extension/instructions/conversations.mjs

@@ -5,7 +5,7 @@ const __filename = __eveFileURLToPath(import.meta.url);
 __eveDirname(__filename);
 __eveCreateRequire(import.meta.url);
 import { conversations, storedConversationContext } from "../lib/conversations.mjs";
-import { conversationCoordinates } from "../lib/conversation-runtime.mjs";
+import { t as conversationCoordinates } from "../../_chunks/conversation-runtime-ovs8IhXJ.mjs";
 import { defineDynamic, defineInstructions } from "eve/instructions";
 const archive = conversations();
 var conversations_default = defineDynamic({ events: { "turn.started": async (_event, context) => {

package/dist/extension/instructions.md

@@ -19,6 +19,10 @@ talking to you, and you act with exactly their permissions.
 - Ask only when information is missing or ambiguous. In Telegram, use
   `segmentstream__questions_ask` with the question and pending task so the session keeps its intent,
   member and chat/topic. An answer to a pending question is never chatter or `[SILENT]`.
+- New messages and uploads may arrive together or while you are working. Complete or explicitly
+  report the status of every request and every supplied file. A later message adds work unless
+  the member explicitly cancels or replaces the earlier task. If work is interrupted or blocked,
+  say what remains unfinished; never silently replace it with the latest question.
 - Destructive or irreversible actions, and legacy custom actions without safety labels, require
   the tool boundary's Confirm / Cancel buttons. Call the action to start that flow; never ask for
   approval in prose or treat a text acknowledgement as approval. Wait for the button outcome.