@segmentstream/agent 0.12.2 → 0.14.0

package/dist/extension/lib/ontology-connection.d.ts

@@ -36,6 +36,7 @@ export declare function ontologyConnection(input: {
     readonly fetch?: typeof fetch;
     /** Set only by the authenticated catalog handshake, never by model input. */
     readonly chatPosting?: boolean;
+    readonly runtimeSource?: boolean;
 }): McpClientConnectionDefinition | null;
 /** Negotiate before opening Eve's client: old strict schemas never receive the new envelope. */
 export declare function ontologyConnectionForTurn(input: Parameters<typeof ontologyConnection>[0]): Promise<McpClientConnectionDefinition | null>;

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

@@ -5,7 +5,7 @@ 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 { c as compatibleRuntimeEnvelope, i as memberIdOf, r as identityProviderOf, u as runtimeEnvelope } from "../../_chunks/principal-VFQWqe5S.mjs";
 import { runtimeToken, tokenExpiry } from "./runtime-token.mjs";
 import { CHAT_POST_ENVELOPE, chatPostDigest, chatPostOperationId, isChatPost } from "./chat-post-confirmation.mjs";
 import { actionApproval, confirmations } from "./confirmations.mjs";
@@ -31,21 +31,23 @@ function ontologyConnection(input) {
 	if (memberId === void 0) return null;
 	const origin = appOrigin(input.environment ?? process.env);
 	const token = input.token ?? runtimeToken;
+	const chatProtocol = input.chatPosting ? ":chat-post-v1" : "";
+	const sourceProtocol = input.runtimeSource ? ":runtime-source-v1" : "";
 	return defineMcpClientConnection({
 		url: `${origin}/mcp`,
 		description: DESCRIPTION,
-		instanceKey: `${origin}/mcp#member:${memberId}${input.chatPosting ? ":chat-post-v1" : ""}`,
+		instanceKey: `${origin}/mcp#member:${memberId}${chatProtocol}${sourceProtocol}`,
 		approval: actionApproval(ontologyTools(input)),
-		...input.chatPosting ? { toolCall: { providedArguments: { [CHAT_POST_ENVELOPE]: (ctx) => {
+		...input.chatPosting || input.runtimeSource ? { toolCall: { providedArguments: { [CHAT_POST_ENVELOPE]: (ctx) => {
 			actAsHeaders({
 				principal: ctx.session.auth.current,
 				expectedMemberId: memberId
 			});
-			const base = {
-				version: 1,
-				session_id: ctx.session.id,
-				call_id: ctx.callId
-			};
+			const base = compatibleRuntimeEnvelope(runtimeEnvelope({
+				principal: ctx.session.auth.current,
+				sessionId: ctx.session.id,
+				callId: ctx.callId
+			}), input.runtimeSource === true);
 			if (!isChatPost(ctx.toolName)) return base;
 			const saved = confirmations.get()[ctx.callId];
 			const preview = saved?.description?.chatPost;
@@ -56,7 +58,8 @@ function ontologyConnection(input) {
 				source: {
 					provider: "telegram",
 					chat_id: saved.source.chatId,
-					thread_id: saved.source.threadId
+					thread_id: saved.source.threadId,
+					...base.source
 				},
 				expected: {
 					chat_id: preview.chatId,
@@ -84,15 +87,18 @@ function ontologyConnection(input) {
 async function ontologyConnectionForTurn(input) {
 	const memberId = memberIdOf(input.principal);
 	if (memberId === void 0) return null;
-	let chatPosting = false;
+	let capabilities = {
+		chatPosting: false,
+		runtimeSource: false
+	};
 	try {
-		chatPosting = await ontologyTools(input).supportsChatPosting(memberId);
+		capabilities = await ontologyTools(input).capabilities(memberId);
 	} catch (error) {
 		console.warn("Chat posting capability unavailable; keeping the compatible ontology connection.", error);
 	}
 	return ontologyConnection({
 		...input,
-		chatPosting
+		...capabilities
 	});
 }
 export { ACT_AS_HEADER, MemberRequiredError, actAsHeaders, ontologyConnection, ontologyConnectionForTurn };

package/dist/extension/lib/ontology-gateway.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, u as runtimeEnvelope } from "../../_chunks/principal-VFQWqe5S.mjs";
 import { object } from "./confirmation-description.mjs";
 import { readOntologyMetadata } from "./ontology-metadata-read.mjs";
 async function ontologyMetadata(memberId, operation, input, context, options = {}) {
@@ -16,7 +16,14 @@ async function ontologyMetadata(memberId, operation, input, context, options = {
 			name: operation,
 			arguments: input
 		}
-	}, context, options);
+	}, context, {
+		...options,
+		envelope: runtimeEnvelope({
+			principal,
+			sessionId: context.session.id,
+			callId: context.callId
+		})
+	});
 	return result.structuredContent === void 0 ? result : object(result.structuredContent);
 }
 async function ontologyInspect(memberId, input, context, options = {}) {

package/dist/extension/lib/ontology-metadata-read.mjs

@@ -5,7 +5,7 @@ const __filename = __eveFileURLToPath(import.meta.url);
 __eveDirname(__filename);
 __eveCreateRequire(import.meta.url);
 import { appOrigin } from "./environment.mjs";
-import { memberIdOf } from "./telegram/principal.mjs";
+import { i as memberIdOf } from "../../_chunks/principal-VFQWqe5S.mjs";
 import { redactDiagnostic } from "./diagnostics.mjs";
 import { object } from "./confirmation-description.mjs";
 import { OntologyToolRejected, ontologyTools } from "./ontology-tools.mjs";

package/dist/extension/lib/ontology-tools.d.ts

@@ -1,3 +1,4 @@
+import { type RuntimeEnvelope } from "./runtime-envelope.js";
 import type { SessionAuthContext } from "eve/context";
 import type { ActionAnnotations } from "./confirmations.js";
 import { type Environment } from "./environment.js";
@@ -13,17 +14,23 @@ export declare class OntologyActionNotPermitted extends Error {
 /** A fresh, permission-filtered catalog. Listing tools cannot run an action's prepare step. */
 export declare function ontologyTools(options?: {
     readonly principal?: SessionAuthContext | null;
+    readonly envelope?: RuntimeEnvelope;
     readonly environment?: Environment;
     readonly token?: RuntimeToken;
     readonly fetch?: typeof fetch;
 }): {
     rpc: (memberId: string, method: string, params: Record<string, unknown>, signal?: AbortSignal) => Promise<Record<string, unknown>>;
     list(memberId: string): Promise<Record<string, unknown>[]>;
+    supportsRuntimeSource(memberId: string, signal?: AbortSignal): Promise<boolean>;
+    capabilities(memberId: string): Promise<{
+        chatPosting: boolean;
+        runtimeSource: boolean;
+    }>;
     supportsChatPosting(memberId: string): Promise<boolean>;
-    labels(memberId: string, action: string, input?: Readonly<Record<string, unknown>>): Promise<ActionAnnotations>;
+    labels(memberId: string, action: string, input?: Readonly<Record<string, unknown>>, signal?: AbortSignal): Promise<ActionAnnotations>;
     describe(memberId: string, action: string, input: Readonly<Record<string, unknown>>): Promise<import("./confirmation-description.js").ConfirmationDescription>;
 };
-export declare function ontologyToolLabels(options?: Parameters<typeof ontologyTools>[0]): (memberId: string, action: string, input?: Readonly<Record<string, unknown>>) => Promise<ActionAnnotations>;
+export declare function ontologyToolLabels(options?: Parameters<typeof ontologyTools>[0]): (memberId: string, action: string, input?: Readonly<Record<string, unknown>>, signal?: AbortSignal) => Promise<ActionAnnotations>;
 /** MCP normalizes an authored camelCase action to snake_case. */
 export declare function actionToolName(entity: string, action: string): string;
 /** One target contract for native and MCP attachment promotion; never trust supplied safety hints. */

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-VFQWqe5S.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,7 +18,19 @@ 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]);
@@ -46,6 +58,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 +132,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
@@ -154,7 +178,7 @@ function ontologyTools(options = {}) {
 						caller,
 						destinations
 					}),
-					action: typeof tool.title === "string" ? tool.title : "❓"
+					action: typeof tool.title === "string" ? tool.title : typeof tool.description === "string" ? tool.description.split("\n\n")[0] : ""
 				};
 			}
 			let entities = [];

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-VFQWqe5S.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-VFQWqe5S.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

@@ -4,21 +4,23 @@ import { createRequire as __eveCreateRequire } from "node:module";
 const __filename = __eveFileURLToPath(import.meta.url);
 __eveDirname(__filename);
 __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-VFQWqe5S.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 { 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-CLprTpsn.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, p as reportTelegramError, r as runInboundRequest, t as InboundRequest } from "../../../_chunks/inbound-request-BrWspFw5.mjs";
-import { attachmentLifecycle } from "./lifecycle.mjs";
 import { scopedAddress, sessionPolicy } from "./sessions.mjs";
+import { handleWorkspaceCallback, isWorkspaceCallback } from "./callbacks.mjs";
+import { t as agentBuild } from "../../../_chunks/build-metadata-BB2uSGsI.mjs";
+import { attachmentLifecycle } from "./lifecycle.mjs";
 import { observedMessages } from "./observed.mjs";
 import { expireDeferredCards, handleDeferredCallback, isDeferredCallback } from "./deferred-confirmations.mjs";
 import { gatewayImageDescriber } from "./images.mjs";
@@ -120,7 +122,31 @@ function segmentstreamTelegram(options) {
 		identities: pairing,
 		observed,
 		chats,
-		verify: telegramWebhookVerifier(() => webhookSecret(environment))
+		verify: telegramWebhookVerifier(() => webhookSecret(environment)),
+		answerCallback: async (callbackQueryId, locale) => {
+			const text = telegramText("callback", "unsupported", locale);
+			const reply = await proxy().request({
+				api: "bot",
+				method: "POST",
+				path: "/answerCallbackQuery",
+				headers: [["content-type", "application/json"]],
+				body: new TextEncoder().encode(JSON.stringify({
+					callback_query_id: callbackQueryId,
+					...text === void 0 ? {} : { text }
+				}))
+			});
+			const body = new TextDecoder().decode(reply.body);
+			let answer;
+			try {
+				answer = JSON.parse(body);
+			} catch (cause) {
+				throw new Error(`Telegram callback acknowledgement was invalid (HTTP ${reply.status}): ${body}`, { cause });
+			}
+			if (reply.status < 200 || reply.status >= 300 || answer === null || typeof answer !== "object" || !("ok" in answer) || answer.ok !== true) throw new Error("Telegram callback acknowledgement was refused.", { cause: {
+				status: reply.status,
+				body
+			} });
+		}
 	});
 	let store = options.attachments;
 	function attachments() {
@@ -279,7 +305,23 @@ function segmentstreamTelegram(options) {
 			}
 		},
 		onCallbackQuery: async (context, query) => {
+			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,
@@ -306,7 +348,7 @@ function segmentstreamTelegram(options) {
 				reportTelegramError("confirmation_callback_failed", error);
 				await context.telegram.answerCallbackQuery({
 					callbackQueryId: query.id,
-					text: "⚠️"
+					...telegramText("callback", "error") === void 0 ? {} : { text: telegramText("callback", "error") }
 				});
 			}
 		},
@@ -404,7 +446,7 @@ function segmentstreamTelegram(options) {
 				const locale = confirmationLocale(principal ?? null, context.state.customerLocale ?? "en");
 				context.state.customerLocale = locale;
 				await withDeliveryLocale(locale, async () => {
-					await handler(event, context);
+					await withTelegramTexts(options.admission?.().texts ?? {}, () => handler(event, context), currentLocale);
 				}, context.state.messageThreadId === null ? void 0 : String(context.state.messageThreadId), typeof principal?.attributes.replyToMessageId === "string" ? principal.attributes.replyToMessageId : void 0, typeof principal?.attributes.chatId === "string" ? principal.attributes.chatId : void 0);
 			}]))
 		} },
@@ -482,7 +524,7 @@ function gatedRoute(input) {
 			};
 			inbound.waitUntil = waitUntil;
 			inbound.backgroundUntil = (task) => args.waitUntil(task);
-			return runInboundRequest(inbound, () => input.capture(request, async (routedRequest = request) => {
+			return withTelegramTexts(options.admission?.().texts ?? {}, () => runInboundRequest(inbound, () => input.capture(request, async (routedRequest = request) => {
 				const response = await route.handler(routedRequest, {
 					...args,
 					waitUntil,
@@ -501,7 +543,7 @@ function gatedRoute(input) {
 					headers: { "retry-after": "1" }
 				});
 				return response;
-			}));
+			})), currentLocale);
 		}
 	};
 }

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-BrWspFw5.mjs";
+import { p as reportTelegramError } from "../../../_chunks/inbound-request-BXhiIph-.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-VFQWqe5S.mjs";
 import { redactDiagnostic } from "../diagnostics.mjs";
 import { confirmationLocale } from "./confirmation-text.mjs";
 import { inTelegramSendQueue, telegramSendScope } from "./send-queue.mjs";
-import { c as customerCopy, f as formattingRefused, l as customerMessage, p as reportTelegramError } from "../../../_chunks/inbound-request-BrWspFw5.mjs";
+import { d as failureText, f as formattingRefused, l as customerMessage, p as reportTelegramError } from "../../../_chunks/inbound-request-BXhiIph-.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";
@@ -83,14 +83,17 @@ async function sendAttachmentsInOrder(options) {
 	const environment = options.environment ?? process.env;
 	const principal = options.principal;
 	const locale = confirmationLocale(principal);
-	const unavailable = (error, diagnostic) => ({
-		error,
-		detail: customerCopy().attachment,
-		reference: reportTelegramError("attachment_send_refused", {
+	const unavailable = (error, diagnostic) => {
+		const reference = reportTelegramError("attachment_send_refused", {
 			error,
 			diagnostic
-		})
-	});
+		});
+		return {
+			error,
+			detail: failureText(reference, "attachment", locale),
+			reference
+		};
+	};
 	if (!channelsEnabled(environment)) return unavailable("channels_disabled", "Attachments can be sent only in production.");
 	if (options.connection === void 0) return unavailable("unsupported", "The Telegram channel is not configured.");
 	if (principal?.authenticator !== "segmentstream-telegram" || typeof principal.attributes.chatId !== "string" || !/^-?\d{1,20}$/.test(principal.attributes.chatId)) return unavailable("no_telegram_chat", "This turn has no Telegram chat.");
@@ -104,7 +107,7 @@ async function sendAttachmentsInOrder(options) {
 		const reference = reportTelegramError("attachment_owner_refused", error);
 		return {
 			error: "forbidden",
-			detail: customerCopy().attachment,
+			detail: failureText(reference, "attachment", locale),
 			reference
 		};
 	}
@@ -187,7 +190,7 @@ async function sendAttachmentsInOrder(options) {
 				id: reference.id,
 				filename,
 				error: error instanceof AttachmentError ? error.code : "unavailable",
-				detail: customerCopy().attachment,
+				detail: failureText(errorId, "attachment", locale),
 				reference: errorId
 			};
 		}
@@ -271,7 +274,7 @@ async function sendAttachmentsInOrder(options) {
 					id: file.id,
 					filename: file.filename,
 					error: error instanceof AttachmentError ? error.code : "send_failed",
-					detail: customerCopy().attachment,
+					detail: failureText(errorId, "attachment", locale),
 					reference: errorId
 				};
 			});

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-VFQWqe5S.mjs";
+import { object } from "../confirmation-description.mjs";
+import { n as currentInboundRequest, p as reportTelegramError } from "../../../_chunks/inbound-request-BXhiIph-.mjs";
+import { formatAddress, parseAddress, scopedAddress } from "./sessions.mjs";
+import { workspaceAction } from "./workspace-action.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/chat-post-card.d.ts

@@ -7,4 +7,4 @@ export declare function chatPostCardLinks(text: string): readonly string[] | und
 export declare function chatPostCard(description: ConfirmationDescription, copy?: ConfirmationCopy): ConfirmationText;
 /** Status/receipt strings are data outside the already rendered preview. */
 export declare function chatPostCardStatus(text: string, status: string): string;
-export declare function chatPostReceipt(output: unknown, completed?: string): string | undefined;
+export declare function chatPostReceipt(output: unknown): string | undefined;