@segmentstream/agent 0.5.4 → 0.6.4

package/dist/extension/lib/telegram/customer-text.mjs

@@ -4,8 +4,11 @@ import { createRequire as __eveCreateRequire } from "node:module";
 const __filename = __eveFileURLToPath(import.meta.url);
 __eveDirname(__filename);
 __eveCreateRequire(import.meta.url);
+import { isExactChatPostCard } from "./chat-post-card.mjs";
 import { redactDiagnostic } from "../diagnostics.mjs";
 import { currentInboundRequest } from "./inbound-request.mjs";
+import { plainTelegramText, splitTelegramText, telegramMarkdown } from "./format.mjs";
+import { inTelegramSendQueue } from "./send-queue.mjs";
 import { randomBytes } from "node:crypto";
 import { AsyncLocalStorage } from "node:async_hooks";
 const deliveryLocale = new AsyncLocalStorage();
@@ -83,7 +86,47 @@ function customerText(text, locale = currentLocale()) {
 	if (!isTechnicalText(text)) return text;
 	return failureText(reportTelegramError("technical_text_blocked", { text }), "response", locale);
 }
-function safeTelegramFetch(fetchImpl) {
+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",
@@ -97,7 +140,18 @@ function safeTelegramFetch(fetchImpl) {
 		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") body[field] = customerText(body[field]);
+		for (const field of ["text", "caption"]) 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) } : {}
@@ -111,10 +165,57 @@ function safeTelegramFetch(fetchImpl) {
 				text: currentLocale().startsWith("ru") ? "Продолжить" : "Continue"
 			};
 		}));
-		return fetchImpl(input, {
-			...init,
-			body: JSON.stringify(body)
-		});
+		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();
 	};
 }
-export { currentLocale, currentThreadId, customerCopy, customerText, failureText, isTechnicalText, reportTelegramError, safeTelegramFetch, withDeliveryLocale };
+export { TelegramDeliveryError, currentLocale, currentThreadId, customerCopy, customerMessage, customerText, failureText, formattingRefused, isTechnicalText, reportTelegramError, safeTelegramFetch, withDeliveryLocale };

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

@@ -0,0 +1,17 @@
+export interface TelegramEntity {
+    readonly type: string;
+    readonly offset: number;
+    readonly length: number;
+    readonly url?: string;
+    readonly language?: string;
+}
+export interface TelegramText {
+    readonly text: string;
+    readonly entities: readonly TelegramEntity[];
+}
+/** Render Markdown as visible text plus UTF-16 entities; no HTML/Markdown parse mode is needed. */
+export declare function telegramMarkdown(markdown: string): TelegramText;
+/** A failed renderer still produces customer prose, without obvious Markdown/decorative markers. */
+export declare function plainTelegramText(text: string): string;
+/** Paragraph, line, sentence, word, then hard boundaries. All lengths/offsets are UTF-16. */
+export declare function splitTelegramText(message: TelegramText, maximum?: number): readonly TelegramText[];

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

@@ -0,0 +1,171 @@
+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 { Lexer } from "marked";
+function telegramMarkdown(markdown) {
+	const source = markdown.replace(/^[ \t]*[━─═]{3,}[ \t]*$/gmu, "");
+	const entities = [];
+	let text = "";
+	let nodes = 0;
+	const append = (value) => {
+		text += value;
+	};
+	function span(type, run, extra = {}) {
+		const offset = text.length;
+		run();
+		if (text.length > offset) entities.push({
+			type,
+			offset,
+			length: text.length - offset,
+			...extra
+		});
+	}
+	function render(tokens = [], depth = 0) {
+		if (depth > 32) throw new Error("Markdown nesting exceeds the Telegram rendering limit.");
+		for (const token of tokens) {
+			if (++nodes > 2e4) throw new Error("Markdown exceeds the Telegram rendering limit.");
+			switch (token.type) {
+				case "strong":
+				case "em":
+				case "del":
+					span(token.type === "strong" ? "bold" : token.type === "em" ? "italic" : "strikethrough", () => render(token.tokens, depth + 1));
+					break;
+				case "heading":
+					span("bold", () => render(token.tokens, depth + 1));
+					append("\n\n");
+					break;
+				case "paragraph":
+					render(token.tokens, depth + 1);
+					append("\n\n");
+					break;
+				case "blockquote":
+					span("blockquote", () => render(token.tokens, depth + 1));
+					break;
+				case "codespan":
+					span("code", () => append(token.text));
+					break;
+				case "code":
+					span("pre", () => append(token.text), token.lang ? { language: token.lang.split(/\s/u)[0] } : {});
+					append("\n\n");
+					break;
+				case "link": {
+					let url;
+					try {
+						url = new URL(token.href);
+					} catch {
+						render(token.tokens, depth + 1);
+						break;
+					}
+					if (![
+						"https:",
+						"http:",
+						"mailto:",
+						"tel:"
+					].includes(url.protocol) || url.username || url.password) throw new Error("Markdown link has an unsupported or credential-bearing destination.");
+					span("text_link", () => render(token.tokens, depth + 1), { url: token.href });
+					break;
+				}
+				case "list":
+					for (const [index, item] of token.items.entries()) {
+						append(token.ordered ? `${Number(token.start) + index}. ` : "• ");
+						if (item.task) append(item.checked ? "☑ " : "☐ ");
+						render(item.tokens, depth + 1);
+						if (!text.endsWith("\n")) append("\n");
+					}
+					append("\n");
+					break;
+				case "table":
+					for (const [index, row] of [token.header, ...token.rows].entries()) {
+						for (const [cellIndex, cell] of row.entries()) {
+							if (cellIndex > 0) append(" | ");
+							if (index === 0) span("bold", () => render(cell.tokens, depth + 1));
+							else render(cell.tokens, depth + 1);
+						}
+						append("\n");
+					}
+					append("\n");
+					break;
+				case "image":
+					append(token.text);
+					break;
+				case "hr":
+					append("\n\n");
+					break;
+				case "br":
+					append("\n");
+					break;
+				case "space": break;
+				case "def": break;
+				case "text":
+					if (token.tokens) render(token.tokens, depth + 1);
+					else append(token.text);
+					break;
+				default: append("text" in token && typeof token.text === "string" ? token.text : token.raw);
+			}
+		}
+	}
+	render(Lexer.lex(source, { gfm: true }));
+	text = text.trimEnd();
+	for (const match of text.matchAll(/(?<![\w@])@[a-z][a-z0-9_]{4,31}(?!\w)/giu)) {
+		const offset = match.index;
+		const end = offset + match[0].length;
+		if (!entities.some((entity) => [
+			"code",
+			"pre",
+			"text_link"
+		].includes(entity.type) && entity.offset < end && entity.offset + entity.length > offset)) entities.push({
+			type: "mention",
+			offset,
+			length: match[0].length
+		});
+	}
+	return {
+		text,
+		entities: entities.map((entity) => ({
+			...entity,
+			length: Math.min(entity.length, text.length - entity.offset)
+		})).filter((entity) => entity.length > 0).sort((a, b) => a.offset - b.offset || b.length - a.length)
+	};
+}
+function plainTelegramText(text) {
+	return text.replace(/^[ \t]*[━─═]{3,}[ \t]*$/gmu, "").replace(/^\s*```[^\n]*\n?|```\s*$/gmu, "").replace(/!?\[([^\]]+)\]\([^\n)]+\)/gu, "$1").replace(/(?:\*\*|__|~~|`)/gu, "").replace(/(?<![\w@])([*_])([^\n*_]+)\1(?!\w)/gu, "$2").replace(/^ {0,3}(?:>\s*)+/gmu, "").replace(/^ {0,3}#{1,6}\s+/gmu, "").replace(/^ {0,3}[-*+]\s+/gmu, "• ").trim();
+}
+function splitTelegramText(message, maximum = 4096) {
+	if (!Number.isSafeInteger(maximum) || maximum < 2) throw new RangeError("Telegram split size must be at least 2 UTF-16 units.");
+	const parts = [];
+	let start = 0;
+	while (start < message.text.length) {
+		let end = Math.min(start + maximum, message.text.length);
+		if (end < message.text.length) {
+			const window = message.text.slice(start, end);
+			const paragraph = window.lastIndexOf("\n\n");
+			const line = window.lastIndexOf("\n");
+			const sentence = [...window.matchAll(/[.!?。！？][ \t]+/gu)].at(-1);
+			const word = window.lastIndexOf(" ");
+			const boundary = paragraph > 0 ? paragraph + 2 : line > 0 ? line + 1 : sentence?.index !== void 0 ? sentence.index + sentence[0].length : word > 0 ? word + 1 : maximum;
+			end = window.slice(0, boundary).trim() === "" ? Math.min(start + maximum, message.text.length) : start + boundary;
+			for (const entity of message.entities) if (entity.offset > start && entity.offset < end && entity.offset + entity.length > end) end = entity.offset;
+			if (/^[\uDC00-\uDFFF]$/u.test(message.text[end] ?? "") && /^[\uD800-\uDBFF]$/u.test(message.text[end - 1] ?? "")) end -= 1;
+		}
+		if (end <= start) end = Math.min(start + maximum, message.text.length);
+		const entities = message.entities.flatMap((entity) => {
+			const left = Math.max(start, entity.offset);
+			const right = Math.min(end, entity.offset + entity.length);
+			return right > left ? [{
+				...entity,
+				offset: left - start,
+				length: right - left
+			}] : [];
+		});
+		parts.push({
+			text: message.text.slice(start, end),
+			entities
+		});
+		start = end;
+	}
+	return parts;
+}
+export { plainTelegramText, splitTelegramText, telegramMarkdown };

package/dist/extension/lib/telegram/health.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 { runtimeRequestFailure } from "./requests.mjs";
+import { runtimeRequestFailure } from "./runtime-request.mjs";
 import { GET } from "eve/channels";
 const HEALTH_ROUTE = "/eve/v1/telegram/health";
 function healthRoute(input) {

package/dist/extension/lib/telegram/inbound-request.d.ts

@@ -42,7 +42,7 @@ export declare class InboundRequest {
     waitUntil: ((task: Promise<unknown>) => void) | undefined;
     /** Continues the exact pending question's session, including under thread scope. */
     address: string | undefined;
-    respond: ((address: string, requestId: string, decision: "approve" | "cancel", principal: SessionAuthContext) => Promise<unknown>) | undefined;
+    respond: ((address: string, requestId: string, decision: "approve" | "cancel", principal: SessionAuthContext, text?: string) => Promise<unknown>) | undefined;
     constructor(
     /** The agent's description from the compiled manifest, for the routing decision. */
     agentDescription: () => Promise<string>);

package/dist/extension/lib/telegram/proxy-fetch.d.ts

@@ -25,4 +25,4 @@ export declare function telegramProxyRoute(url: string): {
     readonly path: string;
 };
 /** The `fetch` eve's Telegram channel calls; see the module comment. */
-export declare function telegramProxyFetch(proxy: ConnectionProxy): typeof fetch;
+export declare function telegramProxyFetch(proxy: ConnectionProxy, scope?: string): typeof fetch;

package/dist/extension/lib/telegram/proxy-fetch.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 { inTelegramSendQueue } from "./send-queue.mjs";
 const TELEGRAM_PROXY_ORIGIN = "https://telegram.segmentstream.invalid";
 const TELEGRAM_PLACEHOLDER_TOKEN = "segmentstream-connection";
 const METHOD_PREFIX = `${TELEGRAM_PROXY_ORIGIN}/bot${TELEGRAM_PLACEHOLDER_TOKEN}/`;
@@ -46,7 +47,7 @@ function proxyMethod(method) {
 function hasNullBody(status) {
 	return status === 101 || status === 204 || status === 205 || status === 304;
 }
-function telegramProxyFetch(proxy) {
+function telegramProxyFetch(proxy, scope = "telegram") {
 	return async (input, init) => {
 		const route = telegramProxyRoute(requestUrl(input));
 		const request = new Request(input, init);
@@ -57,11 +58,18 @@ function telegramProxyFetch(proxy) {
 			headers: headerPairs(request.headers),
 			body: new Uint8Array(await request.arrayBuffer())
 		};
-		const reply = route.api === "file" ? await proxy.download(call) : await proxy.request(call);
-		return new Response(hasNullBody(reply.status) ? null : Buffer.from(reply.body), {
-			status: reply.status,
-			headers: reply.headers.map(([name, value]) => [name, value])
-		});
+		const send = async () => {
+			const reply = route.api === "file" ? await proxy.download(call) : await proxy.request(call);
+			return new Response(hasNullBody(reply.status) ? null : Buffer.from(reply.body), {
+				status: reply.status,
+				headers: reply.headers.map(([name, value]) => [name, value])
+			});
+		};
+		if (route.api !== "bot" || !/^\/(?:send|editMessage|deleteMessage)/u.test(route.path)) return send();
+		const type = request.headers.get("content-type") ?? "";
+		const body = type.startsWith("multipart/form-data") ? await new Response(Buffer.from(call.body), { headers: request.headers }).formData() : type.includes("application/json") ? JSON.parse(new TextDecoder().decode(call.body)) : {};
+		const chatId = body instanceof FormData ? body.get("chat_id") : body.chat_id;
+		return typeof chatId === "string" || typeof chatId === "number" ? inTelegramSendQueue(scope, String(chatId), send) : send();
 	};
 }
 export { TELEGRAM_PLACEHOLDER_TOKEN, TELEGRAM_PROXY_ORIGIN, TelegramProxyRouteError, telegramProxyFetch, telegramProxyRoute };

package/dist/extension/lib/telegram/runtime-request.d.ts

@@ -0,0 +1,8 @@
+import type { RuntimeTokenVerifier } from "../runtime-identity.js";
+/** Authenticate internal channel routes with the production deployment's runtime identity. */
+export declare function runtimeRequestFailure(request: Request, options: {
+    readonly enabled: () => boolean;
+    readonly configured: () => boolean;
+    readonly verify: () => RuntimeTokenVerifier;
+    readonly log?: (message: string, detail: unknown) => void;
+}): Promise<Response | undefined>;

package/dist/extension/lib/telegram/runtime-request.mjs

@@ -0,0 +1,36 @@
+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);
+function bearer(header) {
+	return (header === null ? null : /^Bearer\s+(\S+)$/i.exec(header.trim()))?.[1];
+}
+function error(code, status) {
+	return Response.json({ error: code }, { status });
+}
+async function runtimeRequestFailure(request, options) {
+	const log = options.log ?? ((message, detail) => console.warn(message, detail));
+	if (!options.enabled()) return error("channels_disabled", 503);
+	if (!options.configured()) return error("not_found", 404);
+	const token = bearer(request.headers.get("authorization"));
+	if (token === void 0) return error("unauthorized", 401);
+	let verifier;
+	try {
+		verifier = options.verify();
+	} catch (cause) {
+		log("The agent cannot verify requests: the runtime identity is not configured.", cause);
+		return error("unavailable", 503);
+	}
+	const verification = await verifier(token);
+	if (verification.status === "unavailable") {
+		log("The agent cannot verify requests: the runtime key set is unavailable.", verification.reason);
+		return error("unavailable", 503);
+	}
+	if (verification.status !== "valid") {
+		log("The agent refused a request with an invalid runtime token.", verification.reason);
+		return error("unauthorized", 401);
+	}
+}
+export { runtimeRequestFailure };

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

@@ -0,0 +1,4 @@
+import type { Environment } from "../environment.js";
+export declare function telegramSendScope(environment: Environment, connection: string): string;
+/** One FIFO per bot/chat in this runtime, shared by all adapters, topics and attachment tools. */
+export declare function inTelegramSendQueue<T>(scope: string, chatId: string, run: () => Promise<T>): Promise<T>;

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

@@ -0,0 +1,35 @@
+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 pending = new Map();
+const held = new AsyncLocalStorage();
+function telegramSendScope(environment, connection) {
+	return JSON.stringify([environment.SEGMENTSTREAM_WORKSPACE_ID ?? "", connection]);
+}
+function inTelegramSendQueue(scope, chatId, run) {
+	const key = JSON.stringify([scope, chatId]);
+	if (held.getStore()?.get(key)?.active) return run();
+	const task = (pending.get(key) ?? Promise.resolve()).catch(() => void 0).then(() => {
+		const lease = { active: true };
+		const context = new Map(held.getStore());
+		context.set(key, lease);
+		return held.run(context, async () => {
+			try {
+				return await run();
+			} finally {
+				lease.active = false;
+			}
+		});
+	});
+	pending.set(key, task);
+	const cleanup = () => {
+		if (pending.get(key) === task) pending.delete(key);
+	};
+	task.then(cleanup, cleanup);
+	return task;
+}
+export { inTelegramSendQueue, telegramSendScope };

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

@@ -5,9 +5,9 @@ export declare function isSilentReply(text: string): boolean;
 export declare function completionKind(message: string | null | undefined, finishReason?: string): "reply" | "tool_calls" | "empty" | "whitespace" | "silent_marker";
 type MessageCompleted = NonNullable<TelegramChannelEvents["message.completed"]>;
 /**
- * The channel's `message.completed` handler: eve's default delivery (plain text through
- * `sendMessage`, nothing for a tool-call step) unless the reply is a silence marker.
+ * The channel's final reply: formatted and split before Eve's plain-text splitter, with one
+ * queue slot for the whole reply. Tool-call steps and explicit silence markers have no delivery.
  */
-export declare function replyDelivery(observed?: ObservedMessages): MessageCompleted;
+export declare function replyDelivery(observed?: ObservedMessages, scope?: () => string): MessageCompleted;
 export declare const deliverUnlessSilent: MessageCompleted;
 export {};

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

@@ -6,7 +6,9 @@ __eveDirname(__filename);
 __eveCreateRequire(import.meta.url);
 import "./principal.mjs";
 import { agentMessage, observedChatKey } from "./observed.mjs";
-import { currentLocale, customerText } from "./customer-text.mjs";
+import { splitTelegramText } from "./format.mjs";
+import { inTelegramSendQueue } from "./send-queue.mjs";
+import { TelegramDeliveryError, currentLocale, customerMessage, reportTelegramError } from "./customer-text.mjs";
 import { confirmationLocale } from "./confirmation-text.mjs";
 const SILENT_MARKERS = new Set(["[silent]", "no_reply"]);
 function isSilentReply(text) {
@@ -18,11 +20,24 @@ function completionKind(message, finishReason) {
 	if (message.trim() === "") return "whitespace";
 	return isSilentReply(message) ? "silent_marker" : "reply";
 }
-function replyDelivery(observed) {
+function replyDelivery(observed, scope = () => "telegram") {
 	return async (event, channel, context) => {
 		if (completionKind(event.message, event.finishReason) !== "reply") return;
-		const text = customerText(event.message, confirmationLocale(context.session?.auth.current ?? null, currentLocale()));
-		await channel.telegram.post(text);
+		const message = customerMessage(event.message, confirmationLocale(context.session?.auth.current ?? null, currentLocale()));
+		await inTelegramSendQueue(scope(), channel.telegram.chatId, async () => {
+			const messageIds = [];
+			try {
+				for (const part of splitTelegramText(message)) {
+					const result = await channel.telegram.post(part);
+					if (!/^[1-9]\d*$/u.test(result.id)) throw new Error("Telegram did not acknowledge the reply with a message id.");
+					messageIds.push(Number(result.id));
+				}
+			} catch (error) {
+				const reference = reportTelegramError("telegram_reply_delivery_failed", error, { messageIds });
+				throw new TelegramDeliveryError(reference, error instanceof TelegramDeliveryError ? error.delivery : "unknown", messageIds);
+			}
+		});
+		const text = message.text;
 		if (observed === void 0 || channel.telegram.chatType === "private") return;
 		const principal = context.session.auth.current;
 		const sender = principal?.authenticator === "segmentstream-telegram" ? principal.subject : void 0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@segmentstream/agent",
-  "version": "0.5.4",
+  "version": "0.6.4",
   "description": "Mount a SegmentStream workspace's agent on eve: the ontology as tools, acting as the member who writes, and Telegram through the workspace's connection.",
   "license": "Apache-2.0",
   "author": "SegmentStream",
@@ -68,6 +68,7 @@
     "jose": "^6.2.12",
     "jszip": "^3.10.2",
     "mammoth": "^1.13.0",
+    "marked": "15.0.12",
     "postal-mime": "^4.0.5",
     "xlsx": "https://cdn.sheetjs.com/xlsx-0.20.3/xlsx-0.20.3.tgz"
   },

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

@@ -1,80 +0,0 @@
-import { type RouteDefinition } from "eve/channels";
-import type { TelegramChannel, TelegramChannelState } from "eve/channels/telegram";
-import type { SessionAuthContext } from "eve/context";
-import type { SessionSettings } from "../../config.js";
-import type { RuntimeTokenVerifier } from "../runtime-identity.js";
-import { type SessionPolicy } from "./sessions.js";
-/**
- * Requests from the ontology's `agent_chat.send_message` action: an external agent or a member asks
- * the workspace agent to contact someone in a group or a private chat. The ontology service resolves
- * the chat and posts here with its own Vercel OIDC token; the request is delivered into the chat's
- * session through eve's proactive `receive`, without a seed message, so it continues the session
- * the chat's own messages reach (`chatId::`, the chat-scope address) and the replies land there too.
- * The session policy runs on that session first, as it does for an inbound message.
- */
-export declare const MESSAGES_ROUTE = "/eve/v1/telegram/messages";
-export interface AgentRequest {
-    readonly target: {
-        readonly kind: "group" | "private";
-        readonly provider: "telegram";
-        /** The group's chat id, or the Telegram user id of a private chat. */
-        readonly chatId: string;
-    };
-    readonly message: string;
-    /** Document record ids from newer ontologies; omitted by older deployments. */
-    readonly documentIds?: ReadonlyArray<string>;
-    /** Whom to contact, when the requester named someone. */
-    readonly person: {
-        readonly id: string;
-        readonly name: string;
-    } | null;
-    readonly requester: {
-        readonly id: string;
-        readonly name: string;
-        readonly kind: "member" | "service";
-        /** The roles the requester holds; empty from an ontology that does not send them. */
-        readonly roles: ReadonlyArray<string>;
-        /**
-         * Whether the turn can act as the requester: a member with a live paired identity. An ontology
-         * that does not send it means a member can.
-         */
-        readonly actAs: boolean;
-    };
-}
-/** The request body, or `undefined` when it does not match the contract. */
-export declare function agentRequest(value: unknown): AgentRequest | undefined;
-/**
- * Whom the request's turn runs as. A member requester the ontology says can be acted as is the
- * turn's member, so the ontology connection acts as them and the ontology service checks, as for any
- * turn, that they are active and paired. Their roles, as the action's principal held them, choose the
- * model of a session the request starts; the service resolves them afresh on every call. A service
- * user, or a member who has not paired, cannot be acted as, so the request runs without a member and
- * the turn has no ontology; their roles still choose the model, and grant nothing, since the
- * ontology connection acts only for a `memberId`.
- */
-export declare function requestPrincipal(request: AgentRequest): SessionAuthContext;
-/** What the turn is about, for the model, ahead of the request itself. */
-export declare function requestContext(request: AgentRequest): string;
-/** Authenticate internal channel routes with the production deployment's runtime identity. */
-export declare function runtimeRequestFailure(request: Request, options: {
-    readonly enabled: () => boolean;
-    readonly configured: () => boolean;
-    readonly verify: () => RuntimeTokenVerifier;
-    readonly log?: (message: string, detail: unknown) => void;
-}): Promise<Response | undefined>;
-/**
- * `POST /eve/v1/telegram/messages`. Gated like the webhook: outside production it answers 503 and a
- * workspace without a Telegram channel 404. The caller must be a function of this deployment's
- * project, verified from its Vercel OIDC token.
- */
-export declare function messagesRoute(input: {
-    readonly channel: TelegramChannel;
-    readonly enabled: () => boolean;
-    readonly configured: () => boolean;
-    readonly verify: () => RuntimeTokenVerifier;
-    /** The adapter's session policy, which the webhook route applies too. */
-    readonly sessionPolicy: SessionPolicy;
-    /** The mounted `sessions.scope`. */
-    readonly scope: () => SessionSettings["scope"];
-    readonly log?: (message: string, detail: unknown) => void;
-}): RouteDefinition<TelegramChannelState>;