@segmentstream/agent 0.13.0 → 0.15.0

package/dist/extension/lib/ontology-tools.mjs

@@ -5,10 +5,10 @@ const __filename = __eveFileURLToPath(import.meta.url);
 __eveDirname(__filename);
 __eveCreateRequire(import.meta.url);
 import { appOrigin } from "./environment.mjs";
-import { identityProviderOf, memberIdOf } from "./telegram/principal.mjs";
-import { runtimeToken } from "./runtime-token.mjs";
+import { c as compatibleRuntimeEnvelope, i as memberIdOf, r as identityProviderOf, s as RUNTIME_SOURCE_PROTOCOL, u as runtimeEnvelope } from "../../_chunks/principal-MEMlG3EG.mjs";
 import { redactDiagnostic } from "./diagnostics.mjs";
 import { describeConfirmation, object } from "./confirmation-description.mjs";
+import { runtimeToken } from "./runtime-token.mjs";
 import { describeChatPost, isChatPost, supportsChatPost } from "./chat-post-confirmation.mjs";
 import { randomUUID } from "node:crypto";
 var OntologyToolRejected = class extends Error {
@@ -18,10 +18,23 @@ var OntologyActionNotPermitted = class extends Error {
 	code = "ontology_action_not_permitted";
 };
 function ontologyTools(options = {}) {
+	const runtimeSources = new Map();
 	async function rpc(memberId, method, params, signal) {
+		if (method === "tools/call") {
+			const envelope = options.envelope ?? runtimeEnvelope({ principal: memberIdOf(options.principal) === memberId ? options.principal : null });
+			if (envelope.source !== void 0 && !runtimeSources.has(memberId)) await rpc(memberId, "tools/list", {}, signal);
+			params = {
+				...params,
+				arguments: {
+					...object(params.arguments),
+					_segmentstream: compatibleRuntimeEnvelope(envelope, runtimeSources.get(memberId) === true)
+				}
+			};
+		}
 		const provider = memberIdOf(options.principal) === memberId ? identityProviderOf(options.principal) : void 0;
 		const credential = await (options.token ?? runtimeToken)();
 		const secrets = new Set([credential]);
+		if (method === "tools/call") await options.beforeCall?.(String(params.name));
 		try {
 			const response = await (options.fetch ?? fetch)(`${appOrigin(options.environment ?? process.env)}/mcp`, {
 				method: "POST",
@@ -46,6 +59,7 @@ function ontologyTools(options = {}) {
 			const body = object(await response.json());
 			if (body.error !== void 0) throw new Error("Ontology metadata unavailable.", { cause: body.error });
 			const result = object(body.result);
+			if (method === "tools/list" && Array.isArray(result.tools)) runtimeSources.set(memberId, result.tools.map(object).some((tool) => object(tool._meta)[RUNTIME_SOURCE_PROTOCOL] === 1));
 			if (result.isError === true) {
 				const message = (Array.isArray(result.content) ? result.content : []).map(object).filter((part) => part.type === "text" && typeof part.text === "string").map((part) => part.text).join("\n");
 				if ([
@@ -119,12 +133,23 @@ function ontologyTools(options = {}) {
 			const result = await rpc(memberId, "tools/list", {});
 			return Array.isArray(result.tools) ? result.tools.map(object) : [];
 		},
+		async supportsRuntimeSource(memberId, signal) {
+			if (!runtimeSources.has(memberId)) await rpc(memberId, "tools/list", {}, signal);
+			return runtimeSources.get(memberId) === true;
+		},
+		async capabilities(memberId) {
+			const result = await rpc(memberId, "tools/list", {});
+			return {
+				chatPosting: Array.isArray(result.tools) && result.tools.map(object).some(supportsChatPost),
+				runtimeSource: runtimeSources.get(memberId) === true
+			};
+		},
 		async supportsChatPosting(memberId) {
 			const result = await rpc(memberId, "tools/list", {});
 			return Array.isArray(result.tools) && result.tools.map(object).some(supportsChatPost);
 		},
-		async labels(memberId, action, input = {}) {
-			const { tool } = await resolve(memberId, action, input);
+		async labels(memberId, action, input = {}, signal) {
+			const { tool } = await resolve(memberId, action, input, signal);
 			return {
 				...object(tool.annotations),
 				confirmation: object(object(tool.inputSchema).properties)._confirmation !== void 0

package/dist/extension/lib/runtime-envelope.d.ts

@@ -0,0 +1,28 @@
+import type { RuntimeSource } from "@segmentstream-cloud/ontology";
+import type { SessionAuthContext } from "eve/context";
+import type { TelegramMessage } from "eve/channels/telegram";
+import type { StagedFile } from "./telegram/inbound-request.js";
+export type RuntimeEnvelope = {
+    readonly version: 1;
+    readonly session_id: string;
+    readonly call_id: string;
+    readonly operation_id?: string;
+    readonly source?: RuntimeSource;
+    readonly expected?: {
+        readonly chat_id: string;
+        readonly digest: string;
+    };
+};
+/** The source comes from the verified Telegram message and admitted storage results. */
+export declare function telegramRuntimeSource(message: Pick<TelegramMessage, "chat" | "messageId" | "messageThreadId" | "replyToMessage" | "from" | "raw" | "attachments">, files?: ReadonlyMap<string, StagedFile>, callbackQueryId?: string): RuntimeSource;
+/** Session auth is SDK-owned; no tool argument is read while rebuilding provenance. */
+export declare function principalRuntimeSource(principal?: SessionAuthContext | null): RuntimeSource | undefined;
+export declare function runtimeEnvelope(input?: {
+    readonly principal?: SessionAuthContext | null;
+    readonly sessionId?: string;
+    readonly callId?: string;
+    readonly source?: RuntimeSource;
+}): RuntimeEnvelope;
+/** Older strict ontology schemas accept only the original chat identity fields. */
+export declare function compatibleRuntimeEnvelope(envelope: RuntimeEnvelope, extended: boolean): RuntimeEnvelope;
+export declare const RUNTIME_SOURCE_PROTOCOL = "segmentstream/runtime-source";

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

@@ -0,0 +1,8 @@
+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 { c as compatibleRuntimeEnvelope, d as telegramRuntimeSource, l as principalRuntimeSource, s as RUNTIME_SOURCE_PROTOCOL, u as runtimeEnvelope } from "../../_chunks/principal-MEMlG3EG.mjs";
+export { RUNTIME_SOURCE_PROTOCOL, compatibleRuntimeEnvelope, principalRuntimeSource, runtimeEnvelope, telegramRuntimeSource };

package/dist/extension/lib/stored-files.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 { memberIdOf } from "./telegram/principal.mjs";
+import { i as memberIdOf } from "../../_chunks/principal-MEMlG3EG.mjs";
 import { redactDiagnostic } from "./diagnostics.mjs";
 import { object } from "./confirmation-description.mjs";
 import { ontologyTools } from "./ontology-tools.mjs";

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

@@ -7,19 +7,21 @@ __eveCreateRequire(import.meta.url);
 import { telegramText, withTelegramTexts } from "./texts.mjs";
 import { manifestOf } from "../../config.mjs";
 import { appOrigin, channelsEnabled, proxyEnvironment, runtimeIdentityEnvironment, webhookSecret } from "../environment.mjs";
-import { conversationLanguage, telegramPrincipal } from "./principal.mjs";
+import { n as conversationLanguage, o as telegramPrincipal } from "../../../_chunks/principal-MEMlG3EG.mjs";
+import { confirmationLocale } from "./confirmation-text.mjs";
+import { telegramSendScope } from "./send-queue.mjs";
+import { d as failureText, h as withDeliveryLocale, i as withReplacedText, m as safeTelegramFetch, n as currentInboundRequest, o as currentLocale, p as reportTelegramError, r as runInboundRequest, t as InboundRequest } from "../../../_chunks/inbound-request-RIRNBxUC.mjs";
 import { chooseModel } from "../../model.mjs";
 import { groupRoutingHealth } from "../group-routing/health.mjs";
 import { decisionRouter } from "../group-routing/router.mjs";
 import { runtimeToken } from "../runtime-token.mjs";
 import { conversations } from "../conversations.mjs";
 import { archivedRoutingMessages } from "../group-routing/routing-context.mjs";
-import { t as agentBuild } from "../../../_chunks/build-metadata-BLeBanNg.mjs";
-import { confirmationLocale } from "./confirmation-text.mjs";
-import { telegramSendScope } from "./send-queue.mjs";
-import { d as failureText, h as withDeliveryLocale, i as withReplacedText, m as safeTelegramFetch, n as currentInboundRequest, o as currentLocale, p as reportTelegramError, r as runInboundRequest, t as InboundRequest } from "../../../_chunks/inbound-request-BXhiIph-.mjs";
-import { attachmentLifecycle } from "./lifecycle.mjs";
+import { dispatchStructuredMessage, structuredMessage } from "./structured.mjs";
 import { scopedAddress, sessionPolicy } from "./sessions.mjs";
+import { handleWorkspaceCallback, isWorkspaceCallback } from "./callbacks.mjs";
+import { t as agentBuild } from "../../../_chunks/build-metadata-CJlaXNhc.mjs";
+import { attachmentLifecycle } from "./lifecycle.mjs";
 import { observedMessages } from "./observed.mjs";
 import { expireDeferredCards, handleDeferredCallback, isDeferredCallback } from "./deferred-confirmations.mjs";
 import { gatewayImageDescriber } from "./images.mjs";
@@ -121,6 +123,10 @@ function segmentstreamTelegram(options) {
 		identities: pairing,
 		observed,
 		chats,
+		structured: (raw) => {
+			const inbound = settings().inbound;
+			return inbound === void 0 ? void 0 : structuredMessage(raw, inbound.kinds);
+		},
 		verify: telegramWebhookVerifier(() => webhookSecret(environment)),
 		answerCallback: async (callbackQueryId, locale) => {
 			const text = telegramText("callback", "unsupported", locale);
@@ -203,6 +209,20 @@ function segmentstreamTelegram(options) {
 							includeDecisions: true
 						})).events, 100),
 						signalSettings: settings().groups,
+						...settings().inbound === void 0 ? {} : { structured: {
+							configuration: settings().inbound,
+							run: (principal, memberId, message, event, beforeDispatch) => dispatchStructuredMessage({
+								configuration: settings().inbound,
+								principal,
+								memberId,
+								message,
+								event,
+								beforeDispatch,
+								environment,
+								token,
+								...options.fetch ? { fetch: options.fetch } : {}
+							})
+						} },
 						recoverHeldApprovals: options.confirmationMode?.() === "deferred",
 						...settings().attachmentLifecycle === void 0 ? {} : { lifecycle: (principal, memberId, message) => attachmentLifecycle({
 							configuration: settings().attachmentLifecycle,
@@ -296,7 +316,7 @@ function segmentstreamTelegram(options) {
 					reportTelegramError("intake_dispatch_release_failed", cleanupError);
 				}
 				const errorId = reportTelegramError("inbound_message_failed", error, { chatId: message.chat.id });
-				if (inbound?.retryReference !== void 0 || inbound?.lifecycleKey !== void 0) inbound.retryReference = errorId;
+				if (inbound?.retryReference !== void 0 || inbound?.lifecycleKey !== void 0 || inbound?.structuredContext !== void 0) inbound.retryReference = errorId;
 				else await context.telegram.post(failureText(errorId));
 				return null;
 			} finally {
@@ -307,6 +327,20 @@ function segmentstreamTelegram(options) {
 			const inbound = currentInboundRequest();
 			if (inbound !== void 0) inbound.locale = query.from.languageCode;
 			try {
+				if (isWorkspaceCallback(query.data)) {
+					await handleWorkspaceCallback({
+						context,
+						query,
+						configuration: settings().callbacks,
+						admission: options.admission?.() ?? manifestOf({}),
+						scope: options.sessions().scope,
+						identities: pairing(),
+						environment,
+						token,
+						...options.fetch ? { fetch: options.fetch } : {}
+					});
+					return;
+				}
 				if (isDeferredCallback(query.data)) {
 					await handleDeferredCallback({
 						context,

package/dist/extension/lib/telegram/attachment-description.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 { p as reportTelegramError } from "../../../_chunks/inbound-request-BXhiIph-.mjs";
+import { p as reportTelegramError } from "../../../_chunks/inbound-request-RIRNBxUC.mjs";
 import { describableImage } from "./images.mjs";
 import { MAXIMUM_ROUTING_PDF_CHARACTERS, extractRoutingPdf } from "./pdf-text.mjs";
 import { gateway, generateText } from "ai";

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

@@ -5,12 +5,12 @@ const __filename = __eveFileURLToPath(import.meta.url);
 __eveDirname(__filename);
 __eveCreateRequire(import.meta.url);
 import { appOrigin, channelsEnabled, proxyEnvironment } from "../environment.mjs";
-import "./principal.mjs";
-import { runtimeToken } from "../runtime-token.mjs";
+import "../../../_chunks/principal-MEMlG3EG.mjs";
 import { redactDiagnostic } from "../diagnostics.mjs";
 import { confirmationLocale } from "./confirmation-text.mjs";
 import { inTelegramSendQueue, telegramSendScope } from "./send-queue.mjs";
-import { d as failureText, f as formattingRefused, l as customerMessage, p as reportTelegramError } from "../../../_chunks/inbound-request-BXhiIph-.mjs";
+import { d as failureText, f as formattingRefused, l as customerMessage, p as reportTelegramError } from "../../../_chunks/inbound-request-RIRNBxUC.mjs";
+import { runtimeToken } from "../runtime-token.mjs";
 import { MAXIMUM_PROXY_BODY_BYTES, connectionProxy } from "../connection-proxy.mjs";
 import { ACT_AS_HEADER } from "../ontology-connection.mjs";
 import { AttachmentError, CONVERSATION_HEADER, SESSION_HEADER } from "../attachments.mjs";

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

@@ -0,0 +1,18 @@
+import type { TelegramCallbackQuery, TelegramContext } from "eve/channels/telegram";
+import type { AdmissionSettings, SessionSettings, TelegramSettings } from "../../config.js";
+import type { AgentIdentities } from "../identities.js";
+import type { Environment } from "../environment.js";
+import type { RuntimeToken } from "../runtime-token.js";
+export declare const isWorkspaceCallback: (data?: string) => boolean;
+/** A single dispatch and acknowledgement. Token policy and business idempotency belong to the workspace. */
+export declare function handleWorkspaceCallback(input: {
+    readonly context: TelegramContext;
+    readonly query: TelegramCallbackQuery;
+    readonly configuration?: TelegramSettings["callbacks"];
+    readonly scope: SessionSettings["scope"];
+    readonly admission: AdmissionSettings;
+    readonly identities: AgentIdentities;
+    readonly environment?: Environment;
+    readonly token?: RuntimeToken;
+    readonly fetch?: typeof fetch;
+}): Promise<void>;

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

@@ -0,0 +1,155 @@
+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 { admitMessage } from "../admission.mjs";
+import { telegramText } from "./texts.mjs";
+import { d as telegramRuntimeSource, i as memberIdOf, o as telegramPrincipal, u as runtimeEnvelope } from "../../../_chunks/principal-MEMlG3EG.mjs";
+import { object } from "../confirmation-description.mjs";
+import { n as currentInboundRequest, p as reportTelegramError } from "../../../_chunks/inbound-request-RIRNBxUC.mjs";
+import { workspaceAction } from "./workspace-action.mjs";
+import { formatAddress, parseAddress, scopedAddress } from "./sessions.mjs";
+const isWorkspaceCallback = (data) => data?.startsWith("ws:") === true;
+async function handleWorkspaceCallback(input) {
+	const { query, context } = input;
+	const locale = query.from.languageCode;
+	let acknowledgement;
+	let showAlert = false;
+	let result;
+	let principal;
+	const controller = new AbortController();
+	let timer;
+	try {
+		const token = query.data?.slice(3) ?? "";
+		if (!query.message || query.from.isBot || !token || new TextEncoder().encode(token).byteLength > 60) acknowledgement = telegramText("callback", "unknown", locale);
+		else if (input.configuration === void 0) acknowledgement = telegramText("callback", "unsupported", locale);
+		else {
+			const message = {
+				...query.message,
+				from: query.from,
+				attachments: [],
+				text: "",
+				caption: "",
+				raw: {}
+			};
+			const dispatch = async () => {
+				const lookup = await input.identities.lookup({
+					provider: "telegram",
+					externalId: query.from.id
+				});
+				if (lookup.status !== "paired") {
+					acknowledgement = telegramText("callback", "forbidden", locale);
+					return;
+				}
+				controller.signal.throwIfAborted();
+				principal = telegramPrincipal({
+					message,
+					member: lookup.member,
+					callbackQueryId: query.id
+				});
+				return workspaceAction({
+					...input,
+					configuration: input.configuration,
+					principal,
+					memberId: lookup.member.id,
+					input: { token },
+					signal: controller.signal,
+					envelope: runtimeEnvelope({
+						source: telegramRuntimeSource(message, void 0, query.id),
+						sessionId: `telegram:callback:${query.id}`,
+						callId: query.id
+					})
+				});
+			};
+			const deadline = new Promise((resolve) => {
+				timer = setTimeout(() => {
+					controller.abort();
+					reportTelegramError("workspace_callback_timeout", new Error("Telegram callback dispatch exceeded 10 seconds."), { callbackQueryId: query.id });
+					resolve(void 0);
+				}, 1e4);
+			});
+			result = await Promise.race([dispatch(), deadline]);
+			if (result !== void 0) {
+				acknowledgement = typeof result.acknowledgement === "string" && result.acknowledgement.length <= 200 ? result.acknowledgement : void 0;
+				showAlert = result.show_alert === true;
+			}
+		}
+	} catch (error) {
+		reportTelegramError("workspace_callback_failed", error, { callbackQueryId: query.id });
+		acknowledgement = controller.signal.aborted ? void 0 : telegramText("callback", "error", locale);
+	} finally {
+		if (timer !== void 0) clearTimeout(timer);
+		try {
+			await context.telegram.answerCallbackQuery({
+				callbackQueryId: query.id,
+				...acknowledgement === void 0 ? {} : { text: acknowledgement },
+				showAlert
+			});
+		} catch (error) {
+			reportTelegramError("workspace_callback_ack_failed", error, { callbackQueryId: query.id });
+		}
+	}
+	if (result === void 0 || query.message === void 0 || principal === void 0) return;
+	const edit = object(result.edit);
+	try {
+		if (typeof edit.text === "string" || edit.reply_markup !== void 0) {
+			const payload = {
+				chat_id: query.message.chat.id,
+				message_id: Number(query.message.messageId),
+				...typeof edit.text === "string" && edit.text.length <= 4096 ? { text: edit.text } : {},
+				...[
+					"MarkdownV2",
+					"Markdown",
+					"HTML"
+				].includes(String(edit.parse_mode)) ? { parse_mode: edit.parse_mode } : {},
+				...Array.isArray(edit.entities) && edit.entities.length <= 100 ? { entities: edit.entities } : {},
+				...edit.reply_markup === void 0 ? {} : { reply_markup: edit.reply_markup }
+			};
+			const encoded = JSON.stringify(payload);
+			if (encoded.length > 32768) throw new Error("The callback edit exceeds the Telegram hook limit.");
+			await context.telegram.request(typeof edit.text === "string" ? "editMessageText" : "editMessageReplyMarkup", JSON.parse(encoded));
+		}
+	} catch (error) {
+		reportTelegramError("workspace_callback_edit_failed", error, { callbackQueryId: query.id });
+	}
+	if (typeof result.context === "string" && result.context.trim() && result.context.length <= 16384) try {
+		const admitted = await admitMessage({
+			identity: {
+				provider: "telegram",
+				externalId: query.from.id,
+				chat: query.message.chat.type === "private" ? "private" : "group",
+				turn: true
+			},
+			identities: input.identities,
+			settings: input.admission,
+			languageCode: locale,
+			sendNotice: (text) => context.telegram.post(text),
+			noticeFailed: (error) => reportTelegramError("workspace_callback_notice_failed", error)
+		});
+		if (admitted.status !== "existing" && admitted.status !== "created" || admitted.member.id !== memberIdOf(principal)) return;
+		const sessions = currentInboundRequest()?.sessions;
+		if (sessions === void 0) throw new Error("The callback has no session transport.");
+		const address = scopedAddress(formatAddress({
+			chatId: query.message.chat.type === "private" ? query.from.id : query.message.chat.id,
+			messageThreadId: String(query.message.messageThreadId ?? ""),
+			conversationId: query.message.chat.type === "private" ? "" : query.message.messageId
+		}), input.scope);
+		const session = sessions.from(address);
+		if (session.send === void 0) throw new Error("The callback session cannot enqueue turns.");
+		await session.send(result.context, {
+			auth: principal,
+			turnPolicy: "queue",
+			state: {
+				chatId: query.message.chat.id,
+				chatType: query.message.chat.type,
+				messageThreadId: query.message.messageThreadId ?? null,
+				conversationId: parseAddress(address).conversationId || null
+			}
+		});
+	} catch (error) {
+		reportTelegramError("workspace_callback_turn_failed", error, { callbackQueryId: query.id });
+	}
+}
+export { handleWorkspaceCallback, isWorkspaceCallback };

package/dist/extension/lib/telegram/confirmation-expiry.mjs

@@ -6,10 +6,10 @@ __eveDirname(__filename);
 __eveCreateRequire(import.meta.url);
 import { withTelegramTexts } from "./texts.mjs";
 import { proxyEnvironment } from "../environment.mjs";
+import { telegramSendScope } from "./send-queue.mjs";
+import { m as safeTelegramFetch, p as reportTelegramError } from "../../../_chunks/inbound-request-RIRNBxUC.mjs";
 import { runtimeToken } from "../runtime-token.mjs";
 import { conversations } from "../conversations.mjs";
-import { telegramSendScope } from "./send-queue.mjs";
-import { m as safeTelegramFetch, p as reportTelegramError } from "../../../_chunks/inbound-request-BXhiIph-.mjs";
 import { deferredConfirmations } from "../deferred-confirmations.mjs";
 import { expireDeferredRecord } from "./deferred-confirmations.mjs";
 import { connectionProxy } from "../connection-proxy.mjs";

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

@@ -5,13 +5,13 @@ const __filename = __eveFileURLToPath(import.meta.url);
 __eveDirname(__filename);
 __eveCreateRequire(import.meta.url);
 import { telegramText } from "./texts.mjs";
-import { memberIdOf, telegramPrincipal } from "./principal.mjs";
-import { agentMessage, observedChatKey, withConfirmationPrompt } from "../group-routing/observed.mjs";
-import { conversationEvent } from "../conversations.mjs";
+import { i as memberIdOf, o as telegramPrincipal } from "../../../_chunks/principal-MEMlG3EG.mjs";
 import { humanText } from "../confirmation-description.mjs";
 import { renderConfirmation, withConfirmationText } from "./confirmation-text.mjs";
 import { chatPostCard, chatPostCardStatus, chatPostReceipt, withChatPostCard } from "./chat-post-card.mjs";
-import { n as currentInboundRequest, p as reportTelegramError } from "../../../_chunks/inbound-request-BXhiIph-.mjs";
+import { n as currentInboundRequest, p as reportTelegramError } from "../../../_chunks/inbound-request-RIRNBxUC.mjs";
+import { agentMessage, observedChatKey, withConfirmationPrompt } from "../group-routing/observed.mjs";
+import { conversationEvent } from "../conversations.mjs";
 import { chatPostOperationId, isChatPost } from "../chat-post-confirmation.mjs";
 import { confirmations } from "../confirmations.mjs";
 import { formatAddress, scopedAddress } from "./sessions.mjs";

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

@@ -1,3 +1,4 @@
+import type { StructuredMessage } from "./structured.js";
 import type { AgentIdentities } from "../identities.js";
 import { type Conversations } from "../conversations.js";
 import type { AgentChats } from "./chats.js";
@@ -9,6 +10,7 @@ export declare const REVISION_CLAIM_TTL_MS: number;
 /** Runs after webhook verification, before eve drops bot/channel/service updates. */
 export declare function captureTelegramWebhook(input: {
     readonly answerCallback?: (id: string, locale?: string) => Promise<unknown>;
+    readonly structured?: (raw: Readonly<Record<string, unknown>>) => StructuredMessage | undefined;
     readonly request: Request;
     readonly archive: Conversations;
     readonly identities: AgentIdentities;
@@ -33,6 +35,7 @@ export declare function conversationIdentities(identities: AgentIdentities): Age
 /** Verification and failure acknowledgement stay outside eve's swallowed onMessage failures. */
 export declare function telegramConversationCapture(input: {
     readonly answerCallback?: (id: string, locale?: string) => Promise<unknown>;
+    readonly structured?: (raw: Readonly<Record<string, unknown>>) => StructuredMessage | undefined;
     readonly archive: Conversations;
     readonly identities: () => AgentIdentities;
     readonly observed: ObservedMessages;

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

@@ -4,10 +4,10 @@ import { createRequire as __eveCreateRequire } from "node:module";
 const __filename = __eveFileURLToPath(import.meta.url);
 __eveDirname(__filename);
 __eveCreateRequire(import.meta.url);
+import { n as currentInboundRequest, p as reportTelegramError, s as currentThreadId } from "../../../_chunks/inbound-request-RIRNBxUC.mjs";
 import { currentConfirmationPrompt, observedChatKey } from "../group-routing/observed.mjs";
 import { conversationEvent } from "../conversations.mjs";
 import { archivedRoutingMessages } from "../group-routing/routing-context.mjs";
-import { n as currentInboundRequest, p as reportTelegramError, s as currentThreadId } from "../../../_chunks/inbound-request-BXhiIph-.mjs";
 import { contentShape, messageContent } from "./content.mjs";
 import { messageMetadata } from "./observed.mjs";
 import { reportMembership } from "./membership.mjs";
@@ -108,6 +108,7 @@ async function captureTelegramWebhook(input) {
 	if (parsed?.kind !== "message") return input.next();
 	const message = parsed.message;
 	const content = messageContent(message.raw);
+	const structured = input.structured?.(message.raw);
 	const time = edited === void 0 ? message.raw.date : message.raw.edit_date ?? message.raw.date;
 	const sentAt = typeof time === "number" ? time * 1e3 : Date.now();
 	const senderChat = record(message.raw.sender_chat);
@@ -158,8 +159,10 @@ async function captureTelegramWebhook(input) {
 	const revisionId = edited === void 0 ? void 0 : `telegram:${message.chat.id}:${message.messageId}:routing:${createHash("sha256").update(JSON.stringify({
 		at: event.at,
 		content,
+		...structured === void 0 ? {} : { structured },
 		...event.attachments.length === 0 ? {} : { attachments: attachmentIdentity(event.attachments) }
 	})).digest("hex")}`;
+	const dispatchKey = `telegram:${message.chat.id}:${message.messageId}` + (structured === void 0 ? "" : `:structured:${revisionId ?? "initial"}`);
 	const revisionEvents = [];
 	let revisionClaim;
 	const finishRevision = async (status) => {
@@ -197,12 +200,31 @@ async function captureTelegramWebhook(input) {
 		...lookup?.status === "paired" ? { participantId: lookup.member.id } : {}
 	})).events;
 	const routing = messageHistory.filter((earlier) => earlier.kind === "decision" && earlier.senderId === event.senderId);
-	const previousClaim = routing.find((earlier) => earlier.reason === "turn_claimed");
-	const admitted = routing.some((earlier) => earlier.reason === "turn_admitted");
-	const released = previousClaim !== void 0 && routing.some((earlier) => earlier.eventId === `${previousClaim.eventId}:released`);
-	const dispatched = routing.some((earlier) => earlier.reason === "turn_dispatch_started");
+	const dispatchHistory = structured === void 0 ? routing : routing.filter((earlier) => earlier.eventId.startsWith(`${dispatchKey}:`));
+	const previousClaim = dispatchHistory.find((earlier) => earlier.reason === "turn_claimed");
+	const admitted = dispatchHistory.some((earlier) => earlier.reason === "turn_admitted");
+	const released = previousClaim !== void 0 && dispatchHistory.some((earlier) => earlier.eventId === `${previousClaim.eventId}:released`);
+	const dispatched = dispatchHistory.some((earlier) => earlier.reason === "turn_dispatch_started");
 	const reserved = previousClaim !== void 0 && !released && Date.now() - Date.parse(previousClaim.at) < 6e5;
-	const alreadyHandled = admitted || dispatched || reserved;
+	const result = dispatchHistory.find((earlier) => earlier.reason === "structured_action_completed" && earlier.status === "completed");
+	let structuredContext;
+	if (structured !== void 0 && result?.argsSummary && lookup === void 0 && message.from !== void 0 && !message.from.isBot) {
+		lookup = await input.identities.lookup({
+			provider: "telegram",
+			externalId: message.from.id
+		});
+		capture.lookup = lookup;
+	}
+	if (structured !== void 0 && lookup?.status === "paired" && result?.argsSummary) try {
+		const value = record(JSON.parse(result.argsSummary));
+		if (typeof value.memberId === "string" && value.memberId === lookup.member.id && typeof value.context === "string" && value.context.trim() && value.context.length <= 16384) structuredContext = {
+			text: value.context,
+			memberId: value.memberId
+		};
+	} catch {}
+	const continuationDispatched = dispatchHistory.some((earlier) => earlier.reason === "structured_context_dispatch_started");
+	const continuationPending = dispatched && structuredContext !== void 0 && !admitted && !continuationDispatched;
+	const alreadyHandled = (admitted || dispatched || reserved) && !continuationPending;
 	const rememberRevision = (events) => {
 		if (revisionId !== void 0) revisionEvents.push(...events.filter((item) => item.eventId === revisionId || item.eventId.startsWith(`${revisionId}:`)));
 	};
@@ -282,8 +304,9 @@ async function captureTelegramWebhook(input) {
 	}
 	let accepted = false;
 	if (inbound !== void 0) {
-		inbound.edited = edited !== void 0;
-		if (revisionId !== void 0) inbound.claimRevision = async () => {
+		inbound.structuredContext = continuationPending ? structuredContext : void 0;
+		inbound.edited = edited !== void 0 && !continuationPending;
+		if (revisionId !== void 0 && !continuationPending) inbound.claimRevision = async () => {
 			if (revisionEvents.some((item) => item.eventId === `${revisionId}:completed`)) return false;
 			const claims = revisionEvents.filter((item) => item.reason === "routing_claimed");
 			const latest = claims[0];
@@ -305,9 +328,9 @@ async function captureTelegramWebhook(input) {
 			return inserted !== false;
 		};
 		const nextClaim = previousClaim === void 0 ? void 0 : createHash("sha256").update(previousClaim.eventId).digest("hex");
-		const claimId = previousClaim === void 0 ? `telegram:${message.chat.id}:${message.messageId}:turn` : `telegram:${message.chat.id}:${message.messageId}:turn:${nextClaim}`;
-		let claimed = false;
-		let dispatchStarted = false;
+		const claimId = continuationPending && previousClaim !== void 0 ? previousClaim.eventId : previousClaim === void 0 ? `${dispatchKey}:turn` : `${dispatchKey}:turn:${nextClaim}`;
+		let claimed = continuationPending;
+		let dispatchStarted = continuationPending;
 		const claimEvent = (reason, status, suffix = "") => ({
 			...capture.event,
 			eventId: `${claimId}${suffix}`,
@@ -327,10 +350,32 @@ async function captureTelegramWebhook(input) {
 		inbound.beginDispatch = async () => {
 			dispatchStarted = await input.archive.append({
 				...claimEvent("turn_dispatch_started", "requested"),
-				eventId: `telegram:${message.chat.id}:${message.messageId}:dispatch`
+				eventId: `${dispatchKey}:dispatch`
 			}) === true;
 			return dispatchStarted;
 		};
+		inbound.recordStructuredContext = async (context, memberId) => {
+			if (await input.archive.append({
+				...claimEvent("structured_action_completed", "completed"),
+				eventId: `${dispatchKey}:result`,
+				argsSummary: JSON.stringify({
+					context,
+					memberId
+				})
+			}) !== true) throw new Error("The archive did not acknowledge the structured continuation.");
+			inbound.structuredContext = {
+				text: context,
+				memberId
+			};
+		};
+		inbound.beginStructuredContinuation = async () => {
+			const inserted = await input.archive.append({
+				...claimEvent("structured_context_dispatch_started", "requested"),
+				eventId: `${dispatchKey}:context-dispatch`
+			});
+			dispatchStarted ||= inserted === true;
+			return inserted === true;
+		};
 		inbound.finishClaim = async (delivered) => {
 			if ((accepted || dispatchStarted) && !delivered) return;
 			accepted ||= delivered;

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

@@ -5,5 +5,5 @@ const __filename = __eveFileURLToPath(import.meta.url);
 __eveDirname(__filename);
 __eveCreateRequire(import.meta.url);
 import { isTechnicalText } from "../customer-text-safety.mjs";
-import { a as TelegramDeliveryError, c as customerCopy, d as failureText, f as formattingRefused, h as withDeliveryLocale, l as customerMessage, m as safeTelegramFetch, o as currentLocale, p as reportTelegramError, s as currentThreadId, u as customerText } from "../../../_chunks/inbound-request-BXhiIph-.mjs";
+import { a as TelegramDeliveryError, c as customerCopy, d as failureText, f as formattingRefused, h as withDeliveryLocale, l as customerMessage, m as safeTelegramFetch, o as currentLocale, p as reportTelegramError, s as currentThreadId, u as customerText } from "../../../_chunks/inbound-request-RIRNBxUC.mjs";
 export { TelegramDeliveryError, currentLocale, currentThreadId, customerCopy, customerMessage, customerText, failureText, formattingRefused, isTechnicalText, reportTelegramError, safeTelegramFetch, withDeliveryLocale };

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

@@ -5,18 +5,18 @@ const __filename = __eveFileURLToPath(import.meta.url);
 __eveDirname(__filename);
 __eveCreateRequire(import.meta.url);
 import { telegramText, withTelegramLocale } from "./texts.mjs";
-import { telegramPrincipal } from "./principal.mjs";
-import { agentMessage, observedChatKey, withConfirmationPrompt } from "../group-routing/observed.mjs";
-import { conversationEvent } from "../conversations.mjs";
+import { o as telegramPrincipal } from "../../../_chunks/principal-MEMlG3EG.mjs";
 import { humanText } from "../confirmation-description.mjs";
 import { renderConfirmation, withConfirmationText } from "./confirmation-text.mjs";
 import { chatPostCard, chatPostCardStatus, chatPostReceipt, withChatPostCard } from "./chat-post-card.mjs";
-import { n as currentInboundRequest, p as reportTelegramError } from "../../../_chunks/inbound-request-BXhiIph-.mjs";
+import { n as currentInboundRequest, p as reportTelegramError } from "../../../_chunks/inbound-request-RIRNBxUC.mjs";
+import { agentMessage, observedChatKey, withConfirmationPrompt } from "../group-routing/observed.mjs";
+import { conversationEvent } from "../conversations.mjs";
 import { CONFIRMATION_TTL_MS, inputHash } from "../confirmations.mjs";
 import { OntologyToolRejected } from "../ontology-tools.mjs";
+import { formatAddress } from "./sessions.mjs";
 import { confirmationOutcome } from "../confirmation-outcome.mjs";
 import { deferredConfirmations, deferredKey, runDeferredAction } from "../deferred-confirmations.mjs";
-import { formatAddress } from "./sessions.mjs";
 import { telegramTextLinks } from "@segmentstream-cloud/ontology/telegram";
 const PREFIX = "ss-confirm:d:";
 const isDeferredCallback = (data) => data?.startsWith(PREFIX) === true;

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

@@ -4,8 +4,8 @@ import { createRequire as __eveCreateRequire } from "node:module";
 const __filename = __eveFileURLToPath(import.meta.url);
 __eveDirname(__filename);
 __eveCreateRequire(import.meta.url);
-import { conversationLanguage } from "./principal.mjs";
-import { d as failureText, p as reportTelegramError } from "../../../_chunks/inbound-request-BXhiIph-.mjs";
+import { n as conversationLanguage } from "../../../_chunks/principal-MEMlG3EG.mjs";
+import { d as failureText, p as reportTelegramError } from "../../../_chunks/inbound-request-RIRNBxUC.mjs";
 import { describableImage, describeReceivedImage } from "./images.mjs";
 import { MAXIMUM_ATTACHMENT_BYTES, attachmentUrl } from "../attachments.mjs";
 function telegramConversation(chatId) {