@segmentstream/agent 0.16.0 → 0.16.1

package/README.md

@@ -549,7 +549,7 @@ Eve resolution, so member/topic routing survives a cold start. No second provide
 
 ## Release and migration
 
-The coordinated release uses Agent SDK 0.16.0, Eve 0.76.3, Ontology SDK 0.52.0 and App SDK 0.25.0.
+The coordinated release uses Agent SDK 0.16.1, Eve 0.76.3, Ontology SDK 0.52.0 and App SDK 0.25.0.
 The compatible Cloud archive/API must be deployed first; migrations run only through its CI/CD gate.
 Publish the ontology SDK before the agent SDK. Upgrade the workspace ontology before its agent,
 with the declared Telegram provider mapping and explicit `agent_chat:post_message` grant.

package/dist/_chunks/{build-metadata-CIFPiRho.mjs → build-metadata-CsawQFEV.mjs}

@@ -4,7 +4,7 @@ import { createRequire as __eveCreateRequire } from "node:module";
 const __filename = __eveFileURLToPath(import.meta.url);
 __eveDirname(__filename);
 __eveCreateRequire(import.meta.url);
-var version = "0.16.0";
+var version = "0.16.1";
 function agentBuild(environment = process.env) {
 	return {
 		agent: version,

package/dist/extension/lib/build-metadata.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 { t as agentBuild } from "../../_chunks/build-metadata-CIFPiRho.mjs";
+import { t as agentBuild } from "../../_chunks/build-metadata-CsawQFEV.mjs";
 export { agentBuild };

package/dist/extension/lib/conversation-runtime.d.ts

@@ -14,6 +14,10 @@ export declare function conversationCoordinates(context: {
     participantIds: string[];
     senderId: string | null;
 } | undefined;
-/** eve event hooks run after its durable event write. IDs make platform writes replay-safe. */
+/**
+ * eve event hooks run after its durable event write. IDs make platform writes replay-safe.
+ * eve 0.76.3 catches a throwing hook and logs it as `[eve:hooks] stream event hook failed`
+ * with the session, event type and full error, so archive failures propagate unwrapped.
+ */
 export declare function conversationRecorder(archive?: Conversations, closing?: (message: string, model: string) => Promise<number>): (event: HookEvent, context: HookContext) => Promise<void>;
 export {};

package/dist/extension/lib/conversation-runtime.mjs

@@ -7,7 +7,7 @@ __eveCreateRequire(import.meta.url);
 import { ENDS_CONVERSATION_INSTRUCTIONS } from "./group-routing/conversation-prompt.mjs";
 import { i as memberIdOf } from "../../_chunks/principal-MEMlG3EG.mjs";
 import { n as contentText, t as CONTENT_CAPS } from "../../_chunks/content-CvFsrmSD.mjs";
-import { conversationEvent, conversations, summarizeArguments } from "./conversations.mjs";
+import { conversationEvent, conversations, sessionFailureEventId, summarizeArguments } from "./conversations.mjs";
 import { parseAddress } from "./telegram/sessions.mjs";
 import { completionKind } from "./telegram/silent.mjs";
 import { decide } from "eve/ai";
@@ -33,6 +33,29 @@ function conversationCoordinates(context) {
 		senderId: principal?.subject ?? null
 	};
 }
+const UNADDRESSED_SESSIONS_REMEMBERED = 1e3;
+function reportUnaddressed(event, context, reported) {
+	const sessionId = context.session.id;
+	const fields = {
+		sessionId,
+		eventType: event.type,
+		channelKind: context.channel.kind ?? null,
+		hasContinuationToken: Boolean(context.channel.continuationToken),
+		authenticator: context.session.auth.current?.authenticator ?? null
+	};
+	if (event.type === "turn.failed" || event.type === "step.failed" || event.type === "session.failed") {
+		console.error("[segmentstream] agent log dropped unaddressed failure", {
+			...fields,
+			code: event.data.code,
+			message: contentText(event.data.message, CONTENT_CAPS.error)
+		});
+		return;
+	}
+	if (reported.has(sessionId)) return;
+	if (reported.size >= UNADDRESSED_SESSIONS_REMEMBERED) reported.delete(reported.values().next().value);
+	reported.add(sessionId);
+	console.warn("[segmentstream] agent log dropped unaddressed session events", fields);
+}
 function conversationRecorder(archive = conversations(), closing = async (message, model) => {
 	return (await decide({
 		model,
@@ -45,9 +68,13 @@ function conversationRecorder(archive = conversations(), closing = async (messag
 		maxRetries: 0
 	})).answers.ends_conversation.probability;
 }) {
+	const unaddressed = new Set();
 	return async (event, context) => {
 		const coordinates = conversationCoordinates(context);
-		if (coordinates === void 0) return;
+		if (coordinates === void 0) {
+			reportUnaddressed(event, context, unaddressed);
+			return;
+		}
 		const base = {
 			...coordinates,
 			sessionId: context.session.id,
@@ -94,10 +121,9 @@ function conversationRecorder(archive = conversations(), closing = async (messag
 			} : {},
 			status: event.type === "task.started" ? "requested" : event.data.status === "cancelled" ? "cancelled" : event.data.status === "failed" ? "failed" : "completed"
 		}));
-		else if (event.type === "turn.failed" || event.type === "step.failed") await archive.append(conversationEvent({
+		else if (event.type === "turn.failed" || event.type === "step.failed" || event.type === "session.failed") await archive.append(conversationEvent({
 			...base,
-			turnId: event.data.turnId,
-			eventId,
+			eventId: event.type === "session.failed" ? sessionFailureEventId(context.session.id) : eventId,
 			kind: "decision",
 			decision: "silent",
 			reason: event.type,

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

@@ -73,6 +73,12 @@ export interface Conversations {
 }
 /** Collapse delivery snapshots from older archives before building a user/model transcript. */
 export declare function collapseConversationEvents(events: ConversationPage["events"]): ConversationPage["events"];
+/**
+ * eve's terminal session failure reaches the channel adapter unstamped, so its event ID is not
+ * available there; a session fails terminally once. The hook recorder and the channel both use
+ * this ID, and the archive's idempotent append keeps whichever arrives first.
+ */
+export declare function sessionFailureEventId(sessionId: string): string;
 export declare function conversationEvent(input: Pick<ConversationEvent, "eventId" | "provider" | "chatId" | "chatType" | "kind"> & Partial<ConversationEvent>): ConversationEvent;
 export declare function conversations(input?: {
     readonly environment?: Environment;

package/dist/extension/lib/conversations.mjs

@@ -20,6 +20,9 @@ function collapseConversationEvents(events) {
 	}
 	return [...latest.values()];
 }
+function sessionFailureEventId(sessionId) {
+	return `eve:${sessionId}:session.failed`;
+}
 function conversationEvent(input) {
 	return workflowValue({
 		threadId: null,
@@ -137,4 +140,4 @@ async function storedConversationContext(archive, coordinates) {
 		JSON.stringify(selected.reverse())
 	].join("\n");
 }
-export { collapseConversationEvents, conversationEvent, conversations, storedConversationContext, summarizeArguments };
+export { collapseConversationEvents, conversationEvent, conversations, sessionFailureEventId, storedConversationContext, summarizeArguments };

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

@@ -20,7 +20,7 @@ import { archivedRoutingMessages } from "../group-routing/routing-context.mjs";
 import { dispatchStructuredMessage, structuredMessage } from "./structured.mjs";
 import { scopedAddress, sessionPolicy } from "./sessions.mjs";
 import { handleWorkspaceCallback, isWorkspaceCallback } from "./callbacks.mjs";
-import { t as agentBuild } from "../../../_chunks/build-metadata-CIFPiRho.mjs";
+import { t as agentBuild } from "../../../_chunks/build-metadata-CsawQFEV.mjs";
 import { attachmentLifecycle } from "./lifecycle.mjs";
 import { observedMessages } from "./observed.mjs";
 import { expireDeferredCards, handleDeferredCallback, isDeferredCallback } from "./deferred-confirmations.mjs";
@@ -372,7 +372,10 @@ function segmentstreamTelegram(options) {
 			}
 		},
 		events: {
-			...telegramFailureEvents,
+			...telegramFailureEvents({
+				archive,
+				identities: pairing
+			}),
 			...telegramConfirmationEvents(archive, observed, {
 				environment,
 				token,

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

@@ -28,6 +28,22 @@ export declare function recordInboundContent(content: {
     readonly media?: string;
     readonly decoded?: ReadonlyArray<DecodedAttachment>;
 }): Promise<void>;
+/**
+ * Records eve's unrecoverable session failure from the channel. The channel receives it even when
+ * eve publishes it after its workflow loop throws, which runs no hooks. Never throws, so the
+ * member's notice never depends on the archive.
+ */
+export declare function recordSessionFailure(input: {
+    readonly archive: Conversations;
+    readonly identities: () => AgentIdentities;
+    readonly chatId: string | null;
+    readonly threadId: string | null;
+    readonly failure: {
+        readonly code: string;
+        readonly message: string;
+        readonly sessionId: string;
+    };
+}): Promise<void>;
 /** Captures message sends and button/status edits, including pairing and proactive replies. */
 export declare function captureTelegramFetch(fetchImpl: typeof fetch, archive: Conversations, identities: () => AgentIdentities): typeof fetch;
 /** Reuses the request's verified lookup; it never survives into another inbound request. */

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

@@ -5,8 +5,9 @@ const __filename = __eveFileURLToPath(import.meta.url);
 __eveDirname(__filename);
 __eveCreateRequire(import.meta.url);
 import { n as currentInboundRequest, p as reportTelegramError, s as currentThreadId } from "../../../_chunks/inbound-request-RIRNBxUC.mjs";
+import { n as contentText, t as CONTENT_CAPS } from "../../../_chunks/content-CvFsrmSD.mjs";
 import { currentConfirmationPrompt, observedChatKey } from "../group-routing/observed.mjs";
-import { conversationEvent } from "../conversations.mjs";
+import { conversationEvent, sessionFailureEventId } from "../conversations.mjs";
 import { archivedRoutingMessages } from "../group-routing/routing-context.mjs";
 import { contentShape, messageContent } from "./content.mjs";
 import { messageMetadata } from "./observed.mjs";
@@ -517,6 +518,62 @@ async function recordInboundContent(content) {
 	await capture.archive.append(event);
 	capture.event = event;
 }
+async function outboundAudience(chatId, identities) {
+	const inbound = currentInboundRequest();
+	const capture = inbound === void 0 ? void 0 : captures.get(inbound);
+	let participantIds = capture?.event.participantIds ?? [];
+	const chatType = capture?.event.chatType ?? (chatId.startsWith("-") ? "group" : "private");
+	if (chatType === "private" && participantIds.length === 0 && capture === void 0) try {
+		const lookup = await identities().lookup({
+			provider: "telegram",
+			externalId: chatId
+		});
+		if (lookup.status === "paired") participantIds = [lookup.member.id];
+	} catch (error) {
+		console.error("[segmentstream] outbound participant lookup failed", { error });
+	}
+	return {
+		capture,
+		chatType,
+		participantIds
+	};
+}
+async function recordSessionFailure(input) {
+	const { failure } = input;
+	const sessionId = failure.sessionId === "" ? null : failure.sessionId;
+	try {
+		const errorText = contentText(failure.message, CONTENT_CAPS.error);
+		if (input.chatId === null) {
+			console.error("[segmentstream] agent log dropped unaddressed failure", {
+				sessionId,
+				eventType: "session.failed",
+				code: failure.code,
+				message: errorText
+			});
+			return;
+		}
+		const { chatType, participantIds } = await outboundAudience(input.chatId, input.identities);
+		await input.archive.append(conversationEvent({
+			eventId: sessionId === null ? `eve:session.failed:${randomUUID()}` : sessionFailureEventId(sessionId),
+			provider: "telegram",
+			chatId: input.chatId,
+			chatType,
+			threadId: input.threadId,
+			participantIds,
+			sessionId,
+			kind: "decision",
+			decision: "silent",
+			reason: "session.failed",
+			status: "failed",
+			errorText
+		}));
+	} catch (error) {
+		console.error("[segmentstream] recording session failure failed", {
+			sessionId,
+			error
+		});
+	}
+}
 function captureTelegramFetch(fetchImpl, archive, identities) {
 	return async (input, init) => {
 		const url = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
@@ -525,19 +582,7 @@ function captureTelegramFetch(fetchImpl, archive, identities) {
 		const body = record(JSON.parse(init.body));
 		const chatId = id(body.chat_id);
 		if (chatId === null) return fetchImpl(input, init);
-		const inbound = currentInboundRequest();
-		const capture = inbound === void 0 ? void 0 : captures.get(inbound);
-		let participantIds = capture?.event.participantIds ?? [];
-		const chatType = capture?.event.chatType ?? (chatId.startsWith("-") ? "group" : "private");
-		if (chatType === "private" && participantIds.length === 0 && capture === void 0) try {
-			const lookup = await identities().lookup({
-				provider: "telegram",
-				externalId: chatId
-			});
-			if (lookup.status === "paired") participantIds = [lookup.member.id];
-		} catch (error) {
-			console.error("[segmentstream] outbound participant lookup failed", { error });
-		}
+		const { capture, chatType, participantIds } = await outboundAudience(chatId, identities);
 		const event = conversationEvent({
 			eventId: `telegram:${edit ? "edit" : "send"}:${randomUUID()}`,
 			provider: "telegram",
@@ -681,4 +726,4 @@ function telegramConversationCapture(input) {
 		}
 	};
 }
-export { REVISION_CLAIM_TTL_MS, captureRouteDecider, captureTelegramFetch, captureTelegramWebhook, conversationIdentities, recordGateDecision, recordInboundContent, recordRouteDecision, telegramConversationCapture };
+export { REVISION_CLAIM_TTL_MS, captureRouteDecider, captureTelegramFetch, captureTelegramWebhook, conversationIdentities, recordGateDecision, recordInboundContent, recordRouteDecision, recordSessionFailure, telegramConversationCapture };

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

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

@@ -9,7 +9,7 @@ import { object } from "../confirmation-description.mjs";
 import { n as currentInboundRequest, p as reportTelegramError } from "../../../_chunks/inbound-request-RIRNBxUC.mjs";
 import { needsConfirmation } from "../confirmations.mjs";
 import { OntologyActionNotPermitted, actionToolName, ontologyTools } from "../ontology-tools.mjs";
-import { t as agentBuild } from "../../../_chunks/build-metadata-CIFPiRho.mjs";
+import { t as agentBuild } from "../../../_chunks/build-metadata-CsawQFEV.mjs";
 var AttachmentLifecycleNotPermitted = class extends Error {
 	code = "attachment_lifecycle_not_permitted";
 };

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

@@ -1,2 +1,8 @@
 import type { TelegramChannelEvents } from "eve/channels/telegram";
-export declare const telegramFailureEvents: Pick<TelegramChannelEvents, "turn.failed" | "turn.cancelled" | "session.failed" | "authorization.completed" | "authorization.required">;
+import type { Conversations } from "../conversations.js";
+import type { AgentIdentities } from "../identities.js";
+/** Failure notices for members; an unrecoverable session failure is also recorded to the archive. */
+export declare function telegramFailureEvents(input: {
+    readonly archive: Conversations;
+    readonly identities: () => AgentIdentities;
+}): Pick<TelegramChannelEvents, "turn.failed" | "turn.cancelled" | "session.failed" | "authorization.completed" | "authorization.required">;

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

@@ -7,82 +7,95 @@ __eveCreateRequire(import.meta.url);
 import { telegramText } from "./texts.mjs";
 import { i as memberIdOf } from "../../../_chunks/principal-MEMlG3EG.mjs";
 import { confirmationLocale } from "./confirmation-text.mjs";
-import { c as customerCopy, d as failureText, o as currentLocale, p as reportTelegramError } from "../../../_chunks/inbound-request-RIRNBxUC.mjs";
-const telegramFailureEvents = {
-	async "authorization.required"(event, channel, context) {
-		if (event.candidateId !== void 0) return;
-		const locale = confirmationLocale(context.session.auth.current, currentLocale());
-		const prompt = telegramText("authorization", "prompt", locale);
-		const url = telegramText("authorization", "url", locale);
-		const button = telegramText("authorization", "button", locale);
-		if (prompt !== void 0) {
-			const sent = await channel.telegram.post({
-				text: prompt,
-				...url === void 0 || button === void 0 ? {} : { reply_markup: { inline_keyboard: [[{
-					text: button,
-					url
-				}]] } }
+import { c as customerCopy, d as failureText, o as currentLocale, p as reportTelegramError, s as currentThreadId } from "../../../_chunks/inbound-request-RIRNBxUC.mjs";
+import { recordSessionFailure } from "./conversations.mjs";
+function telegramFailureEvents(input) {
+	return {
+		async "authorization.required"(event, channel, context) {
+			if (event.candidateId !== void 0) return;
+			const locale = confirmationLocale(context.session.auth.current, currentLocale());
+			const prompt = telegramText("authorization", "prompt", locale);
+			const url = telegramText("authorization", "url", locale);
+			const button = telegramText("authorization", "button", locale);
+			if (prompt !== void 0) {
+				const sent = await channel.telegram.post({
+					text: prompt,
+					...url === void 0 || button === void 0 ? {} : { reply_markup: { inline_keyboard: [[{
+						text: button,
+						url
+					}]] } }
+				});
+				if (sent.id) channel.state.pendingAuthMessageIds = {
+					...channel.state.pendingAuthMessageIds,
+					[event.name]: sent.id
+				};
+				return;
+			}
+			const state = channel.state;
+			state.authorizationCancellationTurnId = event.turnId;
+			const errorId = reportTelegramError("authorization_prompt_unconfigured", new Error("texts.authorization.prompt is not configured."), { sessionId: context.session.id });
+			await channel.telegram.post(failureText(errorId, "authorization", locale));
+		},
+		async "turn.cancelled"(event, channel, context) {
+			const state = channel.state;
+			const authorizationTurn = state.authorizationCancellationTurnId;
+			delete state.authorizationCancellationTurnId;
+			if (typeof event.turnId === "string" && authorizationTurn === event.turnId) return;
+			const errorId = reportTelegramError("turn_cancelled", event, {
+				chatId: channel.state.chatId,
+				sessionId: context.session.id,
+				turnId: event.turnId
 			});
-			if (sent.id) channel.state.pendingAuthMessageIds = {
-				...channel.state.pendingAuthMessageIds,
-				[event.name]: sent.id
-			};
-			return;
-		}
-		const state = channel.state;
-		state.authorizationCancellationTurnId = event.turnId;
-		const errorId = reportTelegramError("authorization_prompt_unconfigured", new Error("texts.authorization.prompt is not configured."), { sessionId: context.session.id });
-		await channel.telegram.post(failureText(errorId, "authorization", locale));
-	},
-	async "turn.cancelled"(event, channel, context) {
-		const state = channel.state;
-		const authorizationTurn = state.authorizationCancellationTurnId;
-		delete state.authorizationCancellationTurnId;
-		if (typeof event.turnId === "string" && authorizationTurn === event.turnId) return;
-		const errorId = reportTelegramError("turn_cancelled", event, {
-			chatId: channel.state.chatId,
-			sessionId: context.session.id,
-			turnId: event.turnId
-		});
-		await channel.telegram.post(failureText(errorId, "cancelled", confirmationLocale(context.session.auth.current, currentLocale())));
-	},
-	async "turn.failed"(event, channel, context) {
-		const errorId = reportTelegramError("turn_failed", event, {
-			chatId: channel.state.chatId,
-			memberId: memberIdOf(context.session.auth.current) ?? null,
-			sessionId: context.session.id,
-			turnId: event.turnId
-		});
-		await channel.telegram.post(failureText(errorId, "failed", confirmationLocale(context.session.auth.current, currentLocale())));
-	},
-	async "session.failed"(event, channel) {
-		const errorId = reportTelegramError("session_recovery_failed", event, {
-			chatId: channel.state.chatId,
-			sessionId: event.sessionId
-		});
-		const locale = channel.state.customerLocale ?? "en";
-		await channel.telegram.post(failureText(errorId, "recovery", locale));
-	},
-	async "authorization.completed"(event, channel, context) {
-		const messageId = channel.state.pendingAuthMessageIds?.[event.name];
-		if (event.candidateId !== void 0 || messageId === void 0) return;
-		const locale = confirmationLocale(context.session.auth.current);
-		const copy = customerCopy(locale);
-		let text = event.outcome === "authorized" ? copy.connected : copy.disconnected;
-		if (event.reason !== void 0) {
-			const errorId = reportTelegramError("authorization_not_completed", event, { chatId: channel.state.chatId });
-			text = failureText(errorId, "authorization", locale);
+			await channel.telegram.post(failureText(errorId, "cancelled", confirmationLocale(context.session.auth.current, currentLocale())));
+		},
+		async "turn.failed"(event, channel, context) {
+			const errorId = reportTelegramError("turn_failed", event, {
+				chatId: channel.state.chatId,
+				memberId: memberIdOf(context.session.auth.current) ?? null,
+				sessionId: context.session.id,
+				turnId: event.turnId
+			});
+			await channel.telegram.post(failureText(errorId, "failed", confirmationLocale(context.session.auth.current, currentLocale())));
+		},
+		async "session.failed"(event, channel) {
+			const errorId = reportTelegramError("session_recovery_failed", event, {
+				chatId: channel.state.chatId,
+				sessionId: event.sessionId
+			});
+			const locale = channel.state.customerLocale ?? "en";
+			const recorded = recordSessionFailure({
+				...input,
+				chatId: channel.state.chatId,
+				threadId: typeof channel.state.messageThreadId === "number" ? String(channel.state.messageThreadId) : currentThreadId() ?? null,
+				failure: event
+			});
+			try {
+				await channel.telegram.post(failureText(errorId, "recovery", locale));
+			} finally {
+				await recorded;
+			}
+		},
+		async "authorization.completed"(event, channel, context) {
+			const messageId = channel.state.pendingAuthMessageIds?.[event.name];
+			if (event.candidateId !== void 0 || messageId === void 0) return;
+			const locale = confirmationLocale(context.session.auth.current);
+			const copy = customerCopy(locale);
+			let text = event.outcome === "authorized" ? copy.connected : copy.disconnected;
+			if (event.reason !== void 0) {
+				const errorId = reportTelegramError("authorization_not_completed", event, { chatId: channel.state.chatId });
+				text = failureText(errorId, "authorization", locale);
+			}
+			if (text !== void 0) await channel.telegram.editMessageText({
+				messageId,
+				text,
+				replyMarkup: { inline_keyboard: [] }
+			});
+			else await channel.telegram.editMessageReplyMarkup({
+				messageId,
+				replyMarkup: { inline_keyboard: [] }
+			});
+			delete channel.state.pendingAuthMessageIds?.[event.name];
 		}
-		if (text !== void 0) await channel.telegram.editMessageText({
-			messageId,
-			text,
-			replyMarkup: { inline_keyboard: [] }
-		});
-		else await channel.telegram.editMessageReplyMarkup({
-			messageId,
-			replyMarkup: { inline_keyboard: [] }
-		});
-		delete channel.state.pendingAuthMessageIds?.[event.name];
-	}
-};
+	};
+}
 export { telegramFailureEvents };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@segmentstream/agent",
-  "version": "0.16.0",
+  "version": "0.16.1",
   "description": "Mount a SegmentStream workspace's agent on eve: the ontology as tools, acting as the member who writes, and Telegram through the workspace's connection.",
   "license": "Apache-2.0",
   "author": "SegmentStream",