@segmentstream/agent 0.6.10 → 0.6.12

package/README.md

@@ -79,14 +79,16 @@ Both entry points export the same handle: `@segmentstream/agent` and
 }
 ```
 
-| Field                          | Default               | Meaning                                                                                                                  |
-| ------------------------------ | --------------------- | ------------------------------------------------------------------------------------------------------------------------ |
-| `channels.telegram.connection` | none                  | The Connect key whose credential is the bot token. Without `channels.telegram`, no Telegram.                             |
-| `channels.telegram.policy`     | `"smart"`             | Unaddressed group text: `smart` asks the decision model, `mention` observes; attachments always trigger a turn           |
-| `models.stt`                   | `"spacexai/grok-stt"` | The AI Gateway transcription model for voice messages; `false` leaves them untranscribed                                 |
-| `models.imageDescription`      | automatic             | A separate vision model for ingestion descriptions; omitted prefers native images, `false` disables description fallback |
-| `models.decision`              | `"typesafe-ai/jev"`   | The AI Gateway decision model of the inbound router                                                                      |
-| `ontology.connection`          | `true`                | Whether the agent reaches the ontology over MCP                                                                          |
+| Field                                    | Default               | Meaning                                                                                                                                             |
+| ---------------------------------------- | --------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `channels.telegram.connection`           | none                  | The Connect key whose credential is the bot token. Without `channels.telegram`, no Telegram.                                                        |
+| `channels.telegram.policy`               | `"smart"`             | Unaddressed group text: `smart` asks the decision model, `mention` observes; attachments always trigger a turn                                      |
+| `channels.telegram.linkPreviews`         | `all`                 | Keep native first-link previews; opt into `external` to preview external links only, or `none` to disable previews. Caller options take precedence. |
+| `channels.telegram.additionalOwnOrigins` | `[]`                  | Additional exact HTTP(S) workspace origins, including local ports; no paths or credentials.                                                         |
+| `models.stt`                             | `"spacexai/grok-stt"` | The AI Gateway transcription model for voice messages; `false` leaves them untranscribed                                                            |
+| `models.imageDescription`                | automatic             | A separate vision model for ingestion descriptions; omitted prefers native images, `false` disables description fallback                            |
+| `models.decision`                        | `"typesafe-ai/jev"`   | The AI Gateway decision model of the inbound router                                                                                                 |
+| `ontology.connection`                    | `true`                | Whether the agent reaches the ontology over MCP                                                                                                     |
 
 An unknown field or an invalid value fails the mount with `SegmentStreamAgentConfigError`, naming
 each path. `manifestOf(config)` returns the normalized configuration, defaults applied, for the

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

@@ -0,0 +1,333 @@
+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 { chatPostCardLinks, 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 { telegramPreviewOptions, telegramTextLinks } from "@segmentstream-cloud/ontology/telegram";
+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", previews = {}) {
+	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 {
+					const previewOptions = (url.endsWith("/sendMessage") || url.endsWith("/editMessageText")) && typeof outgoing.text === "string" ? telegramPreviewOptions(body, chatPostCardLinks(outgoing.text) ?? telegramTextLinks(outgoing.text, outgoing.entities ?? []), previews) : {};
+					const payload = { ...outgoing };
+					if (url.endsWith("/sendMessage") || url.endsWith("/editMessageText")) {
+						delete payload.link_preview_options;
+						delete payload.disable_web_page_preview;
+						Object.assign(payload, previewOptions);
+					}
+					return await fetchImpl(input, {
+						...init,
+						body: JSON.stringify(payload)
+					});
+				} 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/config.d.ts

@@ -1,11 +1,4 @@
-/**
- * The extension's configuration: `agent/segmentstream.json`, mounted by
- * `agent/agent/extensions/segmentstream.ts` and read by the platform at deploy.
- *
- * eve validates a mount's configuration with a Standard Schema. The schema below is written by
- * hand, so the package adds no second schema library next to the Effect Schema the rest of the
- * repository uses.
- */
+import { type TelegramLinkPreviews } from "@segmentstream-cloud/ontology/telegram";
 export declare const TELEGRAM_POLICIES: readonly ["mention", "smart"];
 /**
  * How the Telegram channel treats group messages that do not address the bot: `smart` asks the
@@ -28,6 +21,10 @@ export interface SegmentStreamAgentConfigInput {
             readonly connection: string;
             /** `smart` (default) or `mention`. */
             readonly policy?: string;
+            /** Telegram’s native first link (default), external links only, or no previews. */
+            readonly linkPreviews?: string;
+            /** Additional exact HTTP(S) origins belonging to this workspace. */
+            readonly additionalOwnOrigins?: readonly string[];
         };
     };
     readonly models?: {
@@ -72,6 +69,8 @@ export interface SegmentStreamAgentConfigInput {
 export interface TelegramSettings {
     readonly connection: string;
     readonly policy: TelegramPolicy;
+    readonly linkPreviews?: TelegramLinkPreviews;
+    readonly additionalOwnOrigins?: readonly string[];
 }
 /** The chat models `segmentstream.model()` chooses between, as AI Gateway model ids. */
 export interface ChatModelChoice {

package/dist/extension/config.mjs

@@ -4,6 +4,7 @@ import { createRequire as __eveCreateRequire } from "node:module";
 const __filename = __eveFileURLToPath(import.meta.url);
 __eveDirname(__filename);
 __eveCreateRequire(import.meta.url);
+import { TELEGRAM_LINK_PREVIEWS, isHttpOrigin } from "@segmentstream-cloud/ontology/telegram";
 const CONNECTION_KEY = /^[a-z][a-z0-9_]{0,63}$/;
 const TELEGRAM_POLICIES = ["mention", "smart"];
 const DEFAULT_STT_MODEL = "spacexai/grok-stt";
@@ -44,7 +45,12 @@ function telegramSettings(value, issues) {
 	const telegram = section({
 		value,
 		path,
-		allowed: ["connection", "policy"],
+		allowed: [
+			"connection",
+			"policy",
+			"linkPreviews",
+			"additionalOwnOrigins"
+		],
 		issues
 	});
 	if (telegram === void 0) return null;
@@ -58,9 +64,21 @@ function telegramSettings(value, issues) {
 		message: "must be \"smart\" or \"mention\"",
 		path: [...path, "policy"]
 	});
+	const linkPreviews = telegram.linkPreviews === void 0 ? "all" : telegram.linkPreviews;
+	const additionalOwnOrigins = telegram.additionalOwnOrigins === void 0 ? [] : telegram.additionalOwnOrigins;
+	if (!TELEGRAM_LINK_PREVIEWS.some((mode) => mode === linkPreviews)) issues.push({
+		message: "must be \"external\", \"none\" or \"all\"",
+		path: [...path, "linkPreviews"]
+	});
+	if (!Array.isArray(additionalOwnOrigins) || !additionalOwnOrigins.every(isHttpOrigin)) issues.push({
+		message: "must be an array of HTTP(S) origins without paths, credentials, queries or fragments",
+		path: [...path, "additionalOwnOrigins"]
+	});
 	return typeof connection === "string" && isTelegramPolicy(policy) ? {
 		connection,
-		policy
+		policy,
+		linkPreviews,
+		additionalOwnOrigins
 	} : null;
 }
 function modelId(input) {

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.

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

@@ -55,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-DgyI7oR9.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";
@@ -33,6 +32,7 @@ import { TELEGRAM_PLACEHOLDER_TOKEN, TELEGRAM_PROXY_ORIGIN, telegramProxyFetch }
 import { healthRoute } from "./health.mjs";
 import { telegramFailureEvents } from "./turn-errors.mjs";
 import { telegramWebhookVerifier } from "./webhook.mjs";
+import { telegramPreviewEnvironment } from "@segmentstream-cloud/ontology/telegram";
 import { telegramChannel } from "eve/channels/telegram";
 const eveHistory = async (sessionId) => {
 	const { sessions } = await import("eve/server");
@@ -125,10 +125,14 @@ function segmentstreamTelegram(options) {
 		return store;
 	}
 	const channel = telegramChannel({
+		turnPolicy: "queue",
 		api: {
 			apiBaseUrl: TELEGRAM_PROXY_ORIGIN,
 			fileBaseUrl: TELEGRAM_PROXY_ORIGIN,
-			fetch: (input, init) => safeTelegramFetch(captureTelegramFetch(telegramProxyFetch(proxy(), telegramSendScope(environment, settings().connection)), archive, pairing), telegramSendScope(environment, settings().connection))(input, init)
+			fetch: (input, init) => safeTelegramFetch(captureTelegramFetch(telegramProxyFetch(proxy(), telegramSendScope(environment, settings().connection)), archive, pairing), telegramSendScope(environment, settings().connection), {
+				settings: settings(),
+				ownOrigins: telegramPreviewEnvironment(environment).appOrigins
+			})(input, init)
 		},
 		credentials: {
 			botToken: TELEGRAM_PLACEHOLDER_TOKEN,
@@ -201,7 +205,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 +323,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-DgyI7oR9.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/chat-post-card.d.ts

@@ -1,8 +1,9 @@
 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 withChatPostCard<T>(text: string, run: () => T, links?: readonly string[]): T;
 export declare function isExactChatPostCard(text: string): boolean;
+export declare function chatPostCardLinks(text: string): readonly string[] | undefined;
 export declare function chatPostCopy(locale: string): {
     edit: string;
     changes: string;