@segmentstream/agent 0.26.1 → 0.28.0

package/dist/extension/lib/group-routing/router.mjs

@@ -6,8 +6,8 @@ __eveDirname(__filename);
 __eveCreateRequire(import.meta.url);
 import { DEFAULT_GROUP_POLICY, groupPolicy, overlaySmartPolicy } from "./policy.mjs";
 import { addressingReason, otherRecipient, signalAudience } from "./signals.mjs";
-import { conversationState, conversationThreshold } from "./conversation.mjs";
-import { conversationDecisionRouter } from "./conversation-router.mjs";
+import { conversationAddressing } from "./addressing.mjs";
+import { addressedToAgent, conversationDecisionRouter } from "./conversation-router.mjs";
 import { recordRoutingMetric } from "./health.mjs";
 import { humanAddressee, humanThread, questionInvitation, restoreEngagement } from "./engagement.mjs";
 import { boundedRouterPayload, policyHash } from "./record.mjs";
@@ -76,9 +76,8 @@ function recentlyAddressed(message, sender) {
 function lastOutbound(question) {
 	return question.recent.findLast((message) => isAgentMessage(message) && message.messageId !== void 0 && Date.parse(message.at) <= Date.parse(question.message.at));
 }
-function conversationContext(question, options = {}) {
+function conversationContext(question) {
 	const sentAt = Date.parse(question.message.at);
-	const since = options.since;
 	const policy = question.groups ?? DEFAULT_GROUP_POLICY;
 	const recent = question.recent.slice(-policy.smart.context.messages).filter((message) => {
 		if (!isAgentMessage(message)) return true;
@@ -140,8 +139,7 @@ function conversationContext(question, options = {}) {
 				human_thread: humanThread(question.signals, question.recent, policy.smart.engagement.followUpMinutes)
 			})
 		},
-		recent_messages: (since === void 0 ? recent : recent.filter((message) => Date.parse(message.at) >= since)).map((message) => line(message, bot, roster, question.message.at)),
-		...since === void 0 ? {} : { recent_messages_since: new Date(since).toISOString() },
+		recent_messages: recent.map((message) => line(message, bot, roster, question.message.at)),
 		possible_follow_up_to: followUps.map((message) => line(message, bot, roster, question.message.at)),
 		open_questions: openQuestions,
 		last_outbound: JSON.stringify(outbound === void 0 ? null : {
@@ -302,25 +300,11 @@ async function routeMessage(input) {
 			groups,
 			signals
 		};
-		const analysis = conversationState({
-			signals,
-			recent: question.recent,
-			policy: groups,
-			agentNames: [...question.agentIdentity?.aliases ?? [], ...question.agentIdentity?.username ? [question.agentIdentity.username] : []],
-			pendingQuestionAt: input.pendingQuestionAt,
-			asOf: question.processingAt
-		});
-		question = {
-			...question,
-			conversation: analysis
-		};
+		const evidence = conversationAddressing(signals, question.recent, groups, [...question.agentIdentity?.aliases ?? [], ...question.agentIdentity?.username ? [question.agentIdentity.username] : []]);
 		payload = {
 			...payload,
 			burst_id: question.burstId,
-			path: analysis.path,
-			conversation: analysis.conversation,
-			human_exchange: analysis.human_exchange,
-			pending_question_voided: input.pendingQuestionAt !== void 0 && !analysis.pending_question_live,
+			addressing_evidence: evidence,
 			question: {
 				recent: question.recent,
 				pendingQuestions: question.pendingQuestions,
@@ -330,30 +314,22 @@ async function routeMessage(input) {
 				messagesToClassify: question.messagesToClassify
 			}
 		};
-		if (analysis.path === "A") {
+		if (evidence.agent_named || evidence.reply_to_agent && evidence.human_targets.length === 0 && evidence.soft_target === void 0) {
 			if (input.beforeDecide && !await input.beforeDecide(true)) return complete("observe", "admission_refused", "Admission refused before direct turn.");
 			return complete("reply", addressed && addressed !== "pending-question" ? addressed : "mention", "Agent explicitly addressed.");
 		}
-		if (analysis.path === "H") return complete("observe", "human_addressee", "Message addresses another participant; conversation and question invitation closed.");
+		if (evidence.human_targets.length > 0) return complete("observe", "human_addressee", "Message replies to, tags or names another participant.");
 		if (signals.addressing.eligible === false) return complete("observe", "channel_ineligible", "Channel excludes ambient messages.");
 		if (groups.mode === "mention") return complete("observe", "mention_policy", "Mention policy observes unaddressed messages.");
 		if (input.beforeDecide && !await input.beforeDecide()) return complete("observe", "admission_refused", "Admission refused before inference.");
 		const result = await input.decide(question);
 		const diagnostics = typeof result === "string" ? void 0 : result.diagnostics;
-		const probabilities = diagnostics?.addressing;
-		const threshold = conversationThreshold(analysis.path, groups);
-		const valid = probabilities !== void 0 && probabilities.addressee.choice === "agent" && (probabilities.addressee.probabilities?.agent ?? NaN) >= threshold && (probabilities.needs_response.probabilities?.true ?? NaN) >= (analysis.path === "B" || analysis.path === "X" ? .7 : .5) && (probabilities.ends_conversation.probabilities?.true ?? NaN) < .7;
+		const valid = addressedToAgent(diagnostics?.addressing);
 		payload = {
 			...payload,
-			...typeof result === "string" ? {} : result.router,
-			thresholds_applied: {
-				threshold,
-				path: analysis.path,
-				needs_response: analysis.path === "B" || analysis.path === "X" ? .7 : .5,
-				ends_conversation: .7
-			}
+			...typeof result === "string" ? {} : result.router
 		};
-		return complete(valid ? "reply" : "observe", `decision_model_${valid ? "reply" : "observe"}`, "Conversation addressing probabilities evaluated.", "decision-model", diagnostics);
+		return complete(valid ? "reply" : "observe", `decision_model_${valid ? "reply" : "observe"}`, "Addressee read from the chat's recent messages.", "decision-model", diagnostics);
 	} catch (error) {
 		console.error("[segmentstream] conversation routing failed", { error });
 		return complete("observe", error instanceof Error && error.name === "TimeoutError" ? "decision_model_timeout" : "decision_model_failed", "Conversation routing unavailable; observe fallback.");

package/dist/extension/lib/group-routing/routing-context.d.ts

@@ -1,4 +1,8 @@
-import { type RecentMessage } from "./observed.js";
+import { type RecentMessage } from "./messages.js";
 import { type ConversationPage } from "../conversations.js";
-/** Cold ring: the same 30 messages, including unlinked humans and confirmed delivered bot messages. */
+/**
+ * The archive's recent messages for routing, oldest first, including unlinked humans and confirmed
+ * delivered bot messages. A message that started a turn is `admitted`; stored native images of
+ * the others ride along by reference, for the next turn that answers.
+ */
 export declare function archivedRoutingMessages(events: ConversationPage["events"], limit?: number): ReadonlyArray<RecentMessage>;

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

@@ -5,7 +5,7 @@ const __filename = __eveFileURLToPath(import.meta.url);
 __eveDirname(__filename);
 __eveCreateRequire(import.meta.url);
 import { collapseConversationEvents } from "../conversations.mjs";
-import { agentMessage } from "./observed.mjs";
+import { agentMessage } from "./messages.mjs";
 function archivedMetadata(event) {
 	try {
 		return JSON.parse(event.argsSummary ?? "null")?.routing ?? {};
@@ -34,15 +34,7 @@ function archivedRoutingMessages(events, limit = 30) {
 		"thread-with-agent",
 		"pending-question"
 	].includes(event.reason ?? "")).map((event) => [event.messageId, event.reason]));
-	const ended = new Set(events.filter((event) => {
-		if (event.kind !== "decision" || event.messageId === null) return false;
-		try {
-			const data = JSON.parse(event.argsSummary ?? "{}");
-			return data.router?.conversation_ended === true || data.routing?.conversationEnded === true;
-		} catch {
-			return false;
-		}
-	}).map((event) => event.messageId));
+	const admitted = new Set(events.flatMap((event) => event.kind === "decision" && event.reason === "turn_admitted" && event.messageId !== null ? [event.messageId] : []));
 	const membership = new Map();
 	for (const event of [...events].reverse()) {
 		if (event.kind !== "decision" || event.senderId === null) continue;
@@ -68,10 +60,19 @@ function archivedRoutingMessages(events, limit = 30) {
 		} : recordedReply;
 		const derivedText = metadata.decoded?.flatMap((item) => item.content === void 0 ? [] : [item.content]).join("\n");
 		const text = (event.text || derivedText || (metadata.media ? "" : "[attachment or service message]")).slice(0, 2e3);
+		const images = (Array.isArray(metadata.files) ? metadata.files : []).filter((file) => file.image === true).map(({ id, filename, contentType, size, expiresAt }) => ({
+			id,
+			filename,
+			contentType,
+			size,
+			expiresAt
+		}));
 		const common = {
 			invitation: metadata.invitation ?? invitations.get(event.messageId ?? ""),
-			...ended.has(event.messageId) ? { conversationEnded: true } : {},
+			...event.kind === "inbound" && admitted.has(event.messageId ?? "") ? { admitted: true } : {},
+			...images.length === 0 ? {} : { images },
 			author: event.senderName ?? event.senderId ?? "unknown sender",
+			...typeof metadata.author === "string" && event.kind === "inbound" ? { signedAuthor: metadata.author } : {},
 			text,
 			...metadata.media === void 0 ? {} : { media: metadata.media },
 			at: event.at,

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

@@ -9,7 +9,6 @@ import { type RuntimeTokenVerifier } from "../runtime-identity.js";
 import { type RuntimeToken } from "../runtime-token.js";
 import { type ImageDescriber } from "./images.js";
 import { type CapabilityLookup } from "./media-policy.js";
-import { type ObservedMessages } from "./observed.js";
 import type { PdfTextExtractor } from "./pdf-text.js";
 import { type DecideFunction } from "./router.js";
 import { type HistoryReader } from "./sessions.js";
@@ -44,10 +43,9 @@ export interface TelegramAdapterOptions {
     readonly describeAttachment?: AttachmentDescriber;
     readonly extractPdf?: PdfTextExtractor;
     readonly modelCapabilities?: CapabilityLookup;
-    readonly observed?: ObservedMessages;
     /** 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. */
+    /** Reads session events for routing and interactions; tests pass a fake. */
     readonly history?: HistoryReader;
     /** The attachment store; tests pass a fake. */
     readonly attachments?: AgentAttachments;

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

@@ -13,7 +13,7 @@ import { n as conversationLanguage, o as telegramPrincipal } from "../../../_chu
 import { object } from "../confirmation-description.mjs";
 import { confirmationLocale } from "./confirmation-text.mjs";
 import { telegramSendScope } from "./send-queue.mjs";
-import { conversations } from "../conversations.mjs";
+import { conversations, topicContext } from "../conversations.mjs";
 import { withDeliveryDiagnostics } from "./delivery-diagnostics.mjs";
 import { d as failureText, h as withDeliveryLocale, i as withReplacedText, m as safeTelegramFetch, n as currentInboundRequest, o as currentLocale, p as reportTelegramError, r as runInboundRequest, t as InboundRequest } from "../../../_chunks/inbound-request-D1r0FkDI.mjs";
 import { chooseModel } from "../../model.mjs";
@@ -21,22 +21,21 @@ import { groupRoutingHealth } from "../group-routing/health.mjs";
 import { decisionRouter } from "../group-routing/router.mjs";
 import { archivedRoutingMessages } from "../group-routing/routing-context.mjs";
 import { dispatchStructuredMessage, structuredMessage } from "./structured.mjs";
-import { scopedAddress, sessionPolicy } from "./sessions.mjs";
+import { scopedAddress } from "./sessions.mjs";
 import { handleWorkspaceCallback, isWorkspaceCallback } from "./callbacks.mjs";
-import { t as agentBuild } from "../../../_chunks/build-metadata-D_Gqlb5f.mjs";
+import { t as agentBuild } from "../../../_chunks/build-metadata-CMmCRD8l.mjs";
 import { attachmentLifecycle } from "./lifecycle.mjs";
 import { gatewayImageDescriber } from "./images.mjs";
 import { gatewayAttachmentDescriber } from "./attachment-description.mjs";
 import { MAXIMUM_DOWNLOAD_BYTES, connectionProxy } from "../connection-proxy.mjs";
 import { agentAttachments, parseAttachmentUrl } from "../attachments.mjs";
 import { agentIdentities } from "../identities.mjs";
-import { observedMessages } from "./observed.mjs";
-import { interimTexts, replyDelivery } from "./silent.mjs";
-import { handleConfirmationCallback, telegramConfirmationEvents } from "./confirmations.mjs";
 import { captureRouteDecider, captureTelegramFetch, conversationIdentities, recordGateDecision, telegramConversationCapture } from "./conversations.mjs";
 import { botIdentityCache } from "./bot.mjs";
+import { handleConfirmationCallback, telegramConfirmationEvents } from "./confirmations.mjs";
 import { gatewayMediaCapabilities, planMedia } from "./media-policy.mjs";
 import { agentChats } from "./chats.mjs";
+import { interimTexts, replyDelivery } from "./silent.mjs";
 import { downloadTelegramFile, gatewayTranscriber } from "./voice.mjs";
 import { handleInboundMessage } from "./inbound.mjs";
 import { recoverableSessions } from "./session-recovery.mjs";
@@ -78,7 +77,6 @@ const eveInteractions = async (sessionId) => {
 function segmentstreamTelegram(options) {
 	const environment = options.environment ?? process.env;
 	const token = options.token ?? runtimeToken;
-	const observed = options.observed ?? observedMessages(60);
 	const readHistory = options.history ?? eveHistory;
 	const readInteractions = options.history ?? eveInteractions;
 	const capabilities = options.modelCapabilities ?? gatewayMediaCapabilities(options.fetch);
@@ -87,10 +85,6 @@ function segmentstreamTelegram(options) {
 		token,
 		fetch: options.fetch
 	});
-	const policy = sessionPolicy({
-		settings: options.sessions,
-		read: readHistory
-	});
 	const bot = botIdentityCache();
 	const proxies = new Map();
 	const interimDelivered = interimTexts();
@@ -127,7 +121,6 @@ function segmentstreamTelegram(options) {
 	const capture = telegramConversationCapture({
 		archive,
 		identities: pairing,
-		observed,
 		chats,
 		structured: (raw) => {
 			const inbound = settings().inbound;
@@ -172,7 +165,7 @@ function segmentstreamTelegram(options) {
 		archive,
 		identities: pairing
 	});
-	const approvalEvents = telegramConfirmationEvents(archive, observed, () => options.sessions().scope);
+	const approvalEvents = telegramConfirmationEvents(archive, () => options.sessions().scope);
 	const channel = telegramChannel({
 		turnPolicy: "queue",
 		api: {
@@ -203,10 +196,10 @@ function segmentstreamTelegram(options) {
 						policy: settings().policy,
 						decisionModel: options.models().decision,
 						groups: options.groups?.(),
-						recentConversation: async (chatId, threadId) => archivedRoutingMessages((await archive.context({
+						recentConversation: async (chatId, threadId) => archivedRoutingMessages((await topicContext(archive, {
 							provider: "telegram",
 							chatId,
-							...threadId === void 0 ? {} : { threadId },
+							threadId: threadId ?? null,
 							limit: 200,
 							includeDecisions: true
 						})).events, 100),
@@ -236,7 +229,6 @@ function segmentstreamTelegram(options) {
 						}) },
 						sessions: options.sessions,
 						admission: options.admission ?? (() => manifestOf({})),
-						sessionPolicy: policy,
 						sttModel: options.models().stt,
 						attachmentsModel: options.models().imageDescription ?? options.models().attachments ?? "google/gemini-2.5-flash-lite",
 						describeAttachment: options.describeAttachment ?? gatewayAttachmentDescriber,
@@ -285,7 +277,6 @@ function segmentstreamTelegram(options) {
 							...options
 						}),
 						attachments: attachments(),
-						observed,
 						readHistory,
 						history: readInteractions,
 						chats,
@@ -425,7 +416,7 @@ function segmentstreamTelegram(options) {
 					await channel.telegram.post(failureText(reference));
 					return;
 				}
-				await replyDelivery(observed, () => telegramSendScope(environment, settings().connection), {
+				await replyDelivery(() => telegramSendScope(environment, settings().connection), {
 					enabled: () => settings().interimMessages === true,
 					delivered: interimDelivered
 				})(event, context);

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

@@ -1,13 +1,13 @@
 import type { ChannelEvents } from "eve/channels";
 import type { TelegramCallbackQuery, TelegramChannelEvents, TelegramContext, TelegramEventContext } from "eve/channels/telegram";
-import { type ObservedMessages, type PendingConfirmation, type RecentMessage } from "./observed.js";
+import { type ConfirmationPrompt, type PendingConfirmation, type RecentMessage } from "../group-routing/messages.js";
 import { type Conversations } from "../conversations.js";
 import type { AgentIdentities } from "../identities.js";
 import { type PendingQuestion } from "../questions.js";
 import { type HistoryReader, type RecordedEvent } from "./sessions.js";
 export declare function confirmationCallback(requestId: string, memberId: string, decision: "approve" | "cancel" | "edit"): string;
 /** Terminal facts override stale presentation, including when a Telegram edit failed. */
-export declare function routingConfirmationState(events: readonly RecordedEvent[], prompt: import("./observed.js").ConfirmationPrompt, at: string): NonNullable<PendingConfirmation["state"]>;
+export declare function routingConfirmationState(events: readonly RecordedEvent[], prompt: ConfirmationPrompt, at: string): NonNullable<PendingConfirmation["state"]>;
 /** Read-only projection of the same durable approval lifecycle used by the callback gate. */
 export declare function routingConfirmations(events: readonly RecordedEvent[], recent: readonly RecentMessage[], at: string): ReadonlyArray<PendingConfirmation>;
 export declare function questionFromHistory(events: readonly RecordedEvent[], owner?: Pick<PendingQuestion, "memberId" | "chatId" | "messageThreadId">): PendingQuestion | undefined;
@@ -23,5 +23,5 @@ export declare function handleConfirmationCallback(input: {
     readonly scope: "chat" | "thread";
     readonly now?: number;
 }): Promise<void>;
-export declare function telegramConfirmationEvents(archive?: Conversations, observed?: ObservedMessages, scope?: () => "chat" | "thread"): TelegramChannelEvents & Pick<ChannelEvents<TelegramEventContext>, "context.settled">;
+export declare function telegramConfirmationEvents(archive?: Conversations, scope?: () => "chat" | "thread"): TelegramChannelEvents & Pick<ChannelEvents<TelegramEventContext>, "context.settled">;
 export declare const confirmationEvents: TelegramChannelEvents & Pick<ChannelEvents<TelegramEventContext>, "context.settled">;

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

@@ -11,7 +11,7 @@ import { renderConfirmation, withConfirmationText } from "./confirmation-text.mj
 import { chatPostCard, chatPostCardStatus, chatPostReceipt, withChatPostCard } from "./chat-post-card.mjs";
 import { conversationEvent } from "../conversations.mjs";
 import { n as currentInboundRequest, p as reportTelegramError } from "../../../_chunks/inbound-request-D1r0FkDI.mjs";
-import { agentMessage, observedChatKey, withConfirmationPrompt } from "../group-routing/observed.mjs";
+import { withConfirmationPrompt } from "../group-routing/messages.mjs";
 import { chatPostOperationId, isChatPost } from "../chat-post-confirmation.mjs";
 import { confirmations } from "../confirmations.mjs";
 import { formatAddress, scopedAddress } from "./sessions.mjs";
@@ -201,23 +201,7 @@ function messagePrompt(message) {
 		at: new Date().toISOString()
 	};
 }
-function telegramConfirmationEvents(archive, observed, scope) {
-	const remember = (channel, ctx, messageId, text, confirmation) => {
-		const principal = ctx.session.auth.current;
-		const name = humanText(principal?.attributes.memberName);
-		observed?.remember(observedChatKey(channel.telegram), {
-			...agentMessage({
-				text,
-				at: new Date().toISOString(),
-				messageId,
-				...principal?.subject === void 0 || name === void 0 ? {} : { inReplyTo: {
-					id: principal.subject,
-					author: name
-				} }
-			}),
-			...confirmation === void 0 ? {} : { confirmation }
-		});
-	};
+function telegramConfirmationEvents(archive, scope) {
 	const record = async (callId, phase, text, status, ctx) => {
 		const saved = confirmations.get()[callId];
 		if (archive === void 0 || saved?.description?.chatPost === void 0 || saved.source === void 0) return;
@@ -275,7 +259,6 @@ function telegramConfirmationEvents(archive, observed, scope) {
 						selective: true
 					}
 				}));
-				remember(channel, ctx, sent.id, text);
 				channel.state.pendingFreeformReplies = {
 					...channel.state.pendingFreeformReplies,
 					[sent.id]: requestId
@@ -341,7 +324,6 @@ function telegramConfirmationEvents(archive, observed, scope) {
 				} }
 			};
 			const sent = await withConfirmationPrompt(prompt, () => exactPost ? withChatPostCard(text, send, copy.previewLinks) : withConfirmationText(text, send));
-			remember(channel, ctx, sent.id, text, prompt);
 			if (aliasesPendingTopic(scope?.(), channel.continuation?.token)) channel.continuation?.alias(formatAddress({
 				chatId: channel.telegram.chatId,
 				messageThreadId: String(channel.telegram.messageThreadId ?? ""),
@@ -405,7 +387,6 @@ function telegramConfirmationEvents(archive, observed, scope) {
 			};
 			message.prompt = prompt;
 			await withConfirmationPrompt(prompt, () => message.exactPost ? withChatPostCard(text, edit, [...message.previewLinks ?? [], ...telegramTextLinks(status)]) : withConfirmationText(text, edit));
-			remember(channel, ctx, message.messageId, text, prompt);
 			await record(callId, reason ?? (resolution.outcome === "accepted" ? "approved" : resolution.outcome === "declined" ? "cancelled" : "ignored"), text, resolution.outcome === "accepted" ? "requested" : "cancelled", ctx);
 			if (resolution.outcome !== "accepted") {
 				delete state.confirmationMessages?.[callId];
@@ -451,14 +432,13 @@ function telegramConfirmationEvents(archive, observed, scope) {
 						}));
 						channel.continuation?.alias(questionAddress(saved));
 					}
-					const sent = await channel.telegram.post({
+					await channel.telegram.post({
 						text: question.question,
 						reply_markup: {
 							force_reply: true,
 							selective: true
 						}
 					});
-					remember(channel, ctx, sent.id, question.question);
 				}
 			}
 			const message = state.confirmationMessages?.[data.callId];
@@ -479,7 +459,6 @@ function telegramConfirmationEvents(archive, observed, scope) {
 					replyMarkup: { inline_keyboard: [] },
 					text
 				}), [...message.previewLinks ?? [], ...telegramTextLinks(status)]));
-				remember(channel, ctx, message.messageId, text, prompt);
 				await record(data.callId, "receipt", text, failed ? "failed" : object(action?.kind === "tool" ? data.output : void 0).status === "sent" ? "completed" : "unknown", ctx);
 			} else {
 				const copy = message.copy ?? renderConfirmation();
@@ -495,7 +474,6 @@ function telegramConfirmationEvents(archive, observed, scope) {
 					replyMarkup: { inline_keyboard: [] },
 					text
 				})));
-				remember(channel, ctx, message.messageId, text, prompt);
 			}
 			delete state.confirmationMessages?.[data.callId];
 		},

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

@@ -2,7 +2,6 @@ import type { StructuredMessage } from "./structured.js";
 import type { AgentIdentities } from "../identities.js";
 import { type Conversations } from "../conversations.js";
 import type { AgentChats } from "./chats.js";
-import type { ObservedMessages } from "./observed.js";
 import type { DecodedAttachment } from "./attachment-description.js";
 import type { AddressingReason, RouteDecider, RouteDecision } from "./router.js";
 /** A crashed routing attempt can be reclaimed; the per-message turn claim still fences dispatch. */
@@ -14,7 +13,6 @@ export declare function captureTelegramWebhook(input: {
     readonly request: Request;
     readonly archive: Conversations;
     readonly identities: AgentIdentities;
-    readonly observed: ObservedMessages;
     readonly chats?: AgentChats;
     readonly next: (request?: Request) => Promise<Response>;
 }): Promise<Response>;
@@ -22,11 +20,25 @@ export declare function captureTelegramWebhook(input: {
 export declare function recordGateDecision(reason: string, decision?: "reply" | "silent"): void;
 export declare function recordRouteDecision(route: "reply" | "observe", addressed: boolean | AddressingReason | undefined, policy: string, audit?: Pick<RouteDecision, "reason" | "note" | "diagnostics" | "router" | "shadow">): void;
 export declare function captureRouteDecider(decide: RouteDecider): RouteDecider;
+/** A stored attachment of an archived message: what a later turn needs to read or show it. */
+export interface ArchivedFile {
+    readonly id: string;
+    readonly filename: string;
+    readonly contentType: string;
+    readonly size: number;
+    readonly expiresAt: string;
+    /** Whether it can reach a model as a native image. */
+    readonly image?: true;
+}
 /** Update the existing inbound event after STT/description, under the same text retention policy. */
 export declare function recordInboundContent(content: {
     readonly text: string;
     readonly media?: string;
     readonly decoded?: ReadonlyArray<DecodedAttachment>;
+    /** How the chat context names a linked member: their name and roles, then their handle. */
+    readonly author?: string;
+    /** The message's stored attachments, by reference: never bytes or download grants. */
+    readonly files?: ReadonlyArray<ArchivedFile>;
 }): Promise<void>;
 /**
  * Records eve's unrecoverable session failure from the channel. The channel receives it even when
@@ -54,7 +66,6 @@ export declare function telegramConversationCapture(input: {
     readonly structured?: (raw: Readonly<Record<string, unknown>>) => StructuredMessage | undefined;
     readonly archive: Conversations;
     readonly identities: () => AgentIdentities;
-    readonly observed: ObservedMessages;
     readonly chats: AgentChats;
     readonly verify: (request: Request) => boolean;
 }): (request: Request, next: (request?: Request) => Promise<Response>) => Promise<Response>;

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

@@ -6,12 +6,12 @@ __eveDirname(__filename);
 __eveCreateRequire(import.meta.url);
 import { n as contentText, t as CONTENT_CAPS } from "../../../_chunks/content-cDtVnr8Y.mjs";
 import { conversationEvent, sessionFailureEventId } from "../conversations.mjs";
+import { currentDeliveryScope } from "./delivery-diagnostics.mjs";
 import { n as currentInboundRequest, p as reportTelegramError, s as currentThreadId } from "../../../_chunks/inbound-request-D1r0FkDI.mjs";
-import { currentConfirmationPrompt, observedChatKey } from "../group-routing/observed.mjs";
-import { archivedRoutingMessages } from "../group-routing/routing-context.mjs";
+import { currentConfirmationPrompt } from "../group-routing/messages.mjs";
 import { parseArchivedMessage } from "./archive-message.mjs";
 import { contentShape, messageContent } from "./content.mjs";
-import { messageMetadata } from "./observed.mjs";
+import { messageMetadata } from "./message-metadata.mjs";
 import { reportMembership } from "./membership.mjs";
 import { createHash, randomUUID } from "node:crypto";
 const captures = new WeakMap();
@@ -177,20 +177,8 @@ async function captureTelegramWebhook(input) {
 	};
 	const inbound = currentInboundRequest();
 	if (inbound !== void 0) captures.set(inbound, capture);
-	const chat = observedChatKey({
-		chatId: message.chat.id,
-		...message.messageThreadId === void 0 ? {} : { messageThreadId: message.messageThreadId }
-	});
 	const automated = message.from === void 0 || message.from.isBot || message.chat.type === "channel";
 	if (automated || edited !== void 0 || message.raw.left_chat_member || message.raw.migrate_to_chat_id || message.raw.migrate_from_chat_id) await capture.persist();
-	const history = automated ? void 0 : await input.archive.context({
-		provider: "telegram",
-		chatId: message.chat.id,
-		...event.threadId === null ? {} : { threadId: event.threadId },
-		limit: 100,
-		includeDecisions: true,
-		...lookup?.status === "paired" ? { participantId: lookup.member.id } : {}
-	});
 	const messageHistory = automated ? [] : (await input.archive.context({
 		provider: "telegram",
 		chatId: message.chat.id,
@@ -265,35 +253,16 @@ async function captureTelegramWebhook(input) {
 			await recordInboundContent({
 				text: [content.text, ...transcripts].filter(Boolean).join("\n\n"),
 				decoded,
-				...media === void 0 ? {} : { media }
+				...media === void 0 ? {} : { media },
+				...Array.isArray(previousRouting.files) ? { files: previousRouting.files } : {}
 			});
 		}
 	}
-	if (!automated) for (const earlier of input.observed.recent(chat).length === 0 ? archivedRoutingMessages((history?.events ?? []).filter((item) => item.eventId !== event.eventId), 60) : []) if ("role" in earlier || history?.events.some((decision) => decision.kind === "decision" && decision.messageId === earlier.messageId && decision.reason === "turn_admitted")) input.observed.remember(chat, earlier);
-	else input.observed.add(chat, earlier);
 	if (automated || edited !== void 0) {
 		if (message.chat.type === "group" || message.chat.type === "supergroup") await input.chats?.seen({
 			chatId: message.chat.id,
 			title: message.chat.title ?? ""
 		});
-		const remembered = input.observed.recent(chat).findLast((entry) => entry.messageId === message.messageId);
-		const retained = alreadyHandled && edited === void 0 ? remembered : void 0;
-		const retainedContent = archivedRoutingMessages([{
-			...capture.event,
-			sequence: "1",
-			storedAt: event.at
-		}])[0];
-		input.observed.add(chat, retained ?? (retainedContent === void 0 ? void 0 : {
-			...retainedContent,
-			...unchangedAttachments && remembered?.images !== void 0 ? { images: remembered.images } : {}
-		}) ?? {
-			...messageMetadata(message),
-			author: event.senderName ?? event.senderId ?? "automated post",
-			text: event.text ?? "[attachment or service message]",
-			at: event.at,
-			messageId: message.messageId,
-			...event.senderId === null ? {} : { authorId: event.senderId }
-		});
 		capture.decision = "silent";
 		capture.reason = automated ? "automated_or_channel_message" : alreadyHandled ? "message_already_handled" : "message_edit";
 		if (alreadyHandled) capture.note = "This message already started a turn; edits and retries do not repeat its task.";
@@ -495,7 +464,9 @@ async function recordInboundContent(content) {
 	await capture.persist();
 	const metadata = record(JSON.parse(capture.event.argsSummary ?? "{}"));
 	const membership = capture.lookup === void 0 ? record(metadata.routing).membership : capture.lookup.status === "paired" || capture.lookup.status === "existing" || capture.lookup.status === "created" ? "linked" : "unlinked";
-	if (content.text === capture.event.text && content.media === record(metadata.routing).media && membership === record(metadata.routing).membership && JSON.stringify(content.decoded) === JSON.stringify(record(metadata.routing).decoded)) return;
+	const author = content.author ?? record(metadata.routing).author;
+	const files = content.files ?? record(metadata.routing).files;
+	if (content.text === capture.event.text && content.media === record(metadata.routing).media && membership === record(metadata.routing).membership && author === record(metadata.routing).author && JSON.stringify(files) === JSON.stringify(record(metadata.routing).files) && JSON.stringify(content.decoded) === JSON.stringify(record(metadata.routing).decoded)) return;
 	const contentHash = createHash("sha256").update(JSON.stringify({
 		...content,
 		membership
@@ -509,6 +480,8 @@ async function recordInboundContent(content) {
 			routing: {
 				...record(metadata.routing),
 				membership,
+				...typeof author === "string" ? { author: author.slice(0, 500) } : {},
+				...Array.isArray(files) && files.length > 0 ? { files: files.slice(0, 10) } : {},
 				media: content.media?.slice(0, 8e3),
 				decoded: content.decoded
 			}
@@ -582,6 +555,8 @@ function captureTelegramFetch(fetchImpl, archive, identities) {
 		const chatId = id(body.chat_id);
 		if (chatId === null) return fetchImpl(input, init);
 		const { capture, chatType, participantIds } = await outboundAudience(chatId, identities);
+		const delivery = currentDeliveryScope();
+		const own = delivery?.chatId === chatId && delivery.sessionId !== null;
 		const event = conversationEvent({
 			eventId: `telegram:${edit ? "edit" : "send"}:${randomUUID()}`,
 			provider: "telegram",
@@ -620,6 +595,10 @@ function captureTelegramFetch(fetchImpl, archive, identities) {
 			participantIds,
 			threadId: id(body.message_thread_id) ?? currentThreadId() ?? null,
 			replyToMessageId: id(body.reply_to_message_id) ?? id(record(body.reply_parameters).message_id),
+			...own ? {
+				sessionId: delivery.sessionId,
+				turnId: delivery.turnId
+			} : {},
 			status: "requested"
 		});
 		await archive.append(event);

package/dist/extension/lib/telegram/delivery-diagnostics.d.ts

@@ -5,8 +5,11 @@ interface Diagnostic {
     readonly error: unknown;
     readonly metadata: Record<string, unknown>;
 }
+type DeliveryScope = Pick<ConversationEvent, "chatId" | "chatType" | "threadId" | "sessionId" | "turnId">;
 /** Receives the same credential-redacted payload as operator logs, never raw provider errors. */
 export declare function retainDeliveryDiagnostic(diagnostic: Diagnostic): void;
+/** The session and turn a channel callback delivers for, so its sends are archived as its own. */
+export declare function currentDeliveryScope(): DeliveryScope | undefined;
 /** Await archive writes inside the channel callback, including failed or restored callbacks. */
-export declare function withDeliveryDiagnostics<T>(archive: Conversations, scope: Pick<ConversationEvent, "chatId" | "chatType" | "threadId" | "sessionId" | "turnId">, run: () => T | Promise<T>): Promise<T>;
+export declare function withDeliveryDiagnostics<T>(archive: Conversations, scope: DeliveryScope, run: () => T | Promise<T>): Promise<T>;
 export {};

package/dist/extension/lib/telegram/delivery-diagnostics.mjs

@@ -10,11 +10,17 @@ import { conversationEvent } from "../conversations.mjs";
 import { AsyncLocalStorage } from "node:async_hooks";
 const pending = new AsyncLocalStorage();
 function retainDeliveryDiagnostic(diagnostic) {
-	pending.getStore()?.push(diagnostic);
+	pending.getStore()?.diagnostics.push(diagnostic);
+}
+function currentDeliveryScope() {
+	return pending.getStore()?.scope;
 }
 async function withDeliveryDiagnostics(archive, scope, run) {
 	const diagnostics = [];
-	return pending.run(diagnostics, async () => {
+	return pending.run({
+		diagnostics,
+		scope
+	}, async () => {
 		try {
 			return await run();
 		} finally {
@@ -43,4 +49,4 @@ async function withDeliveryDiagnostics(archive, scope, run) {
 		}
 	});
 }
-export { retainDeliveryDiagnostic, withDeliveryDiagnostics };
+export { currentDeliveryScope, retainDeliveryDiagnostic, withDeliveryDiagnostics };

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

@@ -5,7 +5,7 @@ const __filename = __eveFileURLToPath(import.meta.url);
 __eveDirname(__filename);
 __eveCreateRequire(import.meta.url);
 import { runtimeRequestFailure } from "./runtime-request.mjs";
-import { t as agentBuild } from "../../../_chunks/build-metadata-D_Gqlb5f.mjs";
+import { t as agentBuild } from "../../../_chunks/build-metadata-CMmCRD8l.mjs";
 import { GET } from "eve/channels";
 const HEALTH_ROUTE = "/eve/v1/telegram/health";
 function healthRoute(input) {