@segmentstream/agent 0.1.3 → 0.1.5

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

@@ -0,0 +1,123 @@
+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);
+const MAXIMUM_WHEN_TO_USE_LENGTH = 1e3;
+const REPORT_INTERVAL_MS = 6e5;
+const MAXIMUM_CHATS = 500;
+function agentChats(input) {
+	const chats = new Map();
+	const now = input.now ?? Date.now;
+	const log = input.log ?? ((message, error) => console.warn(message, error));
+	function remember(chatId, value) {
+		chats.delete(chatId);
+		chats.set(chatId, value);
+		if (chats.size > MAXIMUM_CHATS) {
+			const oldest = chats.keys().next();
+			if (oldest.done !== true) chats.delete(oldest.value);
+		}
+	}
+	function restore(chatId, written, previous) {
+		if (chats.get(chatId) !== written) return;
+		if (previous === void 0) chats.delete(chatId);
+		else chats.set(chatId, previous);
+	}
+	async function report(chatId, fallback, body) {
+		try {
+			const chat = await input.identities().seenChat({
+				provider: "telegram",
+				externalId: chatId,
+				...body
+			});
+			remember(chatId, {
+				...chats.get(chatId) ?? fallback,
+				chat
+			});
+			return true;
+		} catch (error) {
+			log("The agent could not report the chat to the ontology's registry.", error);
+			return false;
+		}
+	}
+	return {
+		async seen({ chatId, title, memberId }) {
+			const known = chats.get(chatId);
+			const at = now();
+			if (!(known === void 0 || at - known.reportedAt >= 6e5 || memberId !== void 0 && !known.members.has(memberId))) return;
+			const members = new Set(known?.members);
+			if (memberId !== void 0) members.add(memberId);
+			const written = {
+				reportedAt: at,
+				members,
+				chat: known?.chat
+			};
+			remember(chatId, written);
+			if (!await report(chatId, {
+				reportedAt: at,
+				members,
+				chat: void 0
+			}, {
+				title,
+				...memberId === void 0 ? {} : { memberId }
+			})) restore(chatId, written, known);
+		},
+		async left({ chatId, title, memberId }) {
+			const known = chats.get(chatId);
+			const remembered = {
+				reportedAt: known?.reportedAt ?? now(),
+				members: new Set([...known?.members ?? []].filter((member) => member !== memberId)),
+				chat: known?.chat
+			};
+			remember(chatId, remembered);
+			if (!await report(chatId, remembered, {
+				title,
+				leftMemberId: memberId
+			})) restore(chatId, remembered, known);
+		},
+		async agentLeft({ chatId, title }) {
+			const known = chats.get(chatId);
+			const remembered = {
+				reportedAt: known?.reportedAt ?? now(),
+				members: new Set(),
+				chat: known?.chat
+			};
+			remember(chatId, remembered);
+			if (!await report(chatId, remembered, {
+				title,
+				agentLeft: true
+			})) restore(chatId, remembered, known);
+		},
+		async migrated({ chatId, title, migratedFrom }) {
+			const old = chats.get(migratedFrom);
+			const known = chats.get(chatId);
+			const remembered = {
+				reportedAt: now(),
+				members: new Set([...old?.members ?? [], ...known?.members ?? []]),
+				chat: known?.chat
+			};
+			chats.delete(migratedFrom);
+			remember(chatId, remembered);
+			if (!await report(chatId, remembered, {
+				title,
+				migratedFrom
+			})) {
+				restore(chatId, remembered, known);
+				if (old !== void 0 && !chats.has(migratedFrom)) remember(migratedFrom, old);
+			}
+		},
+		chat(chatId) {
+			return chats.get(chatId)?.chat;
+		}
+	};
+}
+function chatContext(chat) {
+	if (chat === void 0) return [];
+	const lines = ["<chat>", `title: ${chat.title}`];
+	if (chat.purpose !== null && chat.purpose !== "") lines.push(`purpose: ${chat.purpose}`);
+	if (chat.whenToUse !== null && chat.whenToUse !== "") lines.push(`when_to_use: ${chat.whenToUse.slice(0, MAXIMUM_WHEN_TO_USE_LENGTH)}`);
+	lines.push("</chat>");
+	return [lines.join("\n")];
+}
+export { REPORT_INTERVAL_MS, agentChats, chatContext };

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

@@ -1,4 +1,5 @@
 import type { ChannelSource } from "eve/channels";
+import type { SessionOperations } from "./sessions.js";
 /**
  * What one webhook request shares between eve's `onMessage` hook and the route wrapper around it.
  * `onMessage` may only return `{ auth, context, title }`; it cannot change the message eve sends.
@@ -11,6 +12,10 @@ export declare class InboundRequest {
     readonly agentDescription: () => Promise<string>;
     /** The text the turn should carry instead of the parsed message, once a transcript exists. */
     text: string | undefined;
+    /** The route's session operations, on addresses already mapped to the configured scope. */
+    sessions: SessionOperations | undefined;
+    /** Keeps work the request started, such as a chat report, alive after it answers. */
+    waitUntil: ((task: Promise<unknown>) => void) | undefined;
     constructor(
     /** The agent's description from the compiled manifest, for the routing decision. */
     agentDescription: () => Promise<string>);

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

@@ -8,6 +8,8 @@ import { AsyncLocalStorage } from "node:async_hooks";
 var InboundRequest = class {
 	agentDescription;
 	text;
+	sessions;
+	waitUntil;
 	constructor(agentDescription) {
 		this.agentDescription = agentDescription;
 	}

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

@@ -1,22 +1,35 @@
 import type { TelegramContext, TelegramInboundResult, TelegramMessage } from "eve/channels/telegram";
-import type { TelegramPolicy } from "../../config.js";
+import type { SessionSettings, TelegramPolicy } from "../../config.js";
 import type { AgentIdentities } from "../identities.js";
 import type { BotIdentityLookup } from "./bot.js";
+import { type AgentChats } from "./chats.js";
 import type { InboundRequest } from "./inbound-request.js";
 import { type ObservedMessages } from "./observed.js";
 import { type RouteDecider } from "./router.js";
+import { type SessionPolicy } from "./sessions.js";
 import { type Transcriber } from "./voice.js";
 /**
  * eve's Telegram `onMessage` hook, in the order `agent-design.md` gives:
  *
  * 1. The hard gate, with no model: bots, channel posts and senders without a live pairing never
- *    start a turn. An unknown sender who writes to the bot privately gets a pairing button.
+ *    start a turn. An unknown sender who writes to the bot privately gets a pairing button. A group
+ *    message reports its chat to the ontology's registry in the background, whatever follows. A
+ *    group's notice that a member left is never a turn: a paired member's departure is reported,
+ *    and so is the agent's own, which unlinks every member. Neither is the notice, in the old chat
+ *    or the new one, that a group became a supergroup: the migration is reported.
  * 2. Voice becomes text, so the router and the agent read what was said.
  * 3. The router answers or observes. An observed message goes to the chat's ring and stops here.
- * 4. An answered message dispatches as the paired member, with the ring ahead of it as context.
+ * 4. The session policy runs on the session the message continues: an idle one is cleared, the
+ *    first message after the day's compaction time compacts it.
+ * 5. An answered message dispatches as the paired member, with the ring, the registry's `<chat>`
+ *    block and a `<speaker>` block naming the member, their roles and the message they replied to
+ *    ahead of it as context. An answered group message waits for its chat's report first, so that
+ *    a chat new to the process already carries its `<chat>` block.
  */
 export interface InboundDependencies {
     readonly policy: TelegramPolicy;
+    readonly sessions: () => SessionSettings;
+    readonly sessionPolicy: SessionPolicy;
     readonly sttModel: string | false;
     readonly identities: AgentIdentities;
     readonly bot: BotIdentityLookup;
@@ -24,6 +37,7 @@ export interface InboundDependencies {
     readonly transcribe: Transcriber;
     readonly download: (fileId: string) => Promise<Uint8Array>;
     readonly observed: ObservedMessages;
+    readonly chats: AgentChats;
     /** The app's `/agent/connect` link for a pairing code. */
     readonly connectUrl: (code: string) => string;
 }

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

@@ -5,12 +5,15 @@ const __filename = __eveFileURLToPath(import.meta.url);
 __eveDirname(__filename);
 __eveCreateRequire(import.meta.url);
 import { telegramPrincipal } from "./principal.mjs";
+import { chatContext } from "./chats.mjs";
 import { observedChatKey, observedContext } from "./observed.mjs";
 import { isAddressed, routeMessage } from "./router.mjs";
+import { messageAddress, scopedAddress } from "./sessions.mjs";
 import { voiceNote, voiceOf, voiceText } from "./voice.mjs";
 const UNKNOWN_PRIVATE = "Hi, I don't know you yet. Connect your Telegram account to the workspace and I'll act as you. The button works for ten minutes.";
 const UNKNOWN_IN_GROUP = "I don't know you yet. Message me privately to connect your account.";
 const REFUSED = "Your access to this agent was revoked, or your membership is inactive. Ask a workspace administrator.";
+const MAXIMUM_QUOTE_LENGTH = 500;
 function buttonTo(text, url) {
 	return { inline_keyboard: [[{
 		text,
@@ -26,13 +29,41 @@ function sentAt(message) {
 	const date = message.raw.date;
 	return new Date(typeof date === "number" ? date * 1e3 : Date.now()).toISOString();
 }
-function observedMessage(message, text) {
+function authorOf(user, member) {
+	const name = display(user) ?? user.id;
+	if (member === void 0) return name;
+	const roles = member.roles.length === 0 ? "" : ` (${member.roles.join(", ")})`;
+	return member.name === null ? `${name}${roles}` : `${member.name}${roles}, ${name}`;
+}
+function observedMessage(message, text, member) {
 	return {
-		author: display(message.from) ?? message.from.id,
+		author: authorOf(message.from, member),
 		text,
 		at: sentAt(message)
 	};
 }
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function speakerBlock(input) {
+	const { message, member, bot } = input;
+	const roles = member.roles.length === 0 ? "no roles" : member.roles.join(", ");
+	const lines = [
+		"<speaker>",
+		`member: ${member.name ?? "unnamed member"} (${roles})`,
+		`telegram: ${display(message.from) ?? "no name"}, user_id ${message.from.id}`
+	];
+	const raw = message.raw.reply_to_message;
+	if (isRecord(raw)) {
+		const from = isRecord(raw.from) ? raw.from : {};
+		const author = from.is_bot === true && bot !== void 0 && String(from.id) === bot.id ? "the agent" : typeof from.username === "string" ? `@${from.username}` : typeof from.first_name === "string" ? from.first_name : "unknown sender";
+		const text = typeof raw.text === "string" ? raw.text : typeof raw.caption === "string" ? raw.caption : "";
+		const quoted = text.length > MAXIMUM_QUOTE_LENGTH ? `${text.slice(0, MAXIMUM_QUOTE_LENGTH)}…` : text;
+		lines.push(`reply_to: ${author}: ${JSON.stringify(quoted)}`);
+	}
+	lines.push("</speaker>");
+	return lines.join("\n");
+}
 function unknownInGroup(bot) {
 	return bot?.username === void 0 ? { text: UNKNOWN_IN_GROUP } : {
 		text: UNKNOWN_IN_GROUP,
@@ -60,9 +91,67 @@ async function answerUnpaired(input) {
 		reply_markup: buttonTo("Connect account", dependencies.connectUrl(pairing.code))
 	});
 }
+function isGroupChat(message) {
+	return message.chat.type === "group" || message.chat.type === "supergroup";
+}
+async function reportDeparture(input) {
+	const { context, message, left, dependencies } = input;
+	const id = left.id;
+	if (typeof id !== "number" && typeof id !== "string") return;
+	if (left.is_bot === true) {
+		const bot = await dependencies.bot(context.telegram);
+		if (bot !== void 0 && String(id) === bot.id) await dependencies.chats.agentLeft({
+			chatId: message.chat.id,
+			title: message.chat.title ?? ""
+		});
+		return;
+	}
+	const lookup = await dependencies.identities.lookup({
+		provider: "telegram",
+		externalId: String(id)
+	});
+	if (lookup.status === "paired") await dependencies.chats.left({
+		chatId: message.chat.id,
+		title: message.chat.title ?? "",
+		memberId: lookup.member.id
+	});
+}
+function rawChatId(value) {
+	return typeof value === "number" || typeof value === "string" && value !== "" ? String(value) : void 0;
+}
+function migrationOf(message) {
+	const to = rawChatId(message.raw.migrate_to_chat_id);
+	const from = rawChatId(message.raw.migrate_from_chat_id);
+	if (to !== void 0) return {
+		chatId: to,
+		migratedFrom: message.chat.id
+	};
+	return from === void 0 ? void 0 : {
+		chatId: message.chat.id,
+		migratedFrom: from
+	};
+}
 async function handleInboundMessage(input) {
 	const { context, dependencies } = input;
 	const message = input.message;
+	const left = message.raw.left_chat_member;
+	const migration = isGroupChat(message) ? migrationOf(message) : void 0;
+	if (isGroupChat(message) && isRecord(left)) {
+		await reportDeparture({
+			context,
+			message,
+			left,
+			dependencies
+		});
+		return null;
+	}
+	if (migration !== void 0) {
+		await dependencies.chats.migrated({
+			...migration,
+			title: message.chat.title ?? ""
+		});
+		return null;
+	}
 	if (message.from === void 0 || message.from.isBot || message.chat.type === "channel") return null;
 	const sent = {
 		...message,
@@ -74,6 +163,13 @@ async function handleInboundMessage(input) {
 		provider: "telegram",
 		externalId: sent.from.id
 	});
+	const group = isGroupChat(sent);
+	const report = group ? dependencies.chats.seen({
+		chatId: sent.chat.id,
+		title: sent.chat.title ?? "",
+		...lookup.status === "paired" ? { memberId: lookup.member.id } : {}
+	}) : void 0;
+	if (report !== void 0) input.request?.waitUntil?.(report);
 	if (lookup.status !== "paired") {
 		if (addressed) await answerUnpaired({
 			context,
@@ -84,6 +180,8 @@ async function handleInboundMessage(input) {
 		});
 		return null;
 	}
+	const address = scopedAddress(messageAddress(sent), dependencies.sessions().scope);
+	const operations = input.request?.sessions;
 	const voice = voiceOf(sent.raw);
 	const caption = sent.text || sent.caption;
 	const notes = [];
@@ -110,21 +208,40 @@ async function handleInboundMessage(input) {
 		question: async () => ({
 			agent: await input.request?.agentDescription() ?? "",
 			observed: dependencies.observed.list(chat),
-			message: observedMessage(sent, text)
+			message: observedMessage(sent, text, lookup.member)
 		})
 	}) === "observe") {
-		dependencies.observed.add(chat, observedMessage(sent, text === "" ? "[attachment]" : text));
+		dependencies.observed.add(chat, observedMessage(sent, text === "" ? "[attachment]" : text, lookup.member));
 		return null;
 	}
 	if (voice !== void 0 && input.request !== void 0) input.request.text = text;
 	else if (voice !== void 0) notes.push(text);
+	if (operations !== void 0) {
+		const newest = dependencies.observed.list(chat).at(-1);
+		if (await dependencies.sessionPolicy.apply({
+			address,
+			operations,
+			...newest === void 0 ? {} : { activeAt: Date.parse(newest.at) || 0 }
+		}) === "cleared") dependencies.observed.take(chat);
+		dependencies.sessionPolicy.delivered(address);
+	}
 	await context.telegram.startTyping();
+	await report;
 	return {
 		auth: telegramPrincipal({
 			message: sent,
 			member: lookup.member
 		}),
-		context: [...observedContext(dependencies.observed.take(chat)), ...notes]
+		context: [
+			...observedContext(dependencies.observed.take(chat)),
+			...group ? chatContext(dependencies.chats.chat(sent.chat.id)) : [],
+			speakerBlock({
+				message: sent,
+				member: lookup.member,
+				bot
+			}),
+			...notes
+		]
 	};
 }
 export { handleInboundMessage };

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

@@ -0,0 +1,71 @@
+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;
+    /** 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;
+/**
+ * `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>;

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

@@ -0,0 +1,173 @@
+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 { TELEGRAM_AUTHENTICATOR } from "./principal.mjs";
+import { formatAddress, scopedAddress } from "./sessions.mjs";
+import { POST } from "eve/channels";
+const MESSAGES_ROUTE = "/eve/v1/telegram/messages";
+const MAX_REQUEST_MESSAGE_LENGTH = 4e3;
+const CHAT_ID = /^-?\d{1,20}$/;
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isText(value) {
+	return typeof value === "string" && value.trim() !== "";
+}
+function user(value) {
+	return isRecord(value) && isText(value.id) && isText(value.name) ? {
+		id: value.id,
+		name: value.name
+	} : void 0;
+}
+function roles(value) {
+	if (value === void 0) return [];
+	return Array.isArray(value) && value.every((role) => typeof role === "string") ? value : void 0;
+}
+function agentRequest(value) {
+	if (!isRecord(value)) return;
+	const { target, message, requester } = value;
+	const person = value.person === null ? null : user(value.person);
+	const from = user(requester);
+	const held = isRecord(requester) ? roles(requester.roles) : void 0;
+	const actAs = isRecord(requester) ? requester.actAs : void 0;
+	if (!isRecord(target) || target.kind !== "group" && target.kind !== "private" || target.provider !== "telegram" || typeof target.chatId !== "string" || !CHAT_ID.test(target.chatId) || !isText(message) || message.length > MAX_REQUEST_MESSAGE_LENGTH || person === void 0 || from === void 0 || !isRecord(requester) || requester.kind !== "member" && requester.kind !== "service" || held === void 0 || actAs !== void 0 && typeof actAs !== "boolean") return;
+	return {
+		target: {
+			kind: target.kind,
+			provider: "telegram",
+			chatId: target.chatId
+		},
+		message,
+		person,
+		requester: {
+			...from,
+			kind: requester.kind,
+			roles: held,
+			actAs: actAs ?? requester.kind === "member"
+		}
+	};
+}
+function requestPrincipal(request) {
+	const { requester, target } = request;
+	if (requester.kind === "member" && requester.actAs) return {
+		authenticator: TELEGRAM_AUTHENTICATOR,
+		issuer: "segmentstream",
+		principalId: `segmentstream:${requester.id}`,
+		principalType: "user",
+		subject: requester.id,
+		attributes: {
+			memberId: requester.id,
+			memberName: requester.name,
+			roles: requester.roles,
+			chatId: target.chatId,
+			chatType: target.kind
+		}
+	};
+	return {
+		authenticator: TELEGRAM_AUTHENTICATOR,
+		issuer: "segmentstream",
+		principalId: `segmentstream:${requester.kind}:${requester.id}`,
+		principalType: requester.kind === "member" ? "user" : "service",
+		subject: requester.id,
+		attributes: {
+			requesterId: requester.id,
+			requesterName: requester.name,
+			roles: requester.roles,
+			chatId: target.chatId,
+			chatType: target.kind
+		}
+	};
+}
+function requestContext(request) {
+	const { requester, person } = request;
+	const to = person === null ? "" : ` to ${person.name} (user_id ${person.id})`;
+	const lines = [
+		"<agent_request>",
+		`A request from ${requester.name} (${requester.kind}, user_id ${requester.id}) arrived through the ontology action agent_chat.send_message; the message is the request.`,
+		`Write in this chat${to}, ask what the request needs, and handle the replies here.`
+	];
+	if (requester.kind === "service" || !requester.actAs) lines.push(`${requester.kind === "service" ? "The requester is a service, not a member" : "The requester has not paired a Telegram account with the agent"}, so this turn runs without a member and the ontology is not available in it. Each member who replies acts with their own permissions.`);
+	lines.push("</agent_request>");
+	return lines.join("\n");
+}
+function withContext(source, context) {
+	return {
+		...source,
+		send(message, options) {
+			return source.send(message, {
+				...options,
+				context: [...options.context ?? [], context]
+			});
+		}
+	};
+}
+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 });
+}
+function messagesRoute(input) {
+	const log = input.log ?? ((message, detail) => console.warn(message, detail));
+	return POST(MESSAGES_ROUTE, async (request, args) => {
+		if (!input.enabled()) return error("channels_disabled", 503);
+		if (!input.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 = input.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);
+		}
+		let body;
+		try {
+			body = await request.json();
+		} catch {
+			return error("invalid_body", 400);
+		}
+		const parsed = agentRequest(body);
+		const receive = input.channel.receive;
+		if (parsed === void 0) return error("invalid_body", 400);
+		if (receive === void 0) throw new Error("eve's Telegram channel has no receive hook.");
+		const chatAddress = scopedAddress(formatAddress({
+			chatId: parsed.target.chatId,
+			messageThreadId: "",
+			conversationId: ""
+		}), input.scope());
+		await input.sessionPolicy.apply({
+			address: chatAddress,
+			operations: {
+				resolveSession: args.resolveSession,
+				from: args.from
+			}
+		});
+		const session = await receive({
+			target: { chatId: parsed.target.chatId },
+			message: parsed.message,
+			auth: requestPrincipal(parsed)
+		}, {
+			from: (address) => withContext(args.from(address), requestContext(parsed)),
+			resolveSession: args.resolveSession
+		});
+		input.sessionPolicy.delivered(chatAddress);
+		return Response.json({
+			delivered: true,
+			sessionId: session.id
+		}, { status: 202 });
+	});
+}
+export { MESSAGES_ROUTE, agentRequest, messagesRoute, requestContext, requestPrincipal };