@segmentstream/agent 0.5.4 → 0.6.4

package/README.md

@@ -98,7 +98,6 @@ platform's deployment manifest.
 | ------------------------------------------------------------------ | -------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | `segmentstream__ontology`                                          | `connections`  | The app's `/mcp`, resolved per turn for the turn's member. No member, no connection.                                                                                            |
 | `segmentstream__telegram`                                          | `channels`     | `POST /eve/v1/telegram`: Telegram through the connection, with pairing, routing and voice.                                                                                      |
-|                                                                    |                | `POST /eve/v1/telegram/messages`: requests from the ontology's `agent_chat.send_message`.                                                                                       |
 | `segmentstream__attachments_list`, `_read`, `_promote`, `_discard` | `tools`        | The member's temporary attachments in this chat: list, read, keep through an action, drop.                                                                                      |
 | `segmentstream__attachments_send`                                  | `tools`        | Sends readable stored ontology files into the current Telegram chat and topic.                                                                                                  |
 | platform rules                                                     | `instructions` | Changes go through actions; `describe` indexes or inspects refs; `discover` searches metadata; tools are already narrowed; when to answer `[SILENT]`; how to handle attachments |
@@ -197,18 +196,16 @@ share a group chat's session never share a client.
   `migrate_from_chat_id` in the new one) reports the new id with `migratedFrom: <old id>`, starts
   no turn and drops the old chat from the memo. The `<chat>` block carries at most 1000
   characters of `whenToUse`.
-- **Requests.** `POST /eve/v1/telegram/messages` takes a request from the ontology's
-  `agent_chat.send_message`: a group or private chat, the request, the person to contact and the
-  requester, with their roles (empty when an older ontology sends none) and `actAs` (whether the
-  turn can act as them; without it, true for a member). The bearer must be a Vercel OIDC token of a production function of the same project,
-  verified with the team's issuer and audience. The request reaches the chat's session through
-  eve's proactive `receive` at `chatId::`, the address the chat's own messages continue, after the
-  session policy (idle reset, daily compaction) runs on it, with an `<agent_request>` block naming the requester and the person. A member's request with `actAs` runs as that
-  member, with their roles, which choose the model of a session the request starts; a service's,
-  or an unpaired member's (`actAs: false`), runs without a member and has no ontology, its roles
-  still choosing the model. It answers 202 with the session id, 503 outside
-  production, 404 without `channels.telegram`, 401 for a missing or invalid token and 400 for a
-  body that does not match, including a request over 4000 characters.
+- **Cross-chat drafts.** The agent uses `chat_post_message` through its existing ontology
+  connection. The exact full text, destination and authenticated attribution appear on a deterministic
+  Confirm / Edit / Cancel card in the requesting group or DM. Only the requester can use it; the
+  card expires after ten minutes. Edit cancels the original call and asks for a revision. Oversize
+  previews are refused, and uncertain delivery is never automatically retried. Sent receipts retain
+  the preview and show a Telegram link when available; archive failure is distinct from send failure.
+  Agent SDK 0.6.0 prepares this flow; delivery becomes available when the ontology advertises the
+  protocol below. The old instruction receiver `/eve/v1/telegram/messages` is removed. Telegram
+  routes now serve only the inbound webhook and authenticated health; old instruction relay calls
+  fail instead of starting an agent turn.
 - **Silence.** When the model answers a routed message with exactly `[SILENT]` (or `NO_REPLY`), in
   any case, nothing is sent to the chat. Empty and whitespace-only final text also send nothing.
   The turn stays in the session. Archive decisions distinguish silence markers, empty text and
@@ -312,10 +309,32 @@ JSON envelope and limits the decoded body to **2 MiB including multipart overhea
 not stream uploads. Files whose multipart body exceeds this limit return `too_large`; the
 larger Telegram limits do not bypass it. Downloads are bounded even if storage understates size.
 
-Ontology `agent_chat.send_message` accepts optional `document_ids` in its REST/MCP input
-(`documentIds` in authored TypeScript), and forwards `documentIds` in the agent HTTP request.
-The `<agent_request>` block tells the agent to attach them with the question, one question per
-message. In groups follow `purpose` and `whenToUse`, and never send restricted documents.
+Exact chat posting accepts text only through the ontology's `chat_post_message`.
+There are no `document_ids` relay arguments, `AgentMessage` transport or
+`<agent_request>` turns. Stored file tools keep their member authorization in the
+current conversation; group purpose and document restrictions still apply.
+
+## Telegram answer delivery
+
+Agent replies render Markdown as visible text and Telegram entities. Headings, emphasis,
+links, lists, quotations and code are supported; decorative separator lines are removed.
+The customer-text guard checks the rendered prose and link destinations. If rendering fails,
+delivery uses clean plain text. Only an explicit Telegram entity-formatting refusal permits
+a plain-text retry; timeouts and other uncertain outcomes must never trigger an automatic resend.
+Attachment captions use the same rendering and fallback rules.
+
+Replies split at paragraph, line, sentence, word or UTF-16 boundaries within Telegram's 4096-unit
+limit. Entities are rebased or clipped on each part, and surrogate pairs stay intact. The whole
+reply or attachment batch occupies one shared FIFO slot per workspace/connection/chat, including
+all forum topics. A failed slot releases the next one. Sends require a positive Telegram message
+id; missing acknowledgements are errors and archive as unknown. Partial-delivery errors retain
+the message ids already acknowledged.
+
+This queue lives in one SDK runtime. It does not coordinate separate serverless instances or
+the ontology service's exact `chat_post_message` provider. Ordering all of those together needs
+a shared provider sequencer. Exact posting retains its approved literal text and durable receipt;
+this formatter does not rewrite approved posts or their confirmation cards. The removed
+`agent_chat.send_message` instruction relay must not be restored as a delivery fallback.
 
 ## Local development
 
@@ -362,8 +381,49 @@ attachment references. It reloads stored context for the same chat/topic each tu
 across cold starts and compaction. File bytes and tool output bodies are not archived.
 
 Retention defaults to 365 days per workspace. Platform REST reads, the workspace ontology's
-`agent_chat_history` and `agent_chat_search`, and the member REST facade enforce workspace/group
+`chat_history` and `chat_search`, and the member REST facade enforce workspace/group
 permissions and DM participant/admin scope. Deploy the backend migration/API and upgrade the
 ontology SDK along with this extension. See the repository's
 [conversation storage guide](../../docs/agent-conversation-storage.md) for APIs, retention,
 eve's existing storage, and Telegram's delivery limits.
+
+### Exact chat posting protocol (prepared in agent SDK 0.6.0)
+
+An authenticated `tools/list` advertises `_meta: { "segmentstream/chat-post": 1 }` on
+`chat_post_message`. Without this marker,
+ordinary tools use the compatible connection and no runtime arguments are added. Posting with
+missing/incomplete preview metadata is denied. The versioned connection has its own instance key.
+
+The runtime reads `me` for the server-derived `attribution`, and `chat_list({ chat })` for exactly
+one eligible destination: `{ items: [{ id, title, provider, external_id }], next_cursor: null }`.
+Provider is currently `telegram`. The final plain text is exactly `attribution + ": " + text`;
+`reply_to` is optional. A preview digest is SHA-256 of the JSON array of chat ID, provider,
+external ID, title, attribution, text, final text and nullable reply target, in that order.
+The target/attribution are resolved again immediately before executing the frozen call.
+
+Eve supplies the model-hidden `_segmentstream` argument on **all** calls of a negotiated connection.
+It contains `version: 1`, `session_id` and `call_id`. A consumed, unexpired chat approval additionally
+supplies `operation_id`, source provider/chat/topic coordinates and `expected: { chat_id, digest }`.
+The operation ID is `hq:` plus SHA-256 of the JSON array `[session_id, call_id]`; it stays stable
+on replay and changes for a revision. The model cannot provide an idempotency key or this envelope.
+The ontology must authenticate runtime provenance, consume/remove the envelope before strict input
+validation for ordinary tools, derive the posting key from the operation, and recompute attribution.
+External OAuth/service callers still supply their own `idempotency_key` and cannot use this envelope.
+These server changes belong to the later ontology stage; do not advertise the marker prematurely.
+
+Source previews, accepted decisions and receipts use existing archive events with operation-linked
+`toolCallId`/event IDs. A cancelled Edit carries its pending revision question in the authoritative
+Eve resolution, so member/topic routing survives a cold start. No second provider sender lives here.
+
+## Release and migration
+
+The tested release uses agent SDK 0.6.4, Eve 0.76.3 and ontology SDK 0.28.3.
+Deploy the agent first, then backend archive migration 0033/API, then the ontology
+with its declared Telegram provider mapping and explicit `agent_chat:post_message`
+grant. Older ontologies keep ordinary tools working without the extra envelope.
+An older archive returning only `{stored:true}` cannot authorize a send.
+
+Rollback
+disables posting while preserving archive claims and deduplication tombstones;
+it never restores relay or retries uncertain deliveries.
+See [migration and verification](../../docs/agent-chat-delivery-migration.md).

package/dist/extension/connections/ontology.mjs

@@ -5,7 +5,7 @@ const __filename = __eveFileURLToPath(import.meta.url);
 __eveDirname(__filename);
 __eveCreateRequire(import.meta.url);
 import segmentstream from "../extension.mjs";
-import { ontologyConnection } from "../lib/ontology-connection.mjs";
+import { ontologyConnectionForTurn } from "../lib/ontology-connection.mjs";
 import { defineDynamic } from "eve/connections";
-var ontology_default = defineDynamic({ events: { "turn.started": (_event, context) => segmentstream.config.ontology.connection ? ontologyConnection({ principal: context.session.auth.current }) : null } });
+var ontology_default = defineDynamic({ events: { "turn.started": (_event, context) => segmentstream.config.ontology.connection ? ontologyConnectionForTurn({ principal: context.session.auth.current }) : null } });
 export { ontology_default as default };

package/dist/extension/instructions.md

@@ -28,15 +28,16 @@ talking to you, and you act with exactly their permissions.
 - Never invent records or values. Say when the ontology does not hold what was asked.
 - When you have been routed a message but a reply would add nothing, answer with exactly
   `[SILENT]` and nothing else. Use it only in that case; it suppresses delivery to the chat.
-- Use the ontology action `agent_chat.send_message` only to start a conversation in a different
-  group or private chat; their replies come back into that chat's session, where you handle them.
-  Inside a delivered `<agent_request>`, this turn already runs in the target chat: your reply here
-  is the message delivered to that chat. Do not look for or call `agent_chat.send_message` to deliver
-  it, even if the ontology catalog is empty or that action is unavailable. If the addressed person
-  has a linked Telegram username, mention them with @username; otherwise address them by name
-  without a tag. Never invent a username. The groups you are in are listed in `agent_chat`, with the
-  `purpose` and `whenToUse` members set; when a member who may change it tells you what a group is
-  for, record it with `agent_chat.update`.
+- To post in another chat, find the destination with `chat_list` and colleagues with `user_find`.
+  Read `chat_history` or `chat_search` only when permitted, then compose the exact draft and call
+  `chat_post_message`. The runtime supplies the operation key. Its Confirm / Edit / Cancel card
+  shows the full attributed text in the requesting chat; only the requester can act on it and it
+  expires after ten minutes. Text such as "yes" or "да" cannot approve a post. After Edit, ask what
+  to change and make a new call/card for the revision; the cancelled call cannot be reused.
+  An uncertain delivery must never be automatically resent, including through a fresh call/key.
+  For a reply in the current chat, answer normally. If chat posting is unavailable, say so.
+  Never call the removed instruction relay or any agent invocation/self-invocation tool. A post must not start an agent.
+  The existing `agent_chat` registry records group purpose and usage; update those only when permitted.
 - Send stored ontology documents with `segmentstream__attachments_send`: give `documentIds`
   (1 to 10 document record ids), or `{ entity, id, property? }` references for other records with
   file properties. The tool derives the member, Telegram chat and topic from this turn, checks

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

@@ -17,9 +17,7 @@ var AttachmentOwnerError = class extends Error {
 	name = "AttachmentOwnerError";
 };
 function attachmentOwner(input) {
-	const attributes = input.principal?.attributes;
-	const requesterId = attributes?.requesterKind === "member" && attributes.chatType === "group" ? attributes.requesterId : void 0;
-	const memberId = memberIdOf(input.principal) ?? (typeof requesterId === "string" ? requesterId : void 0);
+	const memberId = memberIdOf(input.principal);
 	const chatId = input.principal?.attributes.chatId;
 	if (memberId === void 0 || memberId === "" || typeof chatId !== "string" || chatId === "") throw new AttachmentOwnerError("Attachments require a workspace member in a chat with the agent.");
 	return {

package/dist/extension/lib/chat-post-confirmation.d.ts

@@ -0,0 +1,23 @@
+import type { ConfirmationDescription } from "./confirmation-description.js";
+/** Versioned agreement with the authenticated ontology, not a model supplied capability. */
+export declare const CHAT_POST_PROTOCOL = "segmentstream/chat-post";
+export declare const CHAT_POST_ENVELOPE = "_segmentstream";
+export interface ChatPostPreview {
+    readonly chatId: string;
+    readonly provider: "telegram";
+    readonly externalId: string;
+    readonly title: string;
+    readonly attribution: string;
+    readonly text: string;
+    readonly finalText: string;
+    readonly replyTo: string | null;
+}
+export declare function isChatPost(action: string): boolean;
+export declare function supportsChatPost(tool: Record<string, unknown>): boolean;
+export declare function chatPostDigest(preview: ChatPostPreview): string;
+export declare function chatPostOperationId(sessionId: string, callId: string): string;
+export declare function describeChatPost(input: {
+    readonly values: Readonly<Record<string, unknown>>;
+    readonly caller: Record<string, unknown>;
+    readonly destinations: Record<string, unknown>;
+}): ConfirmationDescription;

package/dist/extension/lib/chat-post-confirmation.mjs

@@ -0,0 +1,61 @@
+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 { object } from "./confirmation-description.mjs";
+import { createHash } from "node:crypto";
+const CHAT_POST_PROTOCOL = "segmentstream/chat-post";
+const CHAT_POST_ENVELOPE = "_segmentstream";
+function isChatPost(action) {
+	return action.split("__").at(-1) === "chat_post_message";
+}
+function supportsChatPost(tool) {
+	return isChatPost(String(tool.name)) && object(tool._meta)["segmentstream/chat-post"] === 1;
+}
+function chatPostDigest(preview) {
+	return createHash("sha256").update(JSON.stringify([
+		preview.chatId,
+		preview.provider,
+		preview.externalId,
+		preview.title,
+		preview.attribution,
+		preview.text,
+		preview.finalText,
+		preview.replyTo
+	])).digest("hex");
+}
+function chatPostOperationId(sessionId, callId) {
+	return `hq:${createHash("sha256").update(JSON.stringify([sessionId, callId])).digest("hex")}`;
+}
+function describeChatPost(input) {
+	const { values, caller, destinations } = input;
+	const items = Array.isArray(destinations.items) ? destinations.items.map(object) : [];
+	const target = items[0];
+	if (Object.keys(values).some((key) => ![
+		"chat",
+		"text",
+		"reply_to"
+	].includes(key)) || typeof values.chat !== "string" || !values.chat || typeof values.text !== "string" || !values.text.trim() || values.reply_to !== void 0 && (typeof values.reply_to !== "string" || !values.reply_to) || items.length !== 1 || destinations.next_cursor != null || destinations.nextCursor != null || target === void 0 || ![
+		target.id,
+		target.title,
+		target.external_id,
+		caller.attribution
+	].every((value) => typeof value === "string" && value.length > 0) || target.provider !== "telegram" || target.id !== values.chat && target.title !== values.chat) throw new Error("An unambiguous destination and a complete exact chat preview are required.");
+	return {
+		action: "Post message",
+		fields: [],
+		chatPost: {
+			chatId: target.id,
+			provider: "telegram",
+			externalId: target.external_id,
+			title: target.title,
+			attribution: caller.attribution,
+			text: values.text,
+			finalText: `${caller.attribution}: ${values.text}`,
+			replyTo: typeof values.reply_to === "string" ? values.reply_to : null
+		}
+	};
+}
+export { CHAT_POST_ENVELOPE, CHAT_POST_PROTOCOL, chatPostDigest, chatPostOperationId, describeChatPost, isChatPost, supportsChatPost };

package/dist/extension/lib/confirmation-description.d.ts

@@ -1,3 +1,4 @@
+import type { ChatPostPreview } from "./chat-post-confirmation.js";
 /** Only human-facing facts cross into the confirmation renderer; identifiers stay in the gate. */
 export interface ConfirmationDescription {
     readonly action: string;
@@ -7,6 +8,7 @@ export interface ConfirmationDescription {
         readonly label: string;
         readonly value: string;
     }[];
+    readonly chatPost?: ChatPostPreview;
 }
 export declare function object(value: unknown): Record<string, unknown>;
 export declare function humanize(value: string): string;

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

@@ -19,6 +19,11 @@ export interface Confirmation {
     readonly expiresAt: number;
     readonly status: "pending" | "approved" | "consumed" | "cancelled";
     readonly description?: ConfirmationDescription;
+    readonly source?: {
+        readonly chatId: string;
+        readonly threadId: string;
+    };
+    readonly cancellationReason?: "edit" | "expired";
 }
 export declare const confirmations: StateHandle<Record<string, Confirmation>>;
 /** Eve pauses the original call and rechecks this policy immediately before executing it. */

package/dist/extension/lib/confirmations.mjs

@@ -5,6 +5,8 @@ const __filename = __eveFileURLToPath(import.meta.url);
 __eveDirname(__filename);
 __eveCreateRequire(import.meta.url);
 import { memberIdOf } from "./telegram/principal.mjs";
+import { chatPostDigest, isChatPost } from "./chat-post-confirmation.mjs";
+import { chatPostCard } from "./telegram/chat-post-card.mjs";
 import { createHash } from "node:crypto";
 import { defineState } from "eve/context";
 const CONFIRMATION_TTL_MS = 6e5;
@@ -47,6 +49,20 @@ function actionApproval(options) {
 				console.warn("The ontology action permission check failed.", error);
 				return denied("The action is unavailable or the member no longer has permission.");
 			}
+			const posting = isChatPost(ctx.toolName);
+			let description;
+			if (posting) try {
+				description = await options.describe?.(memberId, ctx.toolName, ctx.toolInput ?? {});
+				const preview = description?.chatPost;
+				const source = ctx.session.auth.current?.attributes;
+				if (preview === void 0 || typeof source?.chatId !== "string" || source.chatId === preview.externalId) return denied("A complete preview for a different chat is required. Reply normally in this chat.");
+				chatPostCard(preview, "en");
+				chatPostCard(preview, "ru");
+				if (saved !== void 0 && (saved.description?.chatPost === void 0 || chatPostDigest(saved.description.chatPost) !== chatPostDigest(preview) || saved.source?.chatId !== source.chatId || saved.source.threadId !== String(source.messageThreadId ?? ""))) return denied("The destination or attribution changed. Make a new call and confirmation.");
+			} catch (error) {
+				console.warn("The exact chat confirmation could not be prepared.", error);
+				return denied("The full exact chat preview is unavailable or too long. Make a new call.");
+			}
 			if (saved?.status === "approved") {
 				state.update((all) => ({
 					...all,
@@ -58,10 +74,9 @@ function actionApproval(options) {
 				return "approved";
 			}
 			if (saved !== void 0) return denied("The original call is waiting for its Confirm / Cancel buttons.");
-			if (!needsConfirmation(labels)) return "approved";
-			let description;
+			if (!posting && !needsConfirmation(labels)) return "approved";
 			try {
-				description = await options.describe?.(memberId, ctx.toolName, ctx.toolInput ?? {});
+				if (!posting) description = await options.describe?.(memberId, ctx.toolName, ctx.toolInput ?? {});
 			} catch (error) {
 				console.warn("The confirmation description could not be read.", error);
 			}
@@ -73,7 +88,11 @@ function actionApproval(options) {
 					inputHash: hash,
 					expiresAt: now() + CONFIRMATION_TTL_MS,
 					status: "pending",
-					...description === void 0 ? {} : { description }
+					...description === void 0 ? {} : { description },
+					...posting ? { source: {
+						chatId: String(ctx.session.auth.current?.attributes.chatId),
+						threadId: String(ctx.session.auth.current?.attributes.messageThreadId ?? "")
+					} } : {}
 				}
 			}));
 			return "user-approval";
@@ -93,7 +112,8 @@ function actionApproval(options) {
 				...all,
 				[ctx.request.callId]: {
 					...saved,
-					status: ctx.response.decision === "approve" ? "approved" : "cancelled"
+					status: ctx.response.decision === "approve" ? "approved" : "cancelled",
+					...ctx.response.decision === "cancel" && ["edit", "expired"].includes(String(ctx.response.principal.attributes.confirmationReason)) ? { cancellationReason: ctx.response.principal.attributes.confirmationReason } : {}
 				}
 			}));
 			return { status: "allowed" };

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

@@ -22,7 +22,18 @@ export interface ConversationEvent {
     readonly toolCallId: string | null;
     readonly toolName: string | null;
     readonly argsSummary: string | null;
-    readonly status: "requested" | "completed" | "failed" | "rejected" | "cancelled" | "unknown" | null;
+    readonly status: "requested" | "completed" | "failed" | "rejected" | "cancelled" | "unknown" | "sent" | "uncertain" | null;
+    readonly operationId?: string | null;
+    readonly requestedBy?: {
+        readonly id: string;
+        readonly kind: "member" | "service";
+        readonly name: string;
+        readonly via: "oauth" | "hq" | "service";
+        readonly clientId: string | null;
+        readonly clientName: string | null;
+        readonly attribution: string;
+    } | null;
+    readonly url?: string | null;
     readonly attachments: ReadonlyArray<{
         readonly id: string;
         readonly kind: string;

package/dist/extension/lib/conversations.mjs

@@ -9,11 +9,12 @@ import { runtimeToken } from "./runtime-token.mjs";
 function collapseConversationEvents(events) {
 	const latest = new Map();
 	for (const event of events) {
-		const key = event.kind === "inbound" && event.provider === "telegram" && event.messageId !== null ? `telegram:${event.chatId}:${event.messageId}:message` : event.kind === "outbound" && /^telegram:(send|edit):/u.test(event.eventId) ? event.eventId.replace(/:result$/u, "") : event.eventId;
+		const key = event.kind === "outbound" && event.operationId != null ? `chat-delivery:${event.operationId}` : event.kind === "inbound" && event.provider === "telegram" && event.messageId !== null ? `telegram:${event.chatId}:${event.messageId}:message` : event.kind === "outbound" && /^telegram:(send|edit):/u.test(event.eventId) ? event.eventId.replace(/:result$/u, "") : event.eventId;
 		const previous = latest.get(key);
 		if (previous === void 0 || (/^\d+$/u.test(event.sequence) && /^\d+$/u.test(previous.sequence) ? BigInt(event.sequence) > BigInt(previous.sequence) : event.storedAt > previous.storedAt)) latest.set(key, {
 			...event,
-			eventId: key
+			eventId: key,
+			...event.kind === "outbound" && event.operationId != null && event.status === "requested" ? { status: "uncertain" } : {}
 		});
 	}
 	return [...latest.values()];
@@ -95,7 +96,7 @@ async function storedConversationContext(archive, coordinates) {
 		chatId: coordinates.chatId,
 		...coordinates.threadId === null ? {} : { threadId: coordinates.threadId },
 		limit: 100
-	})).events).filter((event) => event.kind === "inbound" || event.kind === "outbound" && event.status === "completed");
+	})).events).filter((event) => event.kind === "inbound" || event.kind === "outbound" && ["completed", "sent"].includes(event.status ?? ""));
 	const selected = [];
 	let characters = 0;
 	for (const event of messages) {

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

@@ -34,4 +34,8 @@ export declare function ontologyConnection(input: {
     readonly environment?: Environment;
     readonly token?: RuntimeToken;
     readonly fetch?: typeof fetch;
+    /** Set only by the authenticated catalog handshake, never by model input. */
+    readonly chatPosting?: 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

@@ -6,7 +6,8 @@ __eveDirname(__filename);
 __eveCreateRequire(import.meta.url);
 import { appOrigin } from "./environment.mjs";
 import { memberIdOf } from "./telegram/principal.mjs";
-import { actionApproval } from "./confirmations.mjs";
+import { CHAT_POST_ENVELOPE, chatPostDigest, chatPostOperationId, isChatPost } from "./chat-post-confirmation.mjs";
+import { actionApproval, confirmations } from "./confirmations.mjs";
 import { runtimeToken, tokenExpiry } from "./runtime-token.mjs";
 import { ontologyTools } from "./ontology-tools.mjs";
 import { defineMcpClientConnection } from "eve/connections";
@@ -29,8 +30,36 @@ function ontologyConnection(input) {
 	return defineMcpClientConnection({
 		url: `${origin}/mcp`,
 		description: DESCRIPTION,
-		instanceKey: `${origin}/mcp#member:${memberId}`,
+		instanceKey: `${origin}/mcp#member:${memberId}${input.chatPosting ? ":chat-post-v1" : ""}`,
 		approval: actionApproval(ontologyTools(input)),
+		...input.chatPosting ? { 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
+			};
+			if (!isChatPost(ctx.toolName)) return base;
+			const saved = confirmations.get()[ctx.callId];
+			const preview = saved?.description?.chatPost;
+			if (saved?.status !== "consumed" || saved.memberId !== memberId || saved.action.split("__").at(-1) !== ctx.toolName || saved.expiresAt <= Date.now() || preview === void 0 || saved.source === void 0) throw new Error("Exact chat posting requires the original unexpired confirmed call.");
+			return {
+				...base,
+				operation_id: chatPostOperationId(ctx.session.id, ctx.callId),
+				source: {
+					provider: "telegram",
+					chat_id: saved.source.chatId,
+					thread_id: saved.source.threadId
+				},
+				expected: {
+					chat_id: preview.chatId,
+					digest: chatPostDigest(preview)
+				}
+			};
+		} } } } : {},
 		auth: {
 			credentialOwner: "app",
 			getToken: async () => {
@@ -48,4 +77,18 @@ function ontologyConnection(input) {
 		})
 	});
 }
-export { ACT_AS_HEADER, MemberRequiredError, actAsHeaders, ontologyConnection };
+async function ontologyConnectionForTurn(input) {
+	const memberId = memberIdOf(input.principal);
+	if (memberId === void 0) return null;
+	let chatPosting = false;
+	try {
+		chatPosting = await ontologyTools(input).supportsChatPosting(memberId);
+	} catch (error) {
+		console.warn("Chat posting capability unavailable; keeping the compatible ontology connection.", error);
+	}
+	return ontologyConnection({
+		...input,
+		chatPosting
+	});
+}
+export { ACT_AS_HEADER, MemberRequiredError, actAsHeaders, ontologyConnection, ontologyConnectionForTurn };

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

@@ -7,6 +7,7 @@ export declare function ontologyTools(options?: {
     readonly token?: RuntimeToken;
     readonly fetch?: typeof fetch;
 }): {
+    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

@@ -6,6 +6,7 @@ __eveDirname(__filename);
 __eveCreateRequire(import.meta.url);
 import { appOrigin } from "./environment.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 = {}) {
@@ -31,10 +32,12 @@ function ontologyTools(options = {}) {
 				signal: signal ?? AbortSignal.timeout(15e3),
 				redirect: "error"
 			});
-			if (!response.ok) throw new Error(`Cannot check action permission (HTTP ${response.status}).`);
+			if (!response.ok) throw new Error(`Cannot check action permission (HTTP ${response.status}).`, { cause: await response.text() });
 			const body = object(await response.json());
 			if (body.error !== void 0) throw new Error("Ontology metadata unavailable.", { cause: body.error });
-			return object(body.result);
+			const result = object(body.result);
+			if (result.isError === true) throw new Error("The ontology preview read failed.", { cause: result });
+			return result;
 		} catch (error) {
 			throw new Error("The ontology metadata request failed.", { cause: redactDiagnostic(error, secrets) });
 		}
@@ -51,12 +54,34 @@ function ontologyTools(options = {}) {
 		};
 	}
 	return {
+		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) {
 			return object((await toolFor(memberId, action)).tool.annotations);
 		},
 		async describe(memberId, action, input) {
 			const signal = AbortSignal.timeout(15e3);
 			const { tool, tools } = await toolFor(memberId, action, signal);
+			if (isChatPost(action)) {
+				if (!supportsChatPost(tool)) throw new Error("The ontology does not support exact chat confirmations.");
+				const read = async (name, args) => {
+					if (!tools.some((candidate) => candidate.name === name && object(candidate.annotations).readOnlyHint === true)) throw new Error("The chat preview reads are unavailable.");
+					const result = await rpc(memberId, "tools/call", {
+						name,
+						arguments: args
+					}, signal);
+					if (result.isError === true) throw new Error("The chat preview could not be resolved.");
+					return object(result.structuredContent);
+				};
+				const [caller, destinations] = await Promise.all([read("me", {}), read("chat_list", { chat: input.chat })]);
+				return describeChatPost({
+					values: input,
+					caller,
+					destinations
+				});
+			}
 			let entities = [];
 			try {
 				const catalog = await rpc(memberId, "resources/read", { uri: "ontology://catalog" }, signal);

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

@@ -36,7 +36,7 @@ export interface TelegramAdapterOptions {
     readonly describeImage?: ImageDescriber;
     readonly modelCapabilities?: CapabilityLookup;
     readonly observed?: ObservedMessages;
-    /** Verifies callers of the messages route; tests pass one on a local key set. */
+    /** Verifies callers of the health route; tests pass one on a local key set. */
     readonly verify?: RuntimeTokenVerifier;
     /** Reads session events for routing, policy and interactions; tests pass a fake. */
     readonly history?: HistoryReader;