@segmentstream/agent 0.18.3 → 0.19.0

package/dist/extension/lib/telegram/health.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 { t as agentBuild } from "../../../_chunks/build-metadata-DZ9Nb8Q2.mjs";
+import { t as agentBuild } from "../../../_chunks/build-metadata-CkW-D9NI.mjs";
 import { runtimeRequestFailure } from "./runtime-request.mjs";
 import { GET } from "eve/channels";
 const HEALTH_ROUTE = "/eve/v1/telegram/health";

package/dist/extension/lib/telegram/held-approvals.d.ts

@@ -1,4 +1,4 @@
-import type { CancelTurnResult } from "eve/channels";
+import { type Delivery } from "eve/sessions";
 import type { RecordedEvent } from "./sessions.js";
 /** An approval is an input barrier, never permission to execute it while recovering a chat. */
 export declare function heldApprovals(events: readonly RecordedEvent[]): {
@@ -15,13 +15,13 @@ export declare function releaseHeldApproval(input: {
     readonly now: number;
     readonly cancel: (options: {
         readonly turnId: string;
-    }) => Promise<CancelTurnResult>;
+    }) => Promise<Delivery>;
 }): Promise<{
     status: string;
     reason: string;
     turnId: string;
     startedAt: string;
     actions: string[];
-    cancellation: "accepted";
+    cancellation: "cancelled" | "failed" | "completed" | "awaiting-input";
     executionRequested: boolean;
 } | undefined>;

package/dist/extension/lib/telegram/held-approvals.mjs

@@ -6,27 +6,24 @@ __eveDirname(__filename);
 __eveCreateRequire(import.meta.url);
 import { object } from "../confirmation-description.mjs";
 import { CONFIRMATION_TTL_MS } from "../confirmations.mjs";
+import { SessionNotActiveError } from "eve/sessions";
 function heldApprovals(events) {
 	const pending = new Map();
+	const calls = new Map();
 	for (const event of events) {
 		const data = object(event.data);
-		if (event.type === "context.cleared" || event.type === "session.started") pending.clear();
-		if (event.type === "input.requested" && Array.isArray(data.requests)) for (const item of data.requests) {
-			const request = object(item);
-			const action = object(request.action);
-			if (request.kind === "tool-approval" && typeof request.requestId === "string" && typeof action.callId === "string" && typeof data.turnId === "string") pending.set(request.requestId, {
-				requestId: request.requestId,
-				callId: action.callId,
-				action: String(action.toolName ?? ""),
-				turnId: data.turnId,
-				at: event.meta.at
-			});
-		}
-		for (const [id, approval] of pending) if (event.type === "input.resolved" && Array.isArray(data.resolutions) && data.resolutions.some((item) => object(item).requestId === id) || event.type === "action.result" && object(data.result).callId === approval.callId || [
-			"turn.completed",
-			"turn.failed",
-			"turn.cancelled"
-		].includes(event.type) && data.turnId === approval.turnId) pending.delete(id);
+		if (event.type === "session.started" || event.type === "context.settled" && data.kind === "clear" && data.outcome === "completed") pending.clear();
+		if (event.type === "call.requested" && typeof data.callId === "string") calls.set(data.callId, String(object(data.capability).name ?? ""));
+		const callId = object(data.subject).callId;
+		const turnId = event.scope?.turnId;
+		if (event.type === "interaction.opened" && object(data.request).kind === "approval" && typeof data.interactionId === "string" && typeof callId === "string" && turnId !== void 0) pending.set(data.interactionId, {
+			requestId: data.interactionId,
+			callId,
+			action: calls.get(callId) ?? "",
+			turnId,
+			at: event.meta.at
+		});
+		for (const [id, approval] of pending) if (event.type === "interaction.settled" && data.interactionId === id || event.type === "call.settled" && data.callId === approval.callId || event.type === "turn.settled" && data.turnId === approval.turnId) pending.delete(id);
 	}
 	return [...pending.values()];
 }
@@ -36,8 +33,15 @@ async function releaseHeldApproval(input) {
 	const expired = pending.some((approval) => input.now - Date.parse(approval.at) >= CONFIRMATION_TTL_MS);
 	if (!input.addressed && !expired) return;
 	const turnId = pending[0].turnId;
-	const result = await input.cancel({ turnId });
-	if (result.status === "no_active_turn") return;
+	let delivery;
+	try {
+		delivery = await input.cancel({ turnId });
+	} catch (error) {
+		if (SessionNotActiveError.is(error) && !error.retryable) return;
+		throw error;
+	}
+	const result = await delivery.result();
+	if (result.outcome === "ignored" || result.outcome === "refused") return;
 	return {
 		status: "cancellation_requested",
 		reason: expired ? "expired" : "addressed",

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

@@ -1,6 +1,6 @@
 /** Storage still accepts up to 20 MiB; description has its own lower cost/transfer bound. */
 export declare const MAXIMUM_IMAGE_DESCRIPTION_BYTES: number;
-/** Eve 0.76.3's actual inbound image inlining limit. */
+/** Eve 0.85.0's actual inbound image inlining limit. */
 export declare const MAXIMUM_NATIVE_IMAGE_BYTES: number;
 export declare const MAXIMUM_IMAGE_DESCRIPTIONS = 1;
 export type ImageDescriber = (input: {

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 { p as reportTelegramError } from "../../../_chunks/inbound-request-8xhK7EaW.mjs";
+import { p as reportTelegramError } from "../../../_chunks/inbound-request-Dx1B6Y5r.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,5 +1,5 @@
 import type { DeferredConfirmation } from "../deferred-confirmations.js";
-import type { UserContent } from "ai";
+import type { MessageContent } from "eve/channels";
 import type { ChannelSource } from "eve/channels";
 import type { SessionAuthContext } from "eve/context";
 import type { DecodedAttachment } from "./attachment-description.js";
@@ -79,7 +79,7 @@ export declare class InboundRequest {
      */
     files: ReadonlyMap<string, StagedFile> | undefined;
     /** Earlier observed native images, rebound to this turn's authenticated requester. */
-    extraFiles: Exclude<UserContent, string> | undefined;
+    extraFiles: Exclude<MessageContent, string> | undefined;
     /** The route's session operations, on addresses already mapped to the configured scope. */
     sessions: SessionOperations | undefined;
     /** Host background lifetime; long-running observers must never enter the routing drain. */

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 { i as withReplacedText, n as currentInboundRequest, r as runInboundRequest, t as InboundRequest } from "../../../_chunks/inbound-request-8xhK7EaW.mjs";
+import { i as withReplacedText, n as currentInboundRequest, r as runInboundRequest, t as InboundRequest } from "../../../_chunks/inbound-request-Dx1B6Y5r.mjs";
 export { InboundRequest, currentInboundRequest, runInboundRequest, withReplacedText };

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

@@ -6,8 +6,8 @@ __eveDirname(__filename);
 __eveCreateRequire(import.meta.url);
 import { effectiveGroupPolicy, groupPolicy } from "../group-routing/policy.mjs";
 import { admitMessage, localizedText } from "../admission.mjs";
-import { d as telegramRuntimeSource, n as conversationLanguage, o as telegramPrincipal, u as runtimeEnvelope } from "../../../_chunks/principal-qyR3jKAr.mjs";
-import { p as reportTelegramError } from "../../../_chunks/inbound-request-8xhK7EaW.mjs";
+import { d as telegramRuntimeSource, n as conversationLanguage, o as telegramPrincipal, u as runtimeEnvelope } from "../../../_chunks/principal-BnJuWJtk.mjs";
+import { p as reportTelegramError } from "../../../_chunks/inbound-request-Dx1B6Y5r.mjs";
 import { addressingReason, conversationKey, otherRecipient } from "../group-routing/signals.mjs";
 import { conversationAddressing, conversationState } from "../group-routing/conversation.mjs";
 import { questionInvitation } from "../group-routing/engagement.mjs";
@@ -461,7 +461,7 @@ async function handleInboundMessage(input) {
 				chatId: sent.chat.id,
 				messageId: sent.messageId
 			}).catch((error) => {
-				reportTelegramError("typing_monitor_failed", error, { sessionId: session.id });
+				reportTelegramError("typing_monitor_failed", error, { sessionId: session.sessionId });
 			}));
 		};
 	}
@@ -504,9 +504,8 @@ async function handleInboundMessage(input) {
 	let answering = pending !== void 0 && (input.request?.lifecycleKey === void 0 || pending.taskId === input.request.lifecycleKey) && pending.memberId === member.id && pending.chatId === sent.chat.id && pending.messageThreadId === String(sent.messageThreadId ?? "");
 	const asked = questionHistory.findLast((event) => {
 		const data = isRecord(event.data) ? event.data : {};
-		const result = isRecord(data.result) ? data.result : {};
-		const output = isRecord(result.output) ? result.output : {};
-		return event.type === "action.result" && typeof result.toolName === "string" && result.toolName.endsWith("__questions_ask") && isRecord(output.pendingQuestion) && output.pendingQuestion.id === pending?.id;
+		const output = isRecord(data.output) ? data.output : {};
+		return event.type === "call.settled" && data.outcome === "completed" && isRecord(output.pendingQuestion) && output.pendingQuestion.id === pending?.id;
 	});
 	const questionAge = Date.parse(sentAt(sent)) - Date.parse(asked?.meta.at ?? "");
 	if (answering && addressed === void 0 && !questionInvitation(asked?.meta.at, sentAt(sent), groups.smart.engagement.openQuestionMinutes)) answering = false;

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

@@ -1,6 +1,6 @@
 import type { SessionAuthContext } from "eve/context";
 import type { TelegramContext } from "eve/channels/telegram";
-import type { Session } from "eve/channels";
+import type { Delivery } from "eve/sessions";
 import type { Environment } from "../environment.js";
 import type { RuntimeToken } from "../runtime-token.js";
 export interface AttachmentLifecycle {
@@ -51,6 +51,6 @@ export declare function attachmentLifecycle(options: {
     readonly fetch?: typeof fetch;
 }): (phase: "admitted" | "stored" | "retained" | "ready" | "completed", data?: Record<string, unknown>) => Promise<LifecycleResult>;
 /** Kept inside the webhook's waitUntil lifetime; terminal durable stream events close the reader. */
-export declare function typingUntilComplete(session: Session, marker: string, telegram: TelegramContext["telegram"], signal: AbortSignal, metadata?: Readonly<Record<string, string | undefined>>): Promise<void>;
+export declare function typingUntilComplete(session: Delivery, marker: string, telegram: TelegramContext["telegram"], signal: AbortSignal, metadata?: Readonly<Record<string, string | undefined>>): Promise<void>;
 /** No global timer survives a request or terminal event; failures retain safe method/status telemetry. */
 export declare function startTypingHeartbeat(telegram: TelegramContext["telegram"]): () => void;

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

@@ -4,12 +4,12 @@ import { createRequire as __eveCreateRequire } from "node:module";
 const __filename = __eveFileURLToPath(import.meta.url);
 __eveDirname(__filename);
 __eveCreateRequire(import.meta.url);
-import { d as telegramRuntimeSource, l as principalRuntimeSource, u as runtimeEnvelope } from "../../../_chunks/principal-qyR3jKAr.mjs";
+import { d as telegramRuntimeSource, l as principalRuntimeSource, u as runtimeEnvelope } from "../../../_chunks/principal-BnJuWJtk.mjs";
 import { object } from "../confirmation-description.mjs";
-import { n as currentInboundRequest, p as reportTelegramError } from "../../../_chunks/inbound-request-8xhK7EaW.mjs";
+import { n as currentInboundRequest, p as reportTelegramError } from "../../../_chunks/inbound-request-Dx1B6Y5r.mjs";
 import { needsConfirmation } from "../confirmations.mjs";
 import { OntologyActionNotPermitted, actionToolName, ontologyTools } from "../ontology-tools.mjs";
-import { t as agentBuild } from "../../../_chunks/build-metadata-DZ9Nb8Q2.mjs";
+import { t as agentBuild } from "../../../_chunks/build-metadata-CkW-D9NI.mjs";
 var AttachmentLifecycleNotPermitted = class extends Error {
 	code = "attachment_lifecycle_not_permitted";
 };
@@ -84,66 +84,62 @@ function attachmentLifecycle(options) {
 	};
 }
 async function typingUntilComplete(session, marker, telegram, signal, metadata = {}) {
-	const reader = (await session.getEventStream({ follow: true })).getReader();
+	const iterator = session.stream({ signal })[Symbol.asyncIterator]();
 	let turn;
 	let firstResponse = false;
 	const abort = () => {
-		reader.cancel().catch(() => void 0);
+		iterator.return?.().catch(() => void 0);
 	};
 	signal.addEventListener("abort", abort, { once: true });
 	const stop = startTypingHeartbeat(telegram);
 	try {
 		while (!signal.aborted) {
-			const item = await reader.read();
+			const item = await iterator.next();
 			if (item.done) break;
 			const event = item.value;
-			if (event.type === "message.received" && event.data.message.includes(marker)) {
+			if (event.type === "delivery.consumed" && event.data.parts.some((part) => part.kind === "text" && part.text.includes(marker))) {
 				turn = event.data.turnId;
 				console.info("[segmentstream] telegram.phase", {
 					...metadata,
 					phase: "turn_received",
 					at: new Date().toISOString(),
-					sessionId: session.id,
+					sessionId: session.sessionId,
 					turnId: turn
 				});
 			}
-			if (turn && event.data !== void 0 && "turnId" in event.data && event.data.turnId === turn && [
-				"step.started",
-				"actions.requested",
-				"action.result",
-				"turn.completed",
-				"turn.failed",
-				"turn.cancelled"
+			if (turn && event.scope?.turnId === turn && [
+				"model.started",
+				"call.requested",
+				"call.settled",
+				"turn.settled"
 			].includes(event.type)) console.info("[segmentstream] telegram.phase", {
 				...metadata,
 				phase: event.type,
 				at: new Date().toISOString(),
-				sessionId: session.id,
+				sessionId: session.sessionId,
 				turnId: turn
 			});
-			if (turn && !firstResponse && (event.type === "message.appended" || event.type === "reasoning.appended") && "turnId" in event.data && event.data.turnId === turn) {
+			if (turn && !firstResponse && event.type === "content.delta" && event.scope?.turnId === turn) {
 				firstResponse = true;
 				console.info("[segmentstream] telegram.phase", {
 					...metadata,
 					phase: "model_first_response",
 					at: new Date().toISOString(),
-					sessionId: session.id,
+					sessionId: session.sessionId,
 					turnId: turn
 				});
 			}
-			if (event.type === "session.failed" || event.type === "session.completed") break;
-			if (turn && "turnId" in event.data && event.data.turnId === turn && ([
-				"turn.completed",
-				"turn.failed",
-				"turn.cancelled",
-				"input.requested"
-			].includes(event.type) || event.type === "turn.waiting" && event.data.on === "input")) break;
+			if (event.type === "session.ended") break;
+			if (turn && event.scope?.turnId === turn && [
+				"turn.settled",
+				"turn.paused",
+				"interaction.opened"
+			].includes(event.type)) break;
 		}
 	} finally {
 		stop();
 		signal.removeEventListener("abort", abort);
-		await reader.cancel().catch(() => void 0);
-		reader.releaseLock();
+		await iterator.return?.().catch(() => void 0);
 	}
 }
 function startTypingHeartbeat(telegram) {

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 { p as reportTelegramError } from "../../../_chunks/inbound-request-8xhK7EaW.mjs";
+import { p as reportTelegramError } from "../../../_chunks/inbound-request-Dx1B6Y5r.mjs";
 function planMedia(capabilities, descriptionModel = null) {
 	if (typeof descriptionModel === "string") return {
 		images: "describe",

package/dist/extension/lib/telegram/principal.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 { a as rolesOf, i as memberIdOf, n as conversationLanguage, o as telegramPrincipal, r as identityProviderOf, t as TELEGRAM_AUTHENTICATOR } from "../../../_chunks/principal-qyR3jKAr.mjs";
+import { a as rolesOf, i as memberIdOf, n as conversationLanguage, o as telegramPrincipal, r as identityProviderOf, t as TELEGRAM_AUTHENTICATOR } from "../../../_chunks/principal-BnJuWJtk.mjs";
 export { TELEGRAM_AUTHENTICATOR, conversationLanguage, identityProviderOf, memberIdOf, rolesOf, telegramPrincipal };

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

@@ -19,7 +19,7 @@ async function routingContext(input) {
 		for (const history of histories.values()) for (const question of questionsFromHistory(history)) {
 			const asked = history.findLast((event) => {
 				const data = event.data;
-				return event.type === "action.result" && data?.result?.output?.pendingQuestion?.id === question.id;
+				return event.type === "call.settled" && data?.output?.pendingQuestion?.id === question.id;
 			});
 			pending.set(questionKey(question), {
 				...question,
@@ -64,14 +64,14 @@ async function routingContext(input) {
 		const recovered = [];
 		let resetAt = 0;
 		for (const event of events) {
-			if (event.type === "context.cleared" || event.type === "session.started") {
+			if (event.type === "session.started" || event.type === "context.settled" && event.data?.kind === "clear" && event.data?.outcome === "completed") {
 				recovered.length = 0;
 				resetAt = Date.parse(event.meta.at);
 			}
 			const age = sentAt - Date.parse(event.meta.at);
 			const data = typeof event.data === "object" && event.data !== null ? event.data : void 0;
-			if (event.type === "message.completed" && data !== void 0 && typeof data.message === "string" && typeof data.finishReason === "string" && data.finishReason !== "tool-calls" && data.message.trim() !== "" && !isSilentReply(data.message) && age >= 0 && age <= (input.followUpMinutes === void 0 ? 18e5 : input.followUpMinutes * 6e4)) recovered.push(agentMessage({
-				text: data.message,
+			if (event.type === "content.completed" && data !== void 0 && typeof data.value === "string" && data.kind === "text" && data.phase === "reply" && !data.interrupted && data.value.trim() !== "" && !isSilentReply(data.value) && age >= 0 && age <= (input.followUpMinutes === void 0 ? 18e5 : input.followUpMinutes * 6e4)) recovered.push(agentMessage({
+				text: data.value,
 				at: event.meta.at
 			}));
 		}

package/dist/extension/lib/telegram/session-recovery.d.ts

@@ -1,7 +1,7 @@
 import type { ChannelReceiveContext } from "eve/channels";
 import type { HistoryReader } from "./sessions.js";
 /**
- * Eve 0.76.3 cannot resolve/reset an inbox whose metadata key belonged to a deleted deployment.
+ * A deleted deployment can make the Workflow metadata key unreadable before Eve can hand off a session.
  * Recover on a read, before dispatch: independent requests on this deployment use the same fresh
  * continuation. Healthy addresses keep their owner across deploys. An already broken address
  * gets a fresh owner on each deployment; the archive remains the source of routing context.

package/dist/extension/lib/telegram/session-recovery.mjs

@@ -4,7 +4,7 @@ import { createRequire as __eveCreateRequire } from "node:module";
 const __filename = __eveFileURLToPath(import.meta.url);
 __eveDirname(__filename);
 __eveCreateRequire(import.meta.url);
-import { p as reportTelegramError } from "../../../_chunks/inbound-request-8xhK7EaW.mjs";
+import { p as reportTelegramError } from "../../../_chunks/inbound-request-Dx1B6Y5r.mjs";
 import { createHash } from "node:crypto";
 function missingDeployment(error) {
 	if (!(error instanceof Error) || error.name !== "RunKeyFetchError" || !("status" in error) || error.status !== 404) return false;
@@ -54,6 +54,7 @@ function recoverableSessions(operations, deploymentId, readHistory) {
 	return {
 		resolveSession,
 		from: (address) => ({
+			create: async (options) => (await source(address)).create(options),
 			send: async (message, options) => (await source(address)).send(message, options),
 			respond: async (responses, options) => (await source(address)).respond(responses, options),
 			cancel: async (options) => (await source(address)).cancel(options),

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

@@ -1,5 +1,5 @@
 import type { TelegramMessage } from "eve/channels/telegram";
-import type { CancelTurnResult, ChannelSource } from "eve/channels";
+import type { ChannelSource } from "eve/channels";
 import type { TelegramChannelState } from "eve/channels/telegram";
 import type { SessionSettings } from "../../config.js";
 /**
@@ -42,6 +42,9 @@ export interface SessionHistory {
 /** One recorded event used by session policy, routing context and interaction projections. */
 export interface RecordedEvent {
     readonly type: string;
+    readonly scope?: {
+        readonly turnId?: string;
+    };
     readonly meta: {
         readonly at: string;
     };
@@ -60,12 +63,12 @@ export interface SessionOperations {
         readonly id: string;
         readonly cancel?: (options: {
             readonly turnId: string;
-        }) => Promise<CancelTurnResult>;
+        }) => Promise<import("eve/sessions").Delivery>;
     } | undefined>;
     readonly from: (address: string) => {
         readonly send?: ChannelSource<TelegramChannelState>["send"];
-        compact(): Promise<unknown>;
-        clear(): Promise<unknown>;
+        compact: ChannelSource<TelegramChannelState>["compact"];
+        clear: ChannelSource<TelegramChannelState>["clear"];
     };
 }
 export type SessionAction = "none" | "cleared" | "compacted";

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

@@ -96,11 +96,11 @@ function historyOf(events) {
 		if (Number.isNaN(at)) continue;
 		lastAt = Math.max(lastAt, at);
 		earliest = earliest === 0 ? at : Math.min(earliest, at);
-		if (event.type === "session.started" || event.type === "compaction.completed" || event.type === "context.cleared") {
+		if (event.type === "session.started" || event.type === "context.settled" && typeof event.data === "object" && event.data !== null && "outcome" in event.data && event.data.outcome === "completed") {
 			resetAt = at;
 			marked = true;
 			turnsSinceReset = 0;
-		} else if (event.type === "turn.completed") turnsSinceReset += 1;
+		} else if (event.type === "turn.settled") turnsSinceReset += 1;
 	}
 	return {
 		lastAt,
@@ -166,7 +166,10 @@ function sessionPolicy(input) {
 				action = due(known, settings, now, activeAt);
 			}
 			if (action === "clear") try {
-				await operations.from(address).clear();
+				if ((await (await operations.from(address).clear()).result()).outcome !== "applied") {
+					remembered.delete(address);
+					return "none";
+				}
 				remember(address, {
 					lastAt: known.lastAt,
 					resetAt: now.getTime(),

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

@@ -3,7 +3,7 @@ import { type ObservedMessages } from "./observed.js";
 export declare function isSilentReply(text: string): boolean;
 /** Use the same classification for delivery and its archive decision. Never strip real prose. */
 export declare function completionKind(message: string | null | undefined, finishReason?: string): "reply" | "tool_calls" | "empty" | "whitespace" | "silent_marker";
-type MessageCompleted = NonNullable<TelegramChannelEvents["message.completed"]>;
+type MessageCompleted = NonNullable<TelegramChannelEvents["content.completed"]>;
 /** The texts one runtime delivered as interim messages, per session turn. */
 export interface InterimTexts {
     has(turn: string, text: string): boolean;

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

@@ -4,11 +4,11 @@ import { createRequire as __eveCreateRequire } from "node:module";
 const __filename = __eveFileURLToPath(import.meta.url);
 __eveDirname(__filename);
 __eveCreateRequire(import.meta.url);
-import "../../../_chunks/principal-qyR3jKAr.mjs";
+import "../../../_chunks/principal-BnJuWJtk.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-8xhK7EaW.mjs";
+import { a as TelegramDeliveryError, l as customerMessage, o as currentLocale, p as reportTelegramError } from "../../../_chunks/inbound-request-Dx1B6Y5r.mjs";
 import { agentMessage, observedChatKey } from "../group-routing/observed.mjs";
 const SILENT_MARKERS = new Set(["[silent]", "no_reply"]);
 function isSilentReply(text) {
@@ -37,15 +37,18 @@ function interimTexts(limit = 256) {
 	};
 }
 function replyDelivery(observed, scope = () => "telegram", interim) {
-	return async (event, channel, context) => {
-		const kind = completionKind(event.message, event.finishReason);
+	return async (event, context) => {
+		if (event.data.kind !== "text" || event.data.interrupted) return;
+		const channel = context.channel;
+		const textValue = typeof event.data.value === "string" ? event.data.value : "";
+		const kind = completionKind(textValue, event.data.phase === "reply" ? "stop" : "tool-calls");
 		const interimOn = interim?.enabled() === true;
-		const isInterim = kind === "tool_calls" && interimOn && completionKind(event.message) === "reply";
+		const isInterim = kind === "tool_calls" && interimOn && completionKind(textValue) === "reply";
 		if (kind !== "reply" && !isInterim) return;
-		const turn = interimOn && typeof event.turnId === "string" && event.turnId !== "" ? JSON.stringify([context.session?.id ?? "", event.turnId]) : void 0;
-		const key = event.message.trim();
+		const turn = interimOn && typeof event.scope?.turnId === "string" && event.scope?.turnId !== "" ? JSON.stringify([context.session?.id ?? "", event.scope?.turnId]) : void 0;
+		const key = textValue.trim();
 		if (turn !== void 0 && interim.delivered.has(turn, key)) return;
-		const message = customerMessage(event.message, confirmationLocale(context.session?.auth.current ?? null, currentLocale()));
+		const message = customerMessage(textValue, confirmationLocale(context.session?.auth.current ?? null, currentLocale()));
 		const principal = context.session?.auth.current;
 		const replyTo = principal?.attributes.replyToMessageId;
 		const replyParameters = typeof replyTo === "string" && /^[1-9]\d*$/u.test(replyTo) ? { reply_parameters: {

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

@@ -5,7 +5,7 @@ const __filename = __eveFileURLToPath(import.meta.url);
 __eveDirname(__filename);
 __eveCreateRequire(import.meta.url);
 import { STRUCTURED_KINDS } from "./structured-settings.mjs";
-import { d as telegramRuntimeSource, u as runtimeEnvelope } from "../../../_chunks/principal-qyR3jKAr.mjs";
+import { d as telegramRuntimeSource, u as runtimeEnvelope } from "../../../_chunks/principal-BnJuWJtk.mjs";
 import { workspaceAction } from "./workspace-action.mjs";
 const record = (value) => {
 	if (value === null || typeof value !== "object" || Array.isArray(value)) throw new Error("Invalid structured Telegram object.");

package/dist/extension/lib/telegram/turn-errors.d.ts

@@ -5,4 +5,4 @@ import type { AgentIdentities } from "../identities.js";
 export declare function telegramFailureEvents(input: {
     readonly archive: Conversations;
     readonly identities: () => AgentIdentities;
-}): Pick<TelegramChannelEvents, "turn.failed" | "turn.cancelled" | "session.failed" | "authorization.completed" | "authorization.required">;
+}): Pick<TelegramChannelEvents, "turn.settled" | "session.ended" | "interaction.settled" | "interaction.opened">;