@segmentstream/agent 0.6.14 → 0.7.0

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

@@ -0,0 +1,149 @@
+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 { appOrigin } from "./environment.mjs";
+import { memberIdOf } from "./telegram/principal.mjs";
+import { humanText, object } from "./confirmation-description.mjs";
+import { chatPostDigest, chatPostOperationId, isChatPost } from "./chat-post-confirmation.mjs";
+import { actionApproval, inputHash } from "./confirmations.mjs";
+import { redactDiagnostic } from "./diagnostics.mjs";
+import { runtimeToken } from "./runtime-token.mjs";
+import { ontologyTools } from "./ontology-tools.mjs";
+import { createHash } from "node:crypto";
+const deferredKey = (id) => createHash("sha256").update(id).digest("hex").slice(0, 20);
+function deferredConfirmations(options = {}) {
+	return { async command(command) {
+		const credential = await (options.token ?? runtimeToken)();
+		try {
+			const response = await (options.fetch ?? fetch)(`${appOrigin(options.environment ?? process.env)}/api/ontology/agent/confirmations`, {
+				method: "POST",
+				redirect: "error",
+				signal: AbortSignal.timeout(15e3),
+				headers: {
+					authorization: `Bearer ${credential}`,
+					"content-type": "application/json"
+				},
+				body: JSON.stringify(command)
+			});
+			if (!response.ok) throw new Error(`Confirmation ledger unavailable (HTTP ${response.status}).`, { cause: await response.text() });
+			return (await response.json()).result;
+		} catch (error) {
+			throw new Error("Confirmation ledger request failed.", { cause: redactDiagnostic(error, new Set([credential])) });
+		}
+	} };
+}
+async function executeDeferredTool(memberId, action, input, ctx, options = {}) {
+	if (memberIdOf(ctx.session.auth.current) !== memberId) throw new Error("The ontology tool belongs to another member.");
+	if (Object.hasOwn(input, "_segmentstream")) throw new Error("Runtime call metadata is application-owned.");
+	const principal = ctx.session.auth.current;
+	const attributes = principal?.attributes;
+	const id = chatPostOperationId(ctx.session.id, ctx.callId);
+	const key = deferredKey(id);
+	const hash = inputHash(input);
+	const store = deferredConfirmations(options);
+	const existing = await store.command({
+		operation: "read",
+		key
+	});
+	const boundResult = (record) => {
+		if (record.id !== id || record.key !== key || record.memberId !== memberId || record.inputHash !== hash || inputHash(record.data.input) !== hash || record.data.action !== action || record.data.sessionId !== ctx.session.id || record.data.callId !== ctx.callId || principal?.authenticator !== "segmentstream-telegram" || !principal.subject || typeof attributes?.chatId !== "string" || record.data.requester !== principal.subject || record.data.chatId !== attributes?.chatId || record.data.threadId !== String(attributes?.messageThreadId ?? "")) throw new Error("The confirmation call was replayed with another identity, action or input.");
+		return {
+			status: record.status === "pending" ? "awaiting_confirmation" : record.status,
+			confirmation: record.id
+		};
+	};
+	if (existing !== null) return boundResult(existing);
+	const tools = ontologyTools(options);
+	let saved = {};
+	const result = await actionApproval({
+		...tools,
+		state: {
+			get: () => saved,
+			update: (update) => {
+				saved = update(saved);
+			}
+		}
+	}).request({
+		...ctx,
+		callId: ctx.callId,
+		toolName: action,
+		toolInput: input,
+		approvedTools: new Set()
+	});
+	if (typeof result === "object" && result.type === "denied") throw new Error(result.reason);
+	const confirmation = saved[ctx.callId];
+	if (confirmation === void 0) {
+		const response = await tools.rpc(memberId, "tools/call", {
+			name: action,
+			arguments: input
+		});
+		return object(response.structuredContent ?? response);
+	}
+	if (principal?.authenticator !== "segmentstream-telegram" || !principal.subject || typeof attributes?.chatId !== "string") throw new Error("Deferred confirmation requires an authenticated Telegram requester.");
+	const record = await store.command({
+		operation: "create",
+		record: {
+			id,
+			key,
+			memberId,
+			inputHash: hash,
+			expiresAt: confirmation.expiresAt,
+			status: "pending",
+			data: {
+				action,
+				input,
+				confirmation,
+				sessionId: ctx.session.id,
+				callId: ctx.callId,
+				chatId: attributes.chatId,
+				threadId: String(attributes.messageThreadId ?? ""),
+				requester: principal.subject,
+				...humanText(attributes.memberName) === void 0 ? {} : { requesterName: humanText(attributes.memberName) }
+			}
+		}
+	});
+	if (record === null) throw new Error("The confirmation call was replayed with different input.");
+	return boundResult(record);
+}
+async function runDeferredAction(record, options) {
+	if (record.inputHash !== inputHash(record.data.input)) throw new Error("The confirmed input changed.");
+	const tools = ontologyTools(options);
+	await tools.labels(record.memberId, record.data.action);
+	const preview = record.data.confirmation.description?.chatPost;
+	if (isChatPost(record.data.action)) {
+		const input = Object.fromEntries(Object.entries(record.data.input).filter(([key]) => key !== "_confirmation"));
+		const current = (await tools.describe(record.memberId, record.data.action, input)).chatPost;
+		if (!preview || !current || chatPostDigest(preview) !== chatPostDigest(current)) throw new Error("The confirmed chat destination or attribution changed.");
+	}
+	const envelope = {
+		version: 1,
+		session_id: record.data.sessionId,
+		call_id: record.data.callId,
+		operation_id: record.id,
+		...preview ? {
+			source: {
+				provider: "telegram",
+				chat_id: record.data.chatId,
+				thread_id: record.data.threadId
+			},
+			expected: {
+				chat_id: preview.chatId,
+				digest: chatPostDigest(preview)
+			}
+		} : {}
+	};
+	const result = await tools.rpc(record.memberId, "tools/call", {
+		name: record.data.action.split("__").at(-1),
+		arguments: {
+			...record.data.input,
+			_segmentstream: envelope
+		}
+	});
+	const output = result.structuredContent;
+	if (result.isError === true || (output?.validation)?.ok === false || preview !== void 0 && output?.status !== "sent") throw new Error("The confirmed action did not complete; its outcome may be uncertain.", { cause: result });
+	return result;
+}
+export { deferredConfirmations, deferredKey, executeDeferredTool, runDeferredAction };

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

@@ -7,6 +7,8 @@ export declare function ontologyTools(options?: {
     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>[]>;
     supportsChatPosting(memberId: string): Promise<boolean>;
     labels(memberId: string, action: string): Promise<ActionAnnotations>;
     describe(memberId: string, action: string, input: Readonly<Record<string, unknown>>): Promise<import("./confirmation-description.js").ConfirmationDescription>;

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

@@ -5,9 +5,9 @@ const __filename = __eveFileURLToPath(import.meta.url);
 __eveDirname(__filename);
 __eveCreateRequire(import.meta.url);
 import { appOrigin } from "./environment.mjs";
-import { redactDiagnostic } from "./diagnostics.mjs";
 import { describeConfirmation, object } from "./confirmation-description.mjs";
 import { describeChatPost, isChatPost, supportsChatPost } from "./chat-post-confirmation.mjs";
+import { redactDiagnostic } from "./diagnostics.mjs";
 import { runtimeToken } from "./runtime-token.mjs";
 function ontologyTools(options = {}) {
 	async function rpc(memberId, method, params, signal) {
@@ -54,6 +54,11 @@ function ontologyTools(options = {}) {
 		};
 	}
 	return {
+		rpc,
+		async list(memberId) {
+			const result = await rpc(memberId, "tools/list", {});
+			return Array.isArray(result.tools) ? result.tools.map(object) : [];
+		},
 		async supportsChatPosting(memberId) {
 			const result = await rpc(memberId, "tools/list", {});
 			return Array.isArray(result.tools) && result.tools.map(object).some(supportsChatPost);

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

@@ -30,6 +30,7 @@ export interface TelegramAdapterOptions {
     };
     /** The mounted `sessions`. */
     readonly sessions: () => SessionSettings;
+    readonly confirmationMode?: () => "deferred" | "held";
     readonly decide: DecideFunction;
     readonly environment?: Environment;
     readonly token?: RuntimeToken;

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

@@ -8,20 +8,21 @@ import "../../config.mjs";
 import { appOrigin, channelsEnabled, proxyEnvironment, runtimeIdentityEnvironment, webhookSecret } from "../environment.mjs";
 import { conversationLanguage, telegramPrincipal } from "./principal.mjs";
 import { chooseModel } from "../../model.mjs";
-import { d as withDeliveryLocale, f as InboundRequest, h as withReplacedText, l as reportTelegramError, m as runInboundRequest, p as currentInboundRequest, s as failureText, u as safeTelegramFetch } from "../../../_chunks/customer-text-DjszxgTo.mjs";
 import { confirmationLocale } from "./confirmation-text.mjs";
+import { runtimeToken } from "../runtime-token.mjs";
+import { conversations } from "../conversations.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-BwBvXk0A.mjs";
+import { scopedAddress, sessionPolicy } from "./sessions.mjs";
+import { observedMessages } from "./observed.mjs";
+import { expireDeferredCards, handleDeferredCallback, isDeferredCallback } from "./deferred-confirmations.mjs";
 import { gatewayImageDescriber } from "./images.mjs";
 import { gatewayAttachmentDescriber } from "./attachment-description.mjs";
 import { MAXIMUM_DOWNLOAD_BYTES, connectionProxy } from "../connection-proxy.mjs";
-import { runtimeToken } from "../runtime-token.mjs";
 import { agentAttachments, parseAttachmentUrl } from "../attachments.mjs";
 import { agentIdentities } from "../identities.mjs";
-import { conversations } from "../conversations.mjs";
-import { observedMessages } from "./observed.mjs";
 import { decisionRouter } from "./router.mjs";
 import { replyDelivery } from "./silent.mjs";
-import { scopedAddress, sessionPolicy } from "./sessions.mjs";
 import { handleConfirmationCallback, telegramConfirmationEvents } from "./confirmations.mjs";
 import { captureRouteDecider, captureTelegramFetch, conversationIdentities, recordGateDecision, telegramConversationCapture } from "./conversations.mjs";
 import { runtimeTokenVerifier } from "../runtime-identity.mjs";
@@ -142,6 +143,15 @@ function segmentstreamTelegram(options) {
 		},
 		uploadPolicy: { maxBytes: MAXIMUM_DOWNLOAD_BYTES },
 		onMessage: async (context, message) => {
+			if (options.confirmationMode?.() === "deferred") try {
+				await expireDeferredCards(context, {
+					environment,
+					token,
+					...options.fetch ? { fetch: options.fetch } : {}
+				}, archive, observed);
+			} catch (error) {
+				reportTelegramError("deferred_expiry_failed", error);
+			}
 			const inbound = currentInboundRequest();
 			if (inbound !== void 0) {
 				inbound.locale = conversationLanguage([message.text || message.caption]) ?? message.from?.languageCode ?? "en";
@@ -236,6 +246,21 @@ function segmentstreamTelegram(options) {
 		},
 		onCallbackQuery: async (context, query) => {
 			try {
+				if (isDeferredCallback(query.data)) {
+					await handleDeferredCallback({
+						context,
+						query,
+						identities: pairing(),
+						archive,
+						options: {
+							environment,
+							token,
+							...options.fetch ? { fetch: options.fetch } : {}
+						},
+						observed
+					});
+					return;
+				}
 				await handleConfirmationCallback({
 					context,
 					query,
@@ -253,7 +278,11 @@ function segmentstreamTelegram(options) {
 		},
 		events: {
 			...telegramFailureEvents,
-			...telegramConfirmationEvents(archive, observed),
+			...telegramConfirmationEvents(archive, observed, {
+				environment,
+				token,
+				...options.fetch ? { fetch: options.fetch } : {}
+			}),
 			"message.completed": replyDelivery(observed, () => telegramSendScope(environment, settings().connection))
 		}
 	});
@@ -276,6 +305,25 @@ function segmentstreamTelegram(options) {
 	}
 	return {
 		...channel,
+		async receive(input, operations) {
+			const target = input.target;
+			if (target.confirmationSessionId !== void 0) {
+				const address = target.confirmationAddress;
+				if (address === void 0 || (await operations.resolveSession(address))?.id !== target.confirmationSessionId) throw new Error("The confirmation session was replaced.");
+				return operations.from(address).send(input.message, {
+					auth: null,
+					turnPolicy: "queue",
+					state: {
+						chatId: String(target.chatId),
+						chatType: String(target.chatId).startsWith("-") ? "supergroup" : "private",
+						conversationId: null,
+						messageThreadId: target.messageThreadId ?? null
+					}
+				});
+			}
+			if (channel.receive === void 0) throw new Error("The Telegram channel cannot receive events.");
+			return channel.receive(input, operations);
+		},
 		...adapter === void 0 ? {} : { adapter: {
 			...adapter,
 			fetchFile,
@@ -321,6 +369,24 @@ function gatedRoute(input) {
 				resolveSession: args.resolveSession,
 				from: args.from
 			};
+			inbound.confirmationEvent = async (record, result, auth) => {
+				const address = record.data.address;
+				if (address === void 0) throw new Error("Confirmation has no owning session address.");
+				if ((await args.resolveSession(address))?.id !== record.data.sessionId) throw new Error("The confirmation session was replaced.");
+				return args.from(address).send(JSON.stringify({
+					type: "confirmation_result",
+					...result
+				}), {
+					auth,
+					turnPolicy: "queue",
+					state: {
+						chatId: record.data.chatId,
+						chatType: record.data.chatId.startsWith("-") ? "supergroup" : "private",
+						messageThreadId: record.data.threadId ? Number(record.data.threadId) : null,
+						conversationId: null
+					}
+				});
+			};
 			inbound.respond = (address, requestId, decision, auth, text) => args.from(scoped(address)).respond([{
 				requestId,
 				optionId: decision,

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 { l as reportTelegramError } from "../../../_chunks/customer-text-DjszxgTo.mjs";
+import { p as reportTelegramError } from "../../../_chunks/inbound-request-BwBvXk0A.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

@@ -6,12 +6,12 @@ __eveDirname(__filename);
 __eveCreateRequire(import.meta.url);
 import { appOrigin, channelsEnabled, proxyEnvironment } from "../environment.mjs";
 import "./principal.mjs";
-import { redactDiagnostic } from "../diagnostics.mjs";
-import { a as customerMessage, c as formattingRefused, i as customerCopy, l as reportTelegramError } from "../../../_chunks/customer-text-DjszxgTo.mjs";
 import { confirmationLocale } from "./confirmation-text.mjs";
+import { redactDiagnostic } from "../diagnostics.mjs";
+import { runtimeToken } from "../runtime-token.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-BwBvXk0A.mjs";
 import { MAXIMUM_PROXY_BODY_BYTES, connectionProxy } from "../connection-proxy.mjs";
-import { runtimeToken } from "../runtime-token.mjs";
 import { ACT_AS_HEADER } from "../ontology-connection.mjs";
 import { AttachmentError, CONVERSATION_HEADER, SESSION_HEADER } from "../attachments.mjs";
 import { TELEGRAM_PLACEHOLDER_TOKEN, TELEGRAM_PROXY_ORIGIN, telegramProxyFetch } from "./proxy-fetch.mjs";

package/dist/extension/lib/telegram/confirmation-expiry.d.ts

@@ -0,0 +1,4 @@
+import type { TelegramSettings } from "../../config.js";
+import { type DeferredConfirmation, type DeferredOptions } from "../deferred-confirmations.js";
+/** A bounded sweep; concurrent webhooks/schedules compete for the same atomic expiry claim. */
+export declare function expireScheduledConfirmations(connection: string, notify: (record: DeferredConfirmation, result: Readonly<Record<string, unknown>>) => Promise<unknown>, options?: DeferredOptions, settings?: TelegramSettings): Promise<void>;

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

@@ -0,0 +1,50 @@
+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 { proxyEnvironment } from "../environment.mjs";
+import { runtimeToken } from "../runtime-token.mjs";
+import { deferredConfirmations } from "../deferred-confirmations.mjs";
+import { conversations } from "../conversations.mjs";
+import { telegramSendScope } from "./send-queue.mjs";
+import { m as safeTelegramFetch, p as reportTelegramError } from "../../../_chunks/inbound-request-BwBvXk0A.mjs";
+import { expireDeferredRecord } from "./deferred-confirmations.mjs";
+import { connectionProxy } from "../connection-proxy.mjs";
+import { TELEGRAM_PLACEHOLDER_TOKEN, TELEGRAM_PROXY_ORIGIN, telegramProxyFetch } from "./proxy-fetch.mjs";
+import { telegramPreviewEnvironment } from "@segmentstream-cloud/ontology/telegram";
+import { editTelegramMessageText } from "eve/channels/telegram";
+async function expireScheduledConfirmations(connection, notify, options = {}, settings) {
+	const environment = options.environment ?? process.env;
+	const token = options.token ?? runtimeToken;
+	const archive = conversations({
+		environment,
+		token,
+		fetch: options.fetch
+	});
+	const scope = telegramSendScope(environment, connection);
+	const proxy = connectionProxy({
+		environment: proxyEnvironment(environment),
+		connection,
+		token,
+		fetch: options.fetch
+	});
+	const transport = safeTelegramFetch(telegramProxyFetch(proxy, scope), scope, {
+		settings,
+		ownOrigins: telegramPreviewEnvironment(environment).appOrigins
+	});
+	const records = await deferredConfirmations(options).command({ operation: "expired" });
+	for (const record of records) try {
+		await expireDeferredRecord(record, { telegram: { editMessageText: (input) => editTelegramMessageText({
+			apiBaseUrl: TELEGRAM_PROXY_ORIGIN,
+			credentials: { botToken: TELEGRAM_PLACEHOLDER_TOKEN },
+			fetch: transport,
+			chatId: record.data.chatId,
+			...input
+		}) } }, options, archive, notify);
+	} catch (error) {
+		reportTelegramError("deferred_expiry_failed", error);
+	}
+}
+export { expireScheduledConfirmations };

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

@@ -1,3 +1,4 @@
+import type { DeferredOptions } from "../deferred-confirmations.js";
 import type { ChannelEvents } from "eve/channels";
 import type { TelegramCallbackQuery, TelegramChannelEvents, TelegramContext, TelegramEventContext } from "eve/channels/telegram";
 import { type ObservedMessages, type PendingConfirmation, type RecentMessage } from "./observed.js";
@@ -23,5 +24,5 @@ export declare function handleConfirmationCallback(input: {
     readonly scope: "chat" | "thread";
     readonly now?: number;
 }): Promise<void>;
-export declare function telegramConfirmationEvents(archive?: Conversations, observed?: ObservedMessages): TelegramChannelEvents & Pick<ChannelEvents<TelegramEventContext>, "context.cleared">;
+export declare function telegramConfirmationEvents(archive?: Conversations, observed?: ObservedMessages, deferredOptions?: DeferredOptions): TelegramChannelEvents & Pick<ChannelEvents<TelegramEventContext>, "context.cleared">;
 export declare const confirmationEvents: TelegramChannelEvents & Pick<ChannelEvents<TelegramEventContext>, "context.cleared">;

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

@@ -5,16 +5,17 @@ const __filename = __eveFileURLToPath(import.meta.url);
 __eveDirname(__filename);
 __eveCreateRequire(import.meta.url);
 import { memberIdOf, telegramPrincipal } from "./principal.mjs";
-import { l as reportTelegramError, p as currentInboundRequest } from "../../../_chunks/customer-text-DjszxgTo.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 { chatPostOperationId, isChatPost } from "../chat-post-confirmation.mjs";
+import { chatPostCard, chatPostCardStatus, chatPostReceipt, withChatPostCard } from "./chat-post-card.mjs";
 import { confirmations } from "../confirmations.mjs";
 import { conversationEvent } from "../conversations.mjs";
+import { n as currentInboundRequest, p as reportTelegramError } from "../../../_chunks/inbound-request-BwBvXk0A.mjs";
+import { formatAddress, scopedAddress } from "./sessions.mjs";
 import { agentMessage, observedChatKey, withConfirmationPrompt } from "./observed.mjs";
+import { postDeferredCard } from "./deferred-confirmations.mjs";
 import { answerMarker, isPendingQuestion, pendingQuestions, questionKey } from "../questions.mjs";
-import { formatAddress, scopedAddress } from "./sessions.mjs";
 import { telegramTextLinks } from "@segmentstream-cloud/ontology/telegram";
 import { createHash } from "node:crypto";
 import { registerTelegramFreeformPrompt, renderTelegramInputRequest } from "eve/channels/telegram";
@@ -59,7 +60,7 @@ function routingConfirmationState(events, prompt, at) {
 	if (prompt.state !== void 0 && prompt.state !== "pending" && prompt.state !== "approved") return prompt.state;
 	let state = prompt.state ?? "pending";
 	let callId;
-	for (const event of events) {
+	for (const event of prompt.mode === "deferred" ? [] : events) {
 		const data = object(event.data);
 		if ((event.type === "context.cleared" || event.type === "session.started") && Date.parse(event.meta.at) >= Date.parse(prompt.at)) state = "expired";
 		if (event.type === "input.requested" && Array.isArray(data.requests)) {
@@ -191,7 +192,7 @@ function messagePrompt(message) {
 		at: new Date().toISOString()
 	};
 }
-function telegramConfirmationEvents(archive, observed) {
+function telegramConfirmationEvents(archive, observed, deferredOptions) {
 	const remember = (channel, ctx, messageId, text, confirmation) => {
 		const principal = ctx.session.auth.current;
 		const name = humanText(principal?.attributes.memberName);
@@ -389,6 +390,13 @@ function telegramConfirmationEvents(archive, observed) {
 		},
 		async "action.result"(data, channel, ctx) {
 			const state = channel.state;
+			if (data.result.kind === "tool-result" && deferredOptions !== void 0 && archive !== void 0) {
+				const output = object(data.result.output);
+				if (output.status === "awaiting_confirmation" && typeof output.confirmation === "string") {
+					await postDeferredCard(output.confirmation, channel, ctx, deferredOptions, archive, observed);
+					return;
+				}
+			}
 			if (data.result.kind === "tool-result") {
 				const question = object(data.result.output).pendingQuestion;
 				if (data.result.toolName.endsWith("__questions_ask") && isPendingQuestion(question)) {

package/dist/extension/lib/telegram/conversations.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 { p as currentInboundRequest, r as currentThreadId } from "../../../_chunks/customer-text-DjszxgTo.mjs";
 import { conversationEvent } from "../conversations.mjs";
+import { n as currentInboundRequest, s as currentThreadId } from "../../../_chunks/inbound-request-BwBvXk0A.mjs";
 import { contentShape, messageContent } from "./content.mjs";
 import { currentConfirmationPrompt, messageMetadata, observedChatKey } from "./observed.mjs";
 import { archivedRoutingMessages } from "./routing-context.mjs";

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 customerMessage, c as formattingRefused, d as withDeliveryLocale, i as customerCopy, l as reportTelegramError, n as currentLocale, o as customerText, r as currentThreadId, s as failureText, t as TelegramDeliveryError, u as safeTelegramFetch } from "../../../_chunks/customer-text-DjszxgTo.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-BwBvXk0A.mjs";
 export { TelegramDeliveryError, currentLocale, currentThreadId, customerCopy, customerMessage, customerText, failureText, formattingRefused, isTechnicalText, reportTelegramError, safeTelegramFetch, withDeliveryLocale };

package/dist/extension/lib/telegram/deferred-confirmations.d.ts

@@ -0,0 +1,26 @@
+import type { TelegramCallbackQuery, TelegramContext, TelegramHandle, TelegramEventContext } from "eve/channels/telegram";
+import type { SessionContext } from "eve/context";
+import { type DeferredConfirmation, type DeferredOptions } from "../deferred-confirmations.js";
+import { type Conversations } from "../conversations.js";
+import type { AgentIdentities } from "../identities.js";
+import { type ObservedMessages } from "./observed.js";
+export declare const isDeferredCallback: (data?: string) => boolean;
+export declare const deferredCallback: (record: DeferredConfirmation, choice: "y" | "n" | "e") => string;
+export declare function archiveDeferred(record: DeferredConfirmation, phase: string, archive: Conversations): Promise<void>;
+/** Called at the durable tool-result boundary. Pending cards never become eve input requests. */
+export declare function postDeferredCard(id: string, channel: TelegramEventContext, ctx: SessionContext, options: DeferredOptions, archive: Conversations, observed?: ObservedMessages): Promise<void>;
+/** Every callback re-resolves the live identity. The database arbitrates concurrent presses. */
+export declare function handleDeferredCallback(input: {
+    readonly context: TelegramContext;
+    readonly query: TelegramCallbackQuery;
+    readonly identities: AgentIdentities;
+    readonly archive: Conversations;
+    readonly options: DeferredOptions;
+    readonly observed?: ObservedMessages;
+}): Promise<void>;
+/** A database-clock expiry claim is shared by webhooks and the minute schedule. */
+export declare function expireDeferredRecord(record: DeferredConfirmation, context: {
+    readonly telegram: Pick<TelegramHandle, "editMessageText">;
+}, options: DeferredOptions, archive: Conversations, notify: NonNullable<import("./inbound-request.js").InboundRequest["confirmationEvent"]>, observed?: ObservedMessages): Promise<void>;
+/** Webhooks also reconcile expiry if the host's minute scheduler is delayed. */
+export declare function expireDeferredCards(context: TelegramContext, options: DeferredOptions, archive: Conversations, observed?: ObservedMessages): Promise<void>;