@segmentstream/agent 0.6.14 → 0.7.1

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

@@ -0,0 +1,282 @@
+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 { telegramPrincipal } from "./principal.mjs";
+import { humanText } from "../confirmation-description.mjs";
+import { renderConfirmation, withConfirmationText } from "./confirmation-text.mjs";
+import { confirmationOutcome } from "../confirmation-outcome.mjs";
+import { chatPostCard, chatPostCardStatus, chatPostReceipt, withChatPostCard } from "./chat-post-card.mjs";
+import { CONFIRMATION_TTL_MS, inputHash } from "../confirmations.mjs";
+import { deferredConfirmations, deferredKey, runDeferredAction } from "../deferred-confirmations.mjs";
+import { conversationEvent } from "../conversations.mjs";
+import { n as currentInboundRequest, p as reportTelegramError } from "../../../_chunks/inbound-request-BwBvXk0A.mjs";
+import { formatAddress } from "./sessions.mjs";
+import { agentMessage, observedChatKey, withConfirmationPrompt } from "./observed.mjs";
+import { telegramTextLinks } from "@segmentstream-cloud/ontology/telegram";
+const PREFIX = "ss-confirm:d:";
+const isDeferredCallback = (data) => data?.startsWith(PREFIX) === true;
+const deferredCallback = (record, choice) => `${PREFIX}${record.key}:${choice}`;
+const copyOf = (record) => record.data.confirmation.description?.chatPost ? chatPostCard(record.data.confirmation.description, record.data.confirmation.copy) : renderConfirmation(record.data.confirmation.description, record.data.confirmation.copy);
+function promptOf(record, state) {
+	const name = humanText(record.data.requesterName);
+	return {
+		mode: "deferred",
+		requestId: record.id,
+		sessionId: record.data.sessionId,
+		address: record.data.address,
+		action: humanText(record.data.confirmation.description?.action) ?? "❓",
+		requestedBy: name ?? null,
+		at: new Date(record.expiresAt - CONFIRMATION_TTL_MS).toISOString(),
+		state,
+		...name === void 0 ? {} : { requester: {
+			id: record.data.requester,
+			author: name
+		} }
+	};
+}
+function remember(record, text, prompt, observed) {
+	if (record.data.messageId === void 0) return;
+	observed?.remember(observedChatKey({
+		chatId: record.data.chatId,
+		...record.data.threadId ? { messageThreadId: Number(record.data.threadId) } : {}
+	}), {
+		...agentMessage({
+			text,
+			at: new Date().toISOString(),
+			messageId: record.data.messageId,
+			...prompt.requester === void 0 ? {} : { inReplyTo: prompt.requester }
+		}),
+		confirmation: prompt
+	});
+}
+async function archiveDeferred(record, phase, archive) {
+	await archive.append(conversationEvent({
+		eventId: `confirmation:${record.id}:${phase}`,
+		provider: "telegram",
+		chatId: record.data.chatId,
+		threadId: record.data.threadId || null,
+		chatType: record.data.chatId.startsWith("-") ? "group" : "private",
+		participantIds: [record.memberId],
+		kind: "tool_result",
+		sessionId: record.data.sessionId,
+		toolCallId: record.id,
+		operationId: record.id,
+		toolName: record.data.action,
+		reason: phase,
+		status: phase === "done" ? "completed" : phase === "failed" ? "failed" : phase === "cancelled" || phase === "expired" ? "cancelled" : "requested"
+	}));
+}
+async function postDeferredCard(id, channel, ctx, options, archive, observed) {
+	const store = deferredConfirmations(options);
+	const record = await store.command({
+		operation: "read",
+		key: deferredKey(id)
+	});
+	if (!record || record.data.sessionId !== ctx.session.id || record.status !== "pending" || record.data.messageId) return;
+	const copy = copyOf(record);
+	const address = channel.continuation?.token ?? formatAddress({
+		chatId: record.data.chatId,
+		messageThreadId: record.data.threadId,
+		conversationId: channel.telegram.conversationId ?? ""
+	});
+	const prompt = {
+		...promptOf(record, "pending"),
+		address
+	};
+	await archiveDeferred(record, "requested", archive);
+	const post = () => channel.telegram.post({
+		text: copy.text,
+		reply_markup: { inline_keyboard: [[
+			{
+				text: copy.confirm,
+				callback_data: deferredCallback(record, "y")
+			},
+			...record.data.confirmation.description?.chatPost ? [{
+				text: copy.edit,
+				callback_data: deferredCallback(record, "e")
+			}] : [],
+			{
+				text: copy.cancel,
+				callback_data: deferredCallback(record, "n")
+			}
+		]] }
+	});
+	const sent = await withConfirmationPrompt(prompt, () => record.data.confirmation.description?.chatPost ? withChatPostCard(copy.text, post, copy.previewLinks) : withConfirmationText(copy.text, post));
+	await store.command({
+		operation: "attach",
+		key: record.key,
+		messageId: sent.id,
+		address
+	});
+	remember({
+		...record,
+		data: {
+			...record.data,
+			messageId: sent.id,
+			address
+		}
+	}, copy.text, prompt, observed);
+}
+async function editCard(record, context, status, state, observed) {
+	if (!record.data.messageId) return;
+	const copy = copyOf(record);
+	const exact = record.data.confirmation.description?.chatPost !== void 0;
+	const text = exact ? chatPostCardStatus(copy.text, status) : `${copy.text}\n\n${status}`;
+	const edit = () => context.telegram.editMessageText({
+		messageId: record.data.messageId,
+		text,
+		replyMarkup: { inline_keyboard: [] }
+	});
+	const prompt = promptOf(record, state);
+	await withConfirmationPrompt(prompt, () => exact ? withChatPostCard(text, edit, [...copy.previewLinks ?? [], ...telegramTextLinks(status)]) : withConfirmationText(text, edit));
+	remember(record, text, prompt, observed);
+}
+async function handleDeferredCallback(input) {
+	const { query, context, options, archive } = input;
+	const notice = async (text) => {
+		try {
+			await context.telegram.answerCallbackQuery({
+				callbackQueryId: query.id,
+				text,
+				showAlert: false
+			});
+		} catch (error) {
+			reportTelegramError("deferred_acknowledgment_failed", error);
+		}
+	};
+	const parts = /^ss-confirm:d:([0-9a-f]{20}):([yne])$/.exec(query.data ?? "");
+	if (!parts || !query.message || query.from.isBot) {
+		await notice("⚠️");
+		return;
+	}
+	const store = deferredConfirmations(options);
+	const record = await store.command({
+		operation: "read",
+		key: parts[1]
+	});
+	const lookup = await input.identities.lookup({
+		provider: "telegram",
+		externalId: query.from.id
+	});
+	if (!record || lookup.status !== "paired" || lookup.member.id !== record.memberId || record.data.requester !== query.from.id || record.data.chatId !== query.message.chat.id || record.data.threadId !== String(query.message.messageThreadId ?? "") || record.data.messageId !== query.message.messageId) {
+		await notice("🔒");
+		return;
+	}
+	if (record.inputHash !== inputHash(record.data.input) || parts[2] === "e" && record.data.confirmation.description?.chatPost === void 0) {
+		await notice("⚠️");
+		return;
+	}
+	const copy = copyOf(record);
+	const decision = parts[2] === "y" ? "approve" : "cancel";
+	const claimed = await store.command({
+		operation: "decide",
+		key: record.key,
+		memberId: record.memberId,
+		inputHash: inputHash(record.data.input),
+		decision
+	});
+	if (!claimed || claimed.status === "pending") {
+		await notice("⌛");
+		return;
+	}
+	await notice(claimed.status === "expired" ? "⌛" : void 0);
+	let status = claimed.status;
+	let cardStatus = status === "expired" ? copy.expired : copy.cancelled;
+	let execution;
+	try {
+		await archiveDeferred(claimed, claimed.status, archive);
+	} catch (error) {
+		const reference = reportTelegramError("deferred_decision_archive_failed", error);
+		if (status === "approved") {
+			status = "failed";
+			execution = "not_started";
+			cardStatus = `${copy.failed} ${reference}`;
+			await store.command({
+				operation: "finish",
+				key: claimed.key,
+				status
+			});
+		}
+	}
+	if (status === "approved") {
+		try {
+			await editCard(claimed, context, copy.executing, "approved", input.observed);
+		} catch (error) {
+			reportTelegramError("deferred_card_update_failed", error);
+		}
+		try {
+			const result = await runDeferredAction(claimed, options);
+			status = "done";
+			cardStatus = claimed.data.confirmation.description?.chatPost ? chatPostReceipt(result.structuredContent, copy.completed) ?? "⚠️ ❓" : copy.completed;
+		} catch (error) {
+			status = "failed";
+			const reference = reportTelegramError("deferred_action_failed", error);
+			cardStatus = `${copy.failed} ${reference}`;
+		}
+		await store.command({
+			operation: "finish",
+			key: claimed.key,
+			status
+		});
+	}
+	if (status === "done" || status === "failed") try {
+		await archiveDeferred(claimed, status, archive);
+	} catch (error) {
+		reportTelegramError("deferred_outcome_archive_failed", error);
+	}
+	try {
+		await editCard(claimed, context, cardStatus, status === "done" ? "completed" : status, input.observed);
+	} catch (error) {
+		reportTelegramError("deferred_card_update_failed", error);
+	}
+	const principal = telegramPrincipal({
+		member: lookup.member,
+		message: {
+			...query.message,
+			from: query.from,
+			text: "",
+			caption: "",
+			raw: {},
+			attachments: []
+		}
+	});
+	await currentInboundRequest()?.confirmationEvent?.(claimed, confirmationOutcome(claimed, status, {
+		...execution === void 0 ? {} : { execution },
+		...parts[2] === "e" && status === "cancelled" ? { editRequested: true } : {}
+	}), principal);
+}
+async function expireDeferredRecord(record, context, options, archive, notify, observed) {
+	const claimed = await deferredConfirmations(options).command({
+		operation: "decide",
+		key: record.key,
+		memberId: record.memberId,
+		inputHash: record.inputHash,
+		decision: "expire"
+	});
+	if (!claimed) return;
+	try {
+		await archiveDeferred(claimed, "expired", archive);
+	} catch (error) {
+		reportTelegramError("deferred_outcome_archive_failed", error);
+	}
+	try {
+		await editCard(claimed, context, copyOf(claimed).expired, "expired", observed);
+	} catch (error) {
+		reportTelegramError("deferred_card_update_failed", error);
+	}
+	await notify(claimed, confirmationOutcome(claimed, "expired"), null);
+}
+async function expireDeferredCards(context, options, archive, observed) {
+	const records = await deferredConfirmations(options).command({
+		operation: "expired",
+		chatId: context.telegram.chatId
+	});
+	for (const record of records) {
+		if (record.data.threadId !== String(context.telegram.messageThreadId ?? "")) continue;
+		await expireDeferredRecord(record, context, options, archive, async (saved, result, auth) => currentInboundRequest()?.confirmationEvent?.(saved, result, auth), observed);
+	}
+}
+export { archiveDeferred, deferredCallback, expireDeferredCards, expireDeferredRecord, handleDeferredCallback, isDeferredCallback, postDeferredCard };

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

@@ -5,7 +5,7 @@ const __filename = __eveFileURLToPath(import.meta.url);
 __eveDirname(__filename);
 __eveCreateRequire(import.meta.url);
 import { conversationLanguage } from "./principal.mjs";
-import { l as reportTelegramError, s as failureText } from "../../../_chunks/customer-text-DjszxgTo.mjs";
+import { d as failureText, p as reportTelegramError } from "../../../_chunks/inbound-request-BwBvXk0A.mjs";
 import { describableImage, describeReceivedImage } from "./images.mjs";
 import { MAXIMUM_ATTACHMENT_BYTES, attachmentUrl } from "../attachments.mjs";
 function telegramConversation(chatId) {

package/dist/extension/lib/telegram/images.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 { gateway, generateText } from "ai";
 const MAXIMUM_IMAGE_DESCRIPTION_BYTES = 5242880;
 const MAXIMUM_NATIVE_IMAGE_BYTES = 3145728;

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

@@ -1,3 +1,4 @@
+import type { DeferredConfirmation } from "../deferred-confirmations.js";
 import type { UserContent } from "ai";
 import type { ChannelSource } from "eve/channels";
 import type { SessionAuthContext } from "eve/context";
@@ -61,6 +62,7 @@ export declare class InboundRequest {
     waitUntil: ((task: Promise<unknown>) => void) | undefined;
     /** Continues the exact pending question's session, including under thread scope. */
     address: string | undefined;
+    confirmationEvent: ((record: DeferredConfirmation, result: Readonly<Record<string, unknown>>, auth: SessionAuthContext | null) => Promise<unknown>) | undefined;
     respond: ((address: string, requestId: string, decision: "approve" | "cancel", principal: SessionAuthContext, text?: string) => Promise<unknown>) | undefined;
     constructor(
     /** The agent's description from the compiled manifest, for the routing decision. */

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

@@ -4,5 +4,5 @@ import { createRequire as __eveCreateRequire } from "node:module";
 const __filename = __eveFileURLToPath(import.meta.url);
 __eveDirname(__filename);
 __eveCreateRequire(import.meta.url);
-import { f as InboundRequest, h as withReplacedText, m as runInboundRequest, p as currentInboundRequest } from "../../../_chunks/customer-text-DjszxgTo.mjs";
+import { i as withReplacedText, n as currentInboundRequest, r as runInboundRequest, t as InboundRequest } from "../../../_chunks/inbound-request-BwBvXk0A.mjs";
 export { InboundRequest, currentInboundRequest, runInboundRequest, withReplacedText };

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

@@ -5,16 +5,16 @@ const __filename = __eveFileURLToPath(import.meta.url);
 __eveDirname(__filename);
 __eveCreateRequire(import.meta.url);
 import { conversationLanguage, telegramPrincipal } from "./principal.mjs";
-import { l as reportTelegramError } from "../../../_chunks/customer-text-DjszxgTo.mjs";
-import { MAXIMUM_NATIVE_IMAGE_BYTES } from "./images.mjs";
-import { MAXIMUM_ROUTING_ATTACHMENT_BYTES, describeRoutingAttachment, routingAttachmentDeadline } from "./attachment-description.mjs";
-import { attachmentUrl } from "../attachments.mjs";
+import { p as reportTelegramError } from "../../../_chunks/inbound-request-BwBvXk0A.mjs";
+import { formatAddress, messageAddress, scopedAddress } from "./sessions.mjs";
 import { contentShape, messageContent } from "./content.mjs";
 import { messageAudience } from "./audience.mjs";
 import { attachmentKind, messageMetadata, observedChatKey, observedContext } from "./observed.mjs";
+import { MAXIMUM_NATIVE_IMAGE_BYTES } from "./images.mjs";
+import { MAXIMUM_ROUTING_ATTACHMENT_BYTES, describeRoutingAttachment, routingAttachmentDeadline } from "./attachment-description.mjs";
+import { attachmentUrl } from "../attachments.mjs";
 import { addressingReason, conversationContext, routeMessage } from "./router.mjs";
 import { answerMarker } from "../questions.mjs";
-import { formatAddress, messageAddress, scopedAddress } from "./sessions.mjs";
 import { questionAddress, questionFromHistory } from "./confirmations.mjs";
 import { routingContext } from "./routing-context.mjs";
 import { recordGateDecision, recordInboundContent, recordRouteDecision } from "./conversations.mjs";

package/dist/extension/lib/telegram/media-policy.mjs

@@ -5,7 +5,7 @@ const __filename = __eveFileURLToPath(import.meta.url);
 __eveDirname(__filename);
 __eveCreateRequire(import.meta.url);
 import { DEFAULT_IMAGE_DESCRIPTION_MODEL } from "../../config.mjs";
-import { l as reportTelegramError } from "../../../_chunks/customer-text-DjszxgTo.mjs";
+import { p as reportTelegramError } from "../../../_chunks/inbound-request-BwBvXk0A.mjs";
 function planMedia(capabilities, descriptionModel = null) {
 	if (typeof descriptionModel === "string") return {
 		images: "describe",

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

@@ -69,6 +69,7 @@ export interface PendingConfirmation {
 }
 /** Internal correlation stays in the archive and never enters classifier state. */
 export interface ConfirmationPrompt extends PendingConfirmation {
+    readonly mode?: "deferred";
     readonly requestId: string;
     readonly sessionId?: string;
     readonly address?: string;

package/dist/extension/lib/telegram/routing-context.mjs

@@ -19,6 +19,18 @@ function archivedMetadata(event) {
 }
 function archivedRoutingMessages(events) {
 	const messages = collapseConversationEvents(events).filter((event) => event.kind === "inbound" || event.kind === "outbound" && (event.status === "sent" || event.status === "completed"));
+	const deferredStates = new Map();
+	for (const event of [...events].reverse()) {
+		if (event.kind !== "tool_result" || event.operationId == null) continue;
+		const state = event.reason === "done" ? "completed" : event.reason;
+		if ([
+			"approved",
+			"cancelled",
+			"expired",
+			"completed",
+			"failed"
+		].includes(state ?? "")) deferredStates.set(event.operationId, state);
+	}
 	const membership = new Map();
 	for (const event of [...events].reverse()) {
 		if (event.kind !== "decision" || event.senderId === null) continue;
@@ -28,6 +40,8 @@ function archivedRoutingMessages(events) {
 	}
 	return messages.slice(0, 30).reverse().map((event) => {
 		const metadata = archivedMetadata(event);
+		const prompt = metadata.confirmation;
+		const decision = prompt?.mode === "deferred" ? deferredStates.get(prompt.requestId) : void 0;
 		const parent = messages.find((candidate) => candidate.messageId !== null && candidate.messageId === event.replyToMessageId);
 		const replyTo = metadata.replyTo ?? (event.replyToMessageId === null ? void 0 : {
 			messageId: event.replyToMessageId,
@@ -60,7 +74,10 @@ function archivedRoutingMessages(events) {
 		};
 		return event.kind === "outbound" ? {
 			...common,
-			...metadata.confirmation === void 0 ? {} : { confirmation: metadata.confirmation },
+			...prompt === void 0 ? {} : { confirmation: {
+				...prompt,
+				...decision === void 0 ? {} : { state: decision }
+			} },
 			...agentMessage({
 				text,
 				at: event.at,
@@ -103,7 +120,15 @@ async function routingContext(input) {
 		return {
 			recent: reconciled,
 			pendingQuestions: [...pending.values()].slice(-30),
-			pendingConfirmations: [...histories.values()].flatMap((history) => routingConfirmations(history, reconciled, input.at)).slice(-5)
+			pendingConfirmations: [...[...histories.values()].flatMap((history) => routingConfirmations(history, reconciled, input.at)), ...reconciled.flatMap((message) => {
+				const prompt = "role" in message ? message.confirmation : void 0;
+				return prompt?.mode === "deferred" && prompt.state === "pending" ? [{
+					state: prompt.state,
+					action: prompt.action,
+					requestedBy: prompt.requestedBy,
+					at: prompt.at
+				}] : [];
+			})].slice(-5)
 		};
 	};
 	if (input.operations === void 0) return context(input.remembered);

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

@@ -5,10 +5,10 @@ const __filename = __eveFileURLToPath(import.meta.url);
 __eveDirname(__filename);
 __eveCreateRequire(import.meta.url);
 import "./principal.mjs";
-import { a as customerMessage, l as reportTelegramError, n as currentLocale, t as TelegramDeliveryError } from "../../../_chunks/customer-text-DjszxgTo.mjs";
 import { confirmationLocale } from "./confirmation-text.mjs";
 import { splitTelegramText } from "./format.mjs";
 import { inTelegramSendQueue } from "./send-queue.mjs";
+import { a as TelegramDeliveryError, l as customerMessage, o as currentLocale, p as reportTelegramError } from "../../../_chunks/inbound-request-BwBvXk0A.mjs";
 import { agentMessage, observedChatKey } from "./observed.mjs";
 const SILENT_MARKERS = new Set(["[silent]", "no_reply"]);
 function isSilentReply(text) {

package/dist/extension/lib/telegram/turn-errors.mjs

@@ -5,8 +5,8 @@ const __filename = __eveFileURLToPath(import.meta.url);
 __eveDirname(__filename);
 __eveCreateRequire(import.meta.url);
 import { memberIdOf } from "./principal.mjs";
-import { i as customerCopy, l as reportTelegramError, n as currentLocale, s as failureText } from "../../../_chunks/customer-text-DjszxgTo.mjs";
 import { confirmationLocale } from "./confirmation-text.mjs";
+import { c as customerCopy, d as failureText, o as currentLocale, p as reportTelegramError } from "../../../_chunks/inbound-request-BwBvXk0A.mjs";
 const telegramFailureEvents = {
 	async "turn.cancelled"(event, channel, context) {
 		const errorId = reportTelegramError("turn_cancelled", event, {

package/dist/extension/lib/telegram/voice.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 "../connection-proxy.mjs";
 import { gateway, transcribe } from "ai";
 const LABELS = {

package/dist/extension/schedules/confirmations.d.ts

@@ -0,0 +1,6 @@
+/** No model is invoked until an actual expiry outcome is delivered to its original chat. */
+declare const _default: {
+    cron: string;
+    run({ to }: import("eve/schedules").ScheduleHandlerArgs): Promise<void>;
+};
+export default _default;

package/dist/extension/schedules/confirmations.mjs

@@ -0,0 +1,33 @@
+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 { channelsEnabled } from "../lib/environment.mjs";
+import segmentstream from "../extension.mjs";
+import telegram_default from "../channels/telegram.mjs";
+import { expireScheduledConfirmations } from "../lib/telegram/confirmation-expiry.mjs";
+import { defineSchedule } from "eve/schedules";
+var confirmations_default = defineSchedule({
+	cron: "* * * * *",
+	async run({ to }) {
+		const settings = segmentstream.config.channels.telegram;
+		if (!channelsEnabled(process.env) || !settings || segmentstream.config.confirmations.mode !== "deferred") return;
+		await expireScheduledConfirmations(settings.connection, async (record, result) => {
+			await to(telegram_default, {
+				chatId: record.data.chatId,
+				messageThreadId: record.data.threadId ? Number(record.data.threadId) : void 0,
+				confirmationAddress: record.data.address,
+				confirmationSessionId: record.data.sessionId
+			}).send(JSON.stringify({
+				type: "confirmation_result",
+				...result
+			}), {
+				auth: null,
+				turnPolicy: "queue"
+			});
+		}, {}, settings);
+	}
+});
+export { confirmations_default as default };

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

@@ -0,0 +1,4 @@
+declare const _default: import("eve").DynamicSentinel<{
+    [k: string]: import("eve/tools").ToolDefinition<Record<string, unknown>, Record<string, unknown>>;
+} | null>;
+export default _default;

package/dist/extension/tools/ontology.mjs

@@ -0,0 +1,30 @@
+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 { memberIdOf } from "../lib/telegram/principal.mjs";
+import segmentstream from "../extension.mjs";
+import { ontologyTools } from "../lib/ontology-tools.mjs";
+import { executeDeferredTool } from "../lib/deferred-confirmations.mjs";
+import { defineDynamic, defineTool } from "eve/tools";
+var ontology_default = defineDynamic({ events: { "turn.started": async (_event, context) => {
+	const memberId = memberIdOf(context.session.auth.current);
+	if (!segmentstream.config.ontology.connection || segmentstream.config.confirmations.mode !== "deferred" || memberId === void 0) return null;
+	return Object.fromEntries((await ontologyTools().list(memberId)).map((tool) => {
+		const action = String(tool.name);
+		const schema = tool.inputSchema;
+		const properties = Object.fromEntries(Object.entries(schema.properties ?? {}).filter(([key]) => key !== "_segmentstream"));
+		return [`ontology__${action}`, defineTool({
+			deferred: true,
+			description: String(tool.description ?? tool.title ?? action),
+			inputSchema: {
+				...schema,
+				properties
+			},
+			execute: (input, ctx) => executeDeferredTool(memberId, action, input, ctx)
+		})];
+	}));
+} } });
+export { ontology_default as default };

package/dist/tools/index.d.ts

@@ -6,4 +6,5 @@ export { default as attachments_promote } from "../extension/tools/attachments_p
 export { default as attachments_read } from "../extension/tools/attachments_read.js";
 export { default as attachments_send } from "../extension/tools/attachments_send.js";
 export { default as attachments_table } from "../extension/tools/attachments_table.js";
+export { default as ontology } from "../extension/tools/ontology.js";
 export { default as questions_ask } from "../extension/tools/questions_ask.js";

package/dist/tools/index.mjs

@@ -10,5 +10,6 @@ import attachments_promote_default from "../extension/tools/attachments_promote.
 import attachments_read_default from "../extension/tools/attachments_read.mjs";
 import attachments_send_default from "../extension/tools/attachments_send.mjs";
 import attachments_table_default from "../extension/tools/attachments_table.mjs";
+import ontology_default from "../extension/tools/ontology.mjs";
 import questions_ask_default from "../extension/tools/questions_ask.mjs";
-export { attachments_discard_default as attachments_discard, attachments_list_default as attachments_list, attachments_promote_default as attachments_promote, attachments_read_default as attachments_read, attachments_send_default as attachments_send, attachments_table_default as attachments_table, questions_ask_default as questions_ask };
+export { attachments_discard_default as attachments_discard, attachments_list_default as attachments_list, attachments_promote_default as attachments_promote, attachments_read_default as attachments_read, attachments_send_default as attachments_send, attachments_table_default as attachments_table, ontology_default as ontology, questions_ask_default as questions_ask };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@segmentstream/agent",
-  "version": "0.6.14",
+  "version": "0.7.1",
   "description": "Mount a SegmentStream workspace's agent on eve: the ontology as tools, acting as the member who writes, and Telegram through the workspace's connection.",
   "license": "Apache-2.0",
   "author": "SegmentStream",
@@ -62,7 +62,7 @@
   },
   "dependencies": {
     "@chat-adapter/telegram": "4.41.0",
-    "@segmentstream-cloud/ontology": "0.31.5",
+    "@segmentstream-cloud/ontology": "0.32.1",
     "@vercel/oidc": "^3.8.4",
     "ai": "^7.0.128",
     "csv-parse": "^7.0.3",

package/dist/_chunks/{conversation-runtime-BINKO_6b.mjs → conversation-runtime-ovs8IhXJ.mjs}

@@ -6,8 +6,8 @@ __eveDirname(__filename);
 __eveCreateRequire(import.meta.url);
 import { memberIdOf } from "../extension/lib/telegram/principal.mjs";
 import { conversationEvent, conversations, summarizeArguments } from "../extension/lib/conversations.mjs";
-import { completionKind } from "../extension/lib/telegram/silent.mjs";
 import { parseAddress } from "../extension/lib/telegram/sessions.mjs";
+import { completionKind } from "../extension/lib/telegram/silent.mjs";
 const CONTENT_CAPS = {
 	args: 16384,
 	result: 32768,