@segmentstream/agent 0.5.3 → 0.6.3

package/README.md

@@ -79,13 +79,14 @@ Both entry points export the same handle: `@segmentstream/agent` and
 }
 ```
 
-| Field                          | Default               | Meaning                                                                                         |
-| ------------------------------ | --------------------- | ----------------------------------------------------------------------------------------------- |
-| `channels.telegram.connection` | none                  | The Connect key whose credential is the bot token. Without `channels.telegram`, no Telegram.    |
-| `channels.telegram.policy`     | `"smart"`             | Group messages that do not address the bot: `smart` asks the decision model, `mention` observes |
-| `models.stt`                   | `"spacexai/grok-stt"` | The AI Gateway transcription model for voice messages; `false` leaves them untranscribed        |
-| `models.decision`              | `"typesafe-ai/jev"`   | The AI Gateway decision model of the inbound router                                             |
-| `ontology.connection`          | `true`                | Whether the agent reaches the ontology over MCP                                                 |
+| Field                          | Default               | Meaning                                                                                                                  |
+| ------------------------------ | --------------------- | ------------------------------------------------------------------------------------------------------------------------ |
+| `channels.telegram.connection` | none                  | The Connect key whose credential is the bot token. Without `channels.telegram`, no Telegram.                             |
+| `channels.telegram.policy`     | `"smart"`             | Group messages that do not address the bot: `smart` asks the decision model, `mention` observes                          |
+| `models.stt`                   | `"spacexai/grok-stt"` | The AI Gateway transcription model for voice messages; `false` leaves them untranscribed                                 |
+| `models.imageDescription`      | automatic             | A separate vision model for ingestion descriptions; omitted prefers native images, `false` disables description fallback |
+| `models.decision`              | `"typesafe-ai/jev"`   | The AI Gateway decision model of the inbound router                                                                      |
+| `ontology.connection`          | `true`                | Whether the agent reaches the ontology over MCP                                                                          |
 
 An unknown field or an invalid value fails the mount with `SegmentStreamAgentConfigError`, naming
 each path. `manifestOf(config)` returns the normalized configuration, defaults applied, for the
@@ -97,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 |
@@ -145,14 +145,28 @@ share a group chat's session never share a client.
   model, with the agent's description and the chat's recent observed messages. A message that is not
   answered joins a ring of the chat's last 30 observed messages. The next answered message carries
   the ring into its turn as context. A failed decision observes.
+  Replies to a known human or another bot, and explicit mentions of another recipient, are
+  observed before smart inference unless this bot is addressed. This also takes precedence over
+  a pending-question follow-up. Both mention entities and user-ID `text_mention` entities count;
+  quoted/code mentions do not. Smart routing receives the original body, reply author/text,
+  tagged users and whether this bot was tagged. Decision events retain a short routing audit note
+  alongside the reason code; this is an observable summary, not model chain-of-thought.
 - **Voice.** Voice messages, audio files and video notes are downloaded through the connection and
-  transcribed with `models.stt` through AI Gateway. The transcript becomes the message, with a note
-  such as `[voice message, 12 s]` in context. A file over Telegram's 20 MB download limit, or a
-  failed transcription, reaches the agent as a note saying so.
+  transcribed with `models.stt` through AI Gateway before routing, including observations under
+  `mention`. The transcript becomes the message, with a note such as `[voice message, 12 s]` in
+  context. `stt: false` skips download and transcription. Transcription accepts at most 20 MiB
+  and ten minutes of declared duration, with a 60-second inference timeout. A skipped or failed
+  transcription reaches the agent as a note. Originals are not stored as ontology attachments.
+  Eve 0.76.3 only hydrates inbound images and PDFs; it does **not** deliver native audio bytes to
+  the chat model. Even an audio-capable chat model therefore uses the configured STT fallback,
+  with an explicit host limitation note. Native audio requires a compatible Eve host change.
 - **Attachments.** Photos and documents up to 20 MB stream through the connection proxy (its
   framed responses are not bound by the 2 MiB buffered limit) and are stored, before the turn,
   as the member's temporary attachments in the ontology's file storage
-  (`POST /api/ontology/agent/attachments`), for this chat, for 24 hours. The turn's file parts
+  (`POST /api/ontology/agent/attachments`), for this chat, for 24 hours.
+  Observed group uploads are stored too, after participant registration, without starting a turn
+  or sending a typing indication. The next reply receives their references; attachment tools can
+  also list the stored files after a cold start. The turn's file parts
   point at the stored copies, which eve reads through the channel's `fetchFile` as the turn's
   session, which then owns them, and an `<attachments>` block names each attachment's id. A file
   that is too large or could not be stored becomes a note. The `segmentstream__attachments_*`
@@ -182,25 +196,80 @@ 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. The turn stays in the session.
+  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
+  whitespace, retaining finish reason and character count without logging raw output. Model reply
+  decisions do not prove transport delivery; completed outbound events carry that evidence.
 
 The observed ring and chat-report caches live in process memory. On a cold start, the adapter
 restores recent conversation context from the platform archive and reports its chats afresh.
 The archive survives independently of eve session state and these caches.
 
+Text and captions retain their Telegram entity annotations for addressing. Rich-message blocks
+are projected to plain text before capture and dispatch, bounded to 16,384 UTF-16 code units,
+2048 traversal steps and 24 nested levels. The archive records content shape and truncation without retaining
+raw webhook payloads. Edits remain separate audit events, but replace the earlier message in
+observed/restored model context. An edit alone never starts an agent turn. Entity offsets cannot
+reconstruct a missing body; unsupported empty content is recorded with shape diagnostics.
+
+### Image context and capabilities
+
+Before handling media, the adapter reads the selected model's declared input modalities from
+AI Gateway's public model metadata. Existing sessions use the model recorded in their latest
+available `step.started` event, rather than reselecting by the current speaker's roles. A new
+session uses `models.chat` with the normal role and preview rules. An inline model choice in
+`agent.ts` cannot be inspected before its first session step; capabilities then stay unknown.
+
+| Main chat input    | `models.imageDescription` | Ingestion and later context                                               |
+| ------------------ | ------------------------- | ------------------------------------------------------------------------- |
+| Images supported   | omitted or `false`        | Store the original and retain native file references; no description call |
+| Any capability     | a model id                | Store the original and describe with that separate model before routing   |
+| Images unsupported | omitted                   | Describe with `google/gemini-2.5-flash-lite` before routing               |
+| Images unsupported | `false`                   | Store the original and record that analysis is disabled                   |
+| Unknown            | omitted or `false`        | Store the original and record that analysis is unavailable                |
+
+Descriptions cover JPEG, PNG, WebP and GIF, at most one per Telegram message, 5 MiB of input,
+256 output tokens, 512 retained characters, and a 15-second inference timeout. Albums are
+multiple Telegram messages and can incur multiple calls. These ingestion calls are separate
+from the chat model's session spending limit. The descriptor treats image text as untrusted
+evidence. Failure, unsupported format and limit notes retain the original attachment reference.
+Metadata lookups have a five-second timeout, a five-minute success cache and a 30-second failure
+cache, with at most 128 model entries. A lookup failure never asserts that the model saw pixels.
+
+Eve's native image input limit is 3 MiB per image. On the next reply, the adapter also appends
+eligible observed images as file parts, up to five images and 3 MiB total after accounting for
+current images. It creates attachment URLs for the **current** requester, and storage checks that
+member's access again. Expired or omitted images get notes. A text-only reply receives generated
+descriptions and references, never hidden image bytes. Other formats remain attachment-tool inputs.
+
+The process-local ring retains 30 observations per chat/topic, with separate budgets of 1000
+UTF-16 code units of text and 2000 of media notes per observation, plus at most five image
+references. The recent routing window also retains 30 entries. A process retains at most 500
+chats, evicting the chat least recently written. Reading does not refresh its position. A reply
+drains the observation backlog; an idle reset clears both windows; daily compaction leaves the
+ring intact. Image bytes are not kept in this cache.
+
+Archive restoration can recover raw text/captions after restarts and compaction: the webhook
+warms an empty ring from up to 30 inbound events, and each turn refreshes a separate bounded
+archive transcript. The latter reads at most 100 events, 4000 text characters and ten raw
+attachment references per event, within 30,000 serialized characters overall. Generated
+transcripts/descriptions and native-image ring references are currently **not** archived.
+They can be lost on restart or eviction before the next reply; the originals of stored images
+remain discoverable with attachment tools until expiry. Already dispatched native images follow
+Eve's sandbox/session history and may be omitted by compaction. Durable enriched media context
+and native audio are follow-up work, not guarantees of this adapter.
+
 The webhook subscribes to `message`, `edited_message`, `callback_query`, `my_chat_member`
 and `chat_member`. A bot join reports the group immediately, including when the inviter is
 unpaired; membership updates do not start turns. Report tasks participate in the wrapper's
@@ -240,10 +309,10 @@ 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.
 
 ## Local development
 
@@ -290,8 +359,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.3, Eve 0.76.3 and ontology SDK 0.28.2.
+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/config.d.ts

@@ -14,6 +14,7 @@ export declare const TELEGRAM_POLICIES: readonly ["mention", "smart"];
 export type TelegramPolicy = (typeof TELEGRAM_POLICIES)[number];
 /** The speech-to-text model voice messages are transcribed with, in the AI Gateway catalog. */
 export declare const DEFAULT_STT_MODEL = "spacexai/grok-stt";
+export declare const DEFAULT_IMAGE_DESCRIPTION_MODEL = "google/gemini-2.5-flash-lite";
 /** The decision model the inbound router asks; eve's `decide` default. */
 export declare const DEFAULT_DECISION_MODEL = "typesafe-ai/jev";
 /**
@@ -42,6 +43,8 @@ export interface SegmentStreamAgentConfigInput {
         };
         /** A Gateway transcription model, or `false` to leave voice messages untranscribed. */
         readonly stt?: string | boolean;
+        /** Separate vision model, or false to disable fallback descriptions; omitted prefers native input. */
+        readonly imageDescription?: string | boolean;
         /** The Gateway decision model of the inbound router. */
         readonly decision?: string;
     };
@@ -102,6 +105,7 @@ export interface SegmentStreamAgentConfig {
         /** `null` when `agent.ts` passes the choice to `segmentstream.model()` itself. */
         readonly chat: ChatModelChoice | null;
         readonly stt: string | false;
+        readonly imageDescription: string | false | null;
         readonly decision: string;
     };
     readonly ontology: {

package/dist/extension/config.mjs

@@ -7,6 +7,7 @@ __eveCreateRequire(import.meta.url);
 const CONNECTION_KEY = /^[a-z][a-z0-9_]{0,63}$/;
 const TELEGRAM_POLICIES = ["mention", "smart"];
 const DEFAULT_STT_MODEL = "spacexai/grok-stt";
+const DEFAULT_IMAGE_DESCRIPTION_MODEL = "google/gemini-2.5-flash-lite";
 const DEFAULT_DECISION_MODEL = "typesafe-ai/jev";
 const SESSION_SCOPES = ["chat", "thread"];
 var SegmentStreamAgentConfigError = class extends Error {
@@ -202,7 +203,8 @@ function validateConfig(input) {
 		allowed: [
 			"chat",
 			"stt",
-			"decision"
+			"decision",
+			"imageDescription"
 		],
 		issues
 	});
@@ -226,6 +228,12 @@ function validateConfig(input) {
 		path: ["models", "decision"],
 		issues
 	});
+	const imageDescription = models?.imageDescription === void 0 ? null : models.imageDescription === false ? false : modelId({
+		value: models.imageDescription,
+		fallback: DEFAULT_IMAGE_DESCRIPTION_MODEL,
+		path: ["models", "imageDescription"],
+		issues
+	});
 	const connection = ontology?.connection ?? true;
 	const sessions = sessionSettings(root?.sessions, issues);
 	if (typeof connection !== "boolean") issues.push({
@@ -238,7 +246,8 @@ function validateConfig(input) {
 		models: {
 			chat,
 			stt,
-			decision
+			decision,
+			imageDescription
 		},
 		ontology: { connection: connection === true },
 		sessions
@@ -255,4 +264,4 @@ function manifestOf(config) {
 	if (validation.issues !== void 0) throw new SegmentStreamAgentConfigError(validation.issues);
 	return validation.value;
 }
-export { DEFAULT_DECISION_MODEL, DEFAULT_STT_MODEL, SESSION_SCOPES, SegmentStreamAgentConfigError, TELEGRAM_POLICIES, configSchema, manifestOf, validateConfig };
+export { DEFAULT_DECISION_MODEL, DEFAULT_IMAGE_DESCRIPTION_MODEL, DEFAULT_STT_MODEL, SESSION_SCOPES, SegmentStreamAgentConfigError, TELEGRAM_POLICIES, configSchema, manifestOf, validateConfig };

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/conversation-runtime.mjs

@@ -7,21 +7,25 @@ __eveCreateRequire(import.meta.url);
 import { memberIdOf } from "./telegram/principal.mjs";
 import { conversationEvent, conversations, summarizeArguments } from "./conversations.mjs";
 import { parseAddress } from "./telegram/sessions.mjs";
-import { isSilentReply } from "./telegram/silent.mjs";
+import { completionKind } from "./telegram/silent.mjs";
 function conversationCoordinates(context) {
 	const principal = context.session.auth.current;
 	const telegram = principal?.authenticator === "segmentstream-telegram" || context.channel.kind?.includes("telegram");
 	const address = context.channel.continuationToken;
 	const attributes = principal?.attributes;
-	const chatId = telegram && address ? parseAddress(address).chatId : typeof attributes?.chatId === "string" ? attributes.chatId : address;
+	const fields = address?.split(":");
+	const localAddress = telegram && fields?.length === 4 ? fields.slice(1).join(":") : address;
+	const parsed = telegram && localAddress !== void 0 && /^-?\d+:\d*:\d*$/u.test(localAddress) ? parseAddress(localAddress) : void 0;
+	const attributeChatId = typeof attributes?.chatId === "string" && (!telegram || /^-?\d+$/u.test(attributes.chatId)) ? attributes.chatId : void 0;
+	const chatId = telegram ? parsed?.chatId ?? attributeChatId : attributeChatId !== void 0 ? attributeChatId : address;
 	if (!chatId) return;
 	const memberId = memberIdOf(principal);
 	const chatType = attributes?.chatType;
 	return {
 		provider: telegram ? "telegram" : context.channel.kind ?? "eve",
 		chatId,
-		chatType: chatType === "group" || chatType === "supergroup" ? "group" : chatType === "channel" ? "channel" : "private",
-		threadId: telegram && address ? parseAddress(address).messageThreadId || null : null,
+		chatType: chatType === "group" || chatType === "supergroup" || chatType === void 0 && telegram && chatId.startsWith("-") ? "group" : chatType === "channel" ? "channel" : "private",
+		threadId: !telegram ? null : parsed !== void 0 ? parsed.messageThreadId || null : typeof attributes?.messageThreadId === "string" ? attributes.messageThreadId : null,
 		participantIds: memberId === void 0 ? [] : [memberId],
 		senderId: principal?.subject ?? null
 	};
@@ -70,13 +74,21 @@ function conversationRecorder(archive = conversations()) {
 			status: event.type === "task.started" ? "requested" : event.data.status === "cancelled" ? "cancelled" : event.data.status === "failed" ? "failed" : "completed"
 		}));
 		else if (event.type === "message.completed" && event.data.finishReason !== "tool-calls") {
-			const silent = !event.data.message || isSilentReply(event.data.message);
+			const kind = completionKind(event.data.message, event.data.finishReason);
+			const silent = kind !== "reply";
+			const note = kind === "silent_marker" ? "Model returned an explicit silence marker; no message delivery." : kind === "empty" ? "Model completed without final text; no message delivery." : kind === "whitespace" ? "Model returned only whitespace; no message delivery." : "Model produced a reply; transport delivery is recorded separately.";
 			await archive.append(conversationEvent({
 				...base,
 				eventId,
 				kind: "decision",
 				decision: silent ? "silent" : "reply",
-				reason: silent ? "model_silent_or_empty_output" : "model_reply"
+				reason: kind === "reply" ? "model_reply" : `model_${kind}_output`,
+				text: note,
+				argsSummary: JSON.stringify({
+					outputKind: kind,
+					outputCharacters: event.data.message?.length ?? 0,
+					finishReason: event.data.finishReason
+				})
 			}));
 			if (coordinates.provider !== "telegram" && !silent) await archive.append(conversationEvent({
 				...base,

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;