@segmentstream/agent 0.16.0 → 0.17.0

package/dist/extension/lib/sandbox-session.d.ts

@@ -0,0 +1,104 @@
+import { type StateHandle } from "eve/context";
+import type { RuntimeSandboxSession, SandboxSession } from "eve/sandbox";
+/**
+ * The SDK's side of a session's sandbox (`docs/agent.md`, "Sandbox"): the marker its selector
+ * writes, the session state recording when it opened, the gate every file tool passes and the
+ * cleanup. eve cannot say which environment a session's sandbox came from without opening it, and
+ * the configured environment object need not survive bundling, so the SDK's selector writes a
+ * marker into the sandbox it opens and the tools refuse a sandbox without one. The marker guards
+ * against a missing or replaced `agent/agent/sandbox.ts`; it is not a boundary against the model,
+ * which can only reach the sandbox after the gate has passed.
+ */
+/** Where the SDK's selector records that it opened the sandbox. */
+export declare const SANDBOX_MARKER_PATH = "/workspace/.segmentstream/sandbox.json";
+/** Where eve stages the files that reach the model (`eve/docs/sandbox`, "Inbound attachments"). */
+export declare const SANDBOX_ATTACHMENTS_DIRECTORY = "/workspace/.eve/attachments";
+/** A sandbox older than this is replaced on its first file-tool use in a turn. */
+export declare const SANDBOX_MAXIMUM_AGE_MS: number;
+/** What a replacement carries over of the attachments staged within the last day. */
+export declare const CARRIED_ATTACHMENTS: {
+    readonly files: 32;
+    readonly bytes: number;
+};
+export interface SandboxMarker {
+    readonly version: 1;
+    readonly sessionId: string;
+    /** When the selector opened the sandbox, as an ISO timestamp. */
+    readonly openedAt: string;
+    /** The toolset version the environment's snapshot was prepared with. */
+    readonly toolset: string;
+    readonly network: "deny-all";
+}
+/** What the session remembers about its sandbox, so cleanup never opens one just to delete it. */
+export interface SandboxRecord {
+    readonly openedAt: string;
+    /** The turn whose first file-tool call last passed the gate. */
+    readonly checkedTurn?: string;
+}
+export declare const sandboxRecord: StateHandle<SandboxRecord | null>;
+/** The session's sandbox did not come from `@segmentstream/agent/sandbox`; the tools fail closed. */
+export declare class SandboxUnavailableError extends Error {
+    readonly name = "SandboxUnavailableError";
+}
+/** The part of an eve tool or hook context the sandbox functions use. */
+export interface SandboxContext {
+    readonly session: {
+        readonly id: string;
+        readonly turn: {
+            readonly id: string;
+        };
+    };
+    getSandbox(): Promise<RuntimeSandboxSession>;
+}
+/** Parses a marker file; `undefined` for anything the SDK's selector would not have written. */
+export declare function parseSandboxMarker(bytes: Uint8Array | null): SandboxMarker | undefined;
+/**
+ * Initializes a sandbox the SDK's selector just opened: writes the marker and records the opening
+ * in session state. Outside an eve step there is no session state; the marker still gates the
+ * tools and the age check still runs on first use.
+ */
+export declare function initializeSandbox(sandbox: SandboxSession, input: {
+    readonly sessionId: string;
+    readonly toolset: string;
+    readonly now?: Date;
+    readonly record?: StateHandle<SandboxRecord | null>;
+}): Promise<SandboxMarker>;
+/**
+ * The session's sandbox, once it has passed the gate: it must carry the SDK's marker for this
+ * session, so the file tools never run in eve's default sandbox, whose network is open. The first
+ * call in each turn checks the marker; a sandbox older than a day is deleted through its handle
+ * and reopened, carrying over the attachments staged within the last day so that the files of the
+ * current turn stay where eve's references point.
+ */
+export declare function sessionSandbox(context: SandboxContext, options?: {
+    readonly now?: number;
+    readonly record?: StateHandle<SandboxRecord | null>;
+}): Promise<RuntimeSandboxSession>;
+/** A file from the sandbox, as the platform stores it. */
+export interface SandboxFile {
+    /** Its real path, with symbolic links resolved. */
+    readonly path: string;
+    readonly filename: string;
+    readonly content: Uint8Array;
+}
+/** The named path is not a file the platform takes from the sandbox; the message says why. */
+export declare class SandboxFileRefused extends TypeError {
+}
+/** The named file is larger than the caller allows. */
+export declare class SandboxFileTooLarge extends RangeError {
+}
+/**
+ * Reads a file the model names in the session's sandbox, after the gate. Its real path must stay
+ * inside `/workspace`, so a symbolic link cannot hand the platform a file from elsewhere in the
+ * machine, and it must be a non-empty regular file of at most `maximumBytes`.
+ */
+export declare function sandboxFile(context: SandboxContext, path: string, options: {
+    readonly maximumBytes: number;
+    readonly now?: number;
+    readonly record?: StateHandle<SandboxRecord | null>;
+}): Promise<SandboxFile>;
+/**
+ * Deletes the session's sandbox when the session recorded one, such as when its history is
+ * cleared. Without a record it does nothing: asking eve for the sandbox would open one.
+ */
+export declare function releaseSandbox(context: Pick<SandboxContext, "getSandbox">, record?: StateHandle<SandboxRecord | null>): Promise<boolean>;

package/dist/extension/lib/sandbox-session.mjs

@@ -0,0 +1,142 @@
+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 { posix } from "node:path";
+import { defineState } from "eve/context";
+const SANDBOX_MARKER_PATH = "/workspace/.segmentstream/sandbox.json";
+const SANDBOX_ATTACHMENTS_DIRECTORY = "/workspace/.eve/attachments";
+const SANDBOX_MAXIMUM_AGE_MS = 864e5;
+const CARRIED_ATTACHMENTS = {
+	files: 32,
+	bytes: 67108864
+};
+const STAGED_PATH = /^\/workspace\/\.eve\/attachments\/[0-9a-f]{16}\/[\w.-]+$/;
+const sandboxRecord = defineState("segmentstream.sandbox", () => null);
+var SandboxUnavailableError = class extends Error {
+	name = "SandboxUnavailableError";
+};
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseSandboxMarker(bytes) {
+	if (bytes === null) return;
+	let value;
+	try {
+		value = JSON.parse(Buffer.from(bytes).toString("utf8"));
+	} catch {
+		return;
+	}
+	return isRecord(value) && value.version === 1 && typeof value.sessionId === "string" && value.sessionId !== "" && typeof value.openedAt === "string" && !Number.isNaN(Date.parse(value.openedAt)) && typeof value.toolset === "string" && value.toolset !== "" && value.network === "deny-all" ? {
+		version: 1,
+		sessionId: value.sessionId,
+		openedAt: value.openedAt,
+		toolset: value.toolset,
+		network: "deny-all"
+	} : void 0;
+}
+async function initializeSandbox(sandbox, input) {
+	const marker = {
+		version: 1,
+		sessionId: input.sessionId,
+		openedAt: (input.now ?? new Date()).toISOString(),
+		toolset: input.toolset,
+		network: "deny-all"
+	};
+	await sandbox.writeTextFile({
+		path: SANDBOX_MARKER_PATH,
+		content: `${JSON.stringify(marker)}\n`
+	});
+	try {
+		(input.record ?? sandboxRecord).update(() => ({ openedAt: marker.openedAt }));
+	} catch {}
+	return marker;
+}
+async function verifiedMarker(sandbox, sessionId) {
+	const marker = parseSandboxMarker(await sandbox.readBinaryFile({ path: SANDBOX_MARKER_PATH }));
+	if (marker === void 0 || marker.sessionId !== sessionId) throw new SandboxUnavailableError("The sandbox tools are unavailable: this session's sandbox was not opened by @segmentstream/agent/sandbox. agent/agent/sandbox.ts must re-export it.");
+	return marker;
+}
+async function recentAttachments(sandbox, since) {
+	const listed = await sandbox.run({ command: `find ${SANDBOX_ATTACHMENTS_DIRECTORY} -type f -newermt @${Math.floor(since / 1e3)} -printf '%T@\\t%s\\t%p\\n' 2>/dev/null | sort -rn` });
+	const files = [];
+	let bytes = 0;
+	for (const line of listed.stdout.split("\n")) {
+		const [, size = "", path = ""] = line.split("	");
+		if (!STAGED_PATH.test(path) || files.length >= CARRIED_ATTACHMENTS.files || bytes + Number(size) > CARRIED_ATTACHMENTS.bytes) continue;
+		const content = await sandbox.readBinaryFile({ path });
+		if (content !== null) {
+			files.push({
+				path,
+				content
+			});
+			bytes += content.byteLength;
+		}
+	}
+	return files;
+}
+async function sessionSandbox(context, options = {}) {
+	const record = options.record ?? sandboxRecord;
+	const now = options.now ?? Date.now();
+	const turn = context.session.turn.id;
+	const sandbox = await context.getSandbox();
+	if (record.get()?.checkedTurn === turn) return sandbox;
+	const marker = await verifiedMarker(sandbox, context.session.id);
+	if (now - Date.parse(marker.openedAt) < 864e5) {
+		record.update(() => ({
+			openedAt: marker.openedAt,
+			checkedTurn: turn
+		}));
+		return sandbox;
+	}
+	const carried = await recentAttachments(sandbox, now - SANDBOX_MAXIMUM_AGE_MS);
+	await sandbox.delete();
+	record.update(() => null);
+	const fresh = await context.getSandbox();
+	const reopened = await verifiedMarker(fresh, context.session.id);
+	for (const file of carried) await fresh.writeBinaryFile(file);
+	record.update(() => ({
+		openedAt: reopened.openedAt,
+		checkedTurn: turn
+	}));
+	return fresh;
+}
+var SandboxFileRefused = class extends TypeError {};
+var SandboxFileTooLarge = class extends RangeError {};
+function shellQuoted(value) {
+	return `'${value.replaceAll("'", `'\\''`)}'`;
+}
+async function sandboxFile(context, path, options) {
+	if (!path.startsWith("/workspace/") || /[\0\r\n]/.test(path)) throw new SandboxFileRefused("path must be the absolute path of a file inside /workspace.");
+	const sandbox = await sessionSandbox(context, options);
+	const described = await sandbox.run({ command: `real="$(realpath -e -- ${shellQuoted(path)})" && printf '%s\\n' "$real" && stat -c '%F|%s' -- "$real"` });
+	const [real = "", stat = ""] = described.stdout.split("\n");
+	const [kind, size] = stat.split("|");
+	if (described.exitCode !== 0 || !real.startsWith("/workspace/") || posix.normalize(real) !== real) throw new SandboxFileRefused(`${path} names no file inside /workspace.`);
+	if (kind === "regular empty file") throw new SandboxFileRefused(`${path} is empty.`);
+	if (kind !== "regular file") throw new SandboxFileRefused(`${path} is not a regular file.`);
+	const tooLarge = () => new SandboxFileTooLarge(`${path} is larger than the ${options.maximumBytes / 1024 / 1024} MB an attachment may be.`);
+	if (Number(size) > options.maximumBytes) throw tooLarge();
+	const content = await sandbox.readBinaryFile({ path: real });
+	const filename = posix.basename(real);
+	if (content === null || content.byteLength === 0) throw new SandboxFileRefused(`${path} could not be read.`);
+	if (content.byteLength > options.maximumBytes) throw tooLarge();
+	if (filename.length > 255 || /[\x00-\x1f\x7f\\]/.test(filename)) throw new SandboxFileRefused(`${filename} cannot be stored as a file name; rename the file.`);
+	return {
+		path: real,
+		filename,
+		content
+	};
+}
+async function releaseSandbox(context, record = sandboxRecord) {
+	if (record.get() === null) return false;
+	try {
+		await (await context.getSandbox()).delete();
+	} finally {
+		record.update(() => null);
+	}
+	return true;
+}
+export { CARRIED_ATTACHMENTS, SANDBOX_ATTACHMENTS_DIRECTORY, SANDBOX_MARKER_PATH, SANDBOX_MAXIMUM_AGE_MS, SandboxFileRefused, SandboxFileTooLarge, SandboxUnavailableError, initializeSandbox, parseSandboxMarker, releaseSandbox, sandboxFile, sandboxRecord, sessionSandbox };

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

@@ -0,0 +1,38 @@
+import { type SandboxSession } from "eve/sandbox";
+/**
+ * `@segmentstream/agent/sandbox`: the isolated sandbox of a workspace agent (`docs/agent.md`,
+ * "Sandbox"). eve takes a sandbox only from the agent itself, never from an extension, so the
+ * agent's `agent/agent/sandbox.ts` re-exports this module:
+ *
+ *   export { default, environment } from "@segmentstream/agent/sandbox";
+ *
+ * It replaces eve's default sandbox, which on Vercel opens with an unrestricted network, with a
+ * Vercel Sandbox that has no network at all. The model reaches it through the extension's file
+ * tools; company data stays behind the ontology tools in the app runtime, so no credential, token
+ * or MCP connection ever enters it.
+ */
+/**
+ * The file toolset, installed once into the environment's snapshot while the network is still
+ * open. The Ubuntu packages exist in Ubuntu 26.04, the eve base image's release; a missing name
+ * would fail preparation and so the deploy. pdfplumber, which Ubuntu does not ship, is pinned with
+ * the two dependencies Ubuntu's are too old for, by version and hash, into the sandbox user's own
+ * site-packages; its pdfminer.six 20260107 is Ubuntu's python3-pdfminer.
+ */
+export declare const SANDBOX_PREPARE_SCRIPT = "set -euo pipefail\nsudo apt-get update -q\nsudo env DEBIAN_FRONTEND=noninteractive apt-get install -y -q --no-install-recommends \\\n  poppler-utils qpdf tesseract-ocr tesseract-ocr-eng tesseract-ocr-rus 7zip unar \\\n  imagemagick ghostscript python3-pandas python3-openpyxl python3-pypdf python3-pdfminer\nsudo apt-get clean\nsudo rm -rf /var/lib/apt/lists/*\nrequirements=\"$(mktemp)\"\ncat > \"$requirements\" <<'REQUIREMENTS'\npdfplumber==0.11.10 \\\n  --hash=sha256:7741ea81bf165b474b153e6789d10d18e06b6ddcf3ec84289c3ef2fed6802580\npillow==12.2.0 \\\n  --hash=sha256:4bfd07bc812fbd20395212969e41931001fd59eb55a60658b0e5710872e95286 \\\n  --hash=sha256:7b14cc0106cd9aecda615dd6903840a058b4700fcb817687d0ee4fc8b6e389be \\\n  --hash=sha256:8cbeb542b2ebc6fcdacabf8aca8c1a97c9b3ad3927d46b8723f9d4f033288a0f \\\n  --hash=sha256:22db17c68434de69d8ecfc2fe821569195c0c373b25cccb9cbdacf2c6e53c601\npypdfium2==5.9.0 \\\n  --hash=sha256:7ce3a3dd23ec0adaa079d8be54565ba2aa2f6060e76a4989cd42dabc163d74ee \\\n  --hash=sha256:1d902e03dff5efd51d93cd23d3e55bde53802fa6207bcd0e455239518859a069\nREQUIREMENTS\npython3 -m pip install --user --break-system-packages --no-cache-dir --no-deps \\\n  --only-binary=:all: --require-hashes --disable-pip-version-check -r \"$requirements\"\nrm -f \"$requirements\"\nmkdir -p /workspace/work\nfor tool in pdftotext pdftoppm qpdf tesseract gs 7z unar unzip jq rg; do\n  command -v \"$tool\" > /dev/null\ndone\nlanguages=\"$(tesseract --list-langs)\"\ngrep -qx eng <<< \"$languages\"\ngrep -qx rus <<< \"$languages\"\npython3 -c 'import openpyxl, pandas, pdfminer, pdfplumber, pypdf, pypdfium2'\n";
+/**
+ * Identifies the toolset. eve keys a prepared snapshot on the authored `sandbox.ts` and the
+ * environment's options, not on a `prepare` imported from a package, so the version travels as a
+ * sandbox tag: a changed toolset is a new snapshot.
+ */
+export declare const SANDBOX_TOOLSET_VERSION: string;
+/** Each live sandbox's compute; Vercel pairs every vCPU with 2 GB of memory. */
+export declare const SANDBOX_VCPUS = 2;
+export declare function prepareSandbox(sandbox: SandboxSession): Promise<void>;
+/**
+ * The environment `eve build` prepares. It carries no network policy: one applied here would hold
+ * during preparation too, before the toolset is installed.
+ */
+export declare const environment: import("eve/sandbox").SandboxEnvironment<import("eve/sandbox/vercel").VercelSandboxRuntimeOptions, import("eve/sandbox/vercel").VercelSandboxSession>;
+/** Opens the session's sandbox without network access and marks it as the SDK's. */
+declare const _default: import("eve/sandbox").SandboxSelector;
+export default _default;

package/dist/extension/lib/sandbox.mjs

@@ -0,0 +1,64 @@
+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 { initializeSandbox } from "./sandbox-session.mjs";
+import { createHash } from "node:crypto";
+import { defineSandbox } from "eve/sandbox";
+import { VercelSandbox } from "eve/sandbox/vercel";
+const SANDBOX_PREPARE_SCRIPT = `set -euo pipefail
+sudo apt-get update -q
+sudo env DEBIAN_FRONTEND=noninteractive apt-get install -y -q --no-install-recommends \\
+  poppler-utils qpdf tesseract-ocr tesseract-ocr-eng tesseract-ocr-rus 7zip unar \\
+  imagemagick ghostscript python3-pandas python3-openpyxl python3-pypdf python3-pdfminer
+sudo apt-get clean
+sudo rm -rf /var/lib/apt/lists/*
+requirements="$(mktemp)"
+cat > "$requirements" <<'REQUIREMENTS'
+pdfplumber==0.11.10 \\
+  --hash=sha256:7741ea81bf165b474b153e6789d10d18e06b6ddcf3ec84289c3ef2fed6802580
+pillow==12.2.0 \\
+  --hash=sha256:4bfd07bc812fbd20395212969e41931001fd59eb55a60658b0e5710872e95286 \\
+  --hash=sha256:7b14cc0106cd9aecda615dd6903840a058b4700fcb817687d0ee4fc8b6e389be \\
+  --hash=sha256:8cbeb542b2ebc6fcdacabf8aca8c1a97c9b3ad3927d46b8723f9d4f033288a0f \\
+  --hash=sha256:22db17c68434de69d8ecfc2fe821569195c0c373b25cccb9cbdacf2c6e53c601
+pypdfium2==5.9.0 \\
+  --hash=sha256:7ce3a3dd23ec0adaa079d8be54565ba2aa2f6060e76a4989cd42dabc163d74ee \\
+  --hash=sha256:1d902e03dff5efd51d93cd23d3e55bde53802fa6207bcd0e455239518859a069
+REQUIREMENTS
+python3 -m pip install --user --break-system-packages --no-cache-dir --no-deps \\
+  --only-binary=:all: --require-hashes --disable-pip-version-check -r "$requirements"
+rm -f "$requirements"
+mkdir -p /workspace/work
+for tool in pdftotext pdftoppm qpdf tesseract gs 7z unar unzip jq rg; do
+  command -v "$tool" > /dev/null
+done
+languages="$(tesseract --list-langs)"
+grep -qx eng <<< "$languages"
+grep -qx rus <<< "$languages"
+python3 -c 'import openpyxl, pandas, pdfminer, pdfplumber, pypdf, pypdfium2'
+`;
+const SANDBOX_TOOLSET_VERSION = createHash("sha256").update(SANDBOX_PREPARE_SCRIPT).digest("hex").slice(0, 16);
+const SANDBOX_VCPUS = 2;
+async function prepareSandbox(sandbox) {
+	const result = await sandbox.run({ command: SANDBOX_PREPARE_SCRIPT });
+	if (result.exitCode !== 0) throw new Error(`The SegmentStream sandbox toolset failed to install (exit ${result.exitCode}): ` + result.stderr.slice(-4e3));
+}
+const environment = VercelSandbox.environment({
+	prepare: prepareSandbox,
+	tags: { segmentstreamToolset: SANDBOX_TOOLSET_VERSION }
+});
+var sandbox_default = defineSandbox(async ({ session }) => {
+	const sandbox = await environment.open({
+		networkPolicy: "deny-all",
+		resources: { vcpus: 2 }
+	});
+	await initializeSandbox(sandbox, {
+		sessionId: session.id,
+		toolset: SANDBOX_TOOLSET_VERSION
+	});
+	return sandbox;
+});
+export { SANDBOX_PREPARE_SCRIPT, SANDBOX_TOOLSET_VERSION, SANDBOX_VCPUS, sandbox_default as default, environment, prepareSandbox };

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-DR4gACLZ.mjs";
 import { attachmentLifecycle } from "./lifecycle.mjs";
 import { observedMessages } from "./observed.mjs";
 import { expireDeferredCards, handleDeferredCallback, isDeferredCallback } from "./deferred-confirmations.mjs";
@@ -29,7 +29,7 @@ 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 { replyDelivery } from "./silent.mjs";
+import { interimTexts, replyDelivery } from "./silent.mjs";
 import { handleConfirmationCallback, telegramConfirmationEvents } from "./confirmations.mjs";
 import { captureRouteDecider, captureTelegramFetch, conversationIdentities, recordGateDecision, telegramConversationCapture } from "./conversations.mjs";
 import { runtimeTokenVerifier } from "../runtime-identity.mjs";
@@ -88,6 +88,7 @@ function segmentstreamTelegram(options) {
 	});
 	const bot = botIdentityCache();
 	const proxies = new Map();
+	const interimDelivered = interimTexts();
 	let identities;
 	let verify = options.verify;
 	function settings() {
@@ -372,7 +373,10 @@ function segmentstreamTelegram(options) {
 			}
 		},
 		events: {
-			...telegramFailureEvents,
+			...telegramFailureEvents({
+				archive,
+				identities: pairing
+			}),
 			...telegramConfirmationEvents(archive, observed, {
 				environment,
 				token,
@@ -415,7 +419,10 @@ function segmentstreamTelegram(options) {
 					await channel.telegram.post(failureText(reference));
 					return;
 				}
-				await replyDelivery(observed, () => telegramSendScope(environment, settings().connection))(event, channel, context);
+				await replyDelivery(observed, () => telegramSendScope(environment, settings().connection), {
+					enabled: () => settings().interimMessages === true,
+					delivered: interimDelivered
+				})(event, channel, context);
 			}
 		}
 	});

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-DR4gACLZ.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-DR4gACLZ.mjs";
 var AttachmentLifecycleNotPermitted = class extends Error {
 	code = "attachment_lifecycle_not_permitted";
 };

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

@@ -4,10 +4,32 @@ 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"]>;
+/** The texts one runtime delivered as interim messages, per session turn. */
+export interface InterimTexts {
+    has(turn: string, text: string): boolean;
+    add(turn: string, text: string): void;
+}
+/** How many recent turns {@link interimTexts} remembers. */
+export declare const INTERIM_TURNS = 256;
+/** Remembers the interim texts of the most recent turns, the oldest turn forgotten first. */
+export declare function interimTexts(limit?: number): InterimTexts;
+/**
+ * `channels.telegram.interimMessages`: the text the model writes in a step that ends in tool
+ * calls, such as a word on what a long job is doing, reaches the chat as its own message.
+ */
+export interface InterimMessages {
+    readonly enabled: () => boolean;
+    /** What this runtime delivered, so neither an interim text nor a final reply goes out twice. */
+    readonly delivered: InterimTexts;
+}
 /**
  * The channel's final reply: formatted and split before Eve's plain-text splitter, with one
- * queue slot for the whole reply. Tool-call steps and explicit silence markers have no delivery.
+ * queue slot for the whole reply. Explicit silence markers have no delivery. Tool-call steps have
+ * none either unless `interim` is enabled: then their text is delivered exactly like a reply, but
+ * not remembered for group routing, which counts only final replies, as its recovery from the
+ * session stream does. A text already delivered as an interim message in the same turn, whether
+ * a repeat or the final reply, is not delivered again.
  */
-export declare function replyDelivery(observed?: ObservedMessages, scope?: () => string): MessageCompleted;
+export declare function replyDelivery(observed?: ObservedMessages, scope?: () => string, interim?: InterimMessages): MessageCompleted;
 export declare const deliverUnlessSilent: MessageCompleted;
 export {};

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

@@ -20,9 +20,31 @@ function completionKind(message, finishReason) {
 	if (message.trim() === "") return "whitespace";
 	return isSilentReply(message) ? "silent_marker" : "reply";
 }
-function replyDelivery(observed, scope = () => "telegram") {
+const INTERIM_TURNS = 256;
+function interimTexts(limit = 256) {
+	const turns = new Map();
+	return {
+		has: (turn, text) => turns.get(turn)?.has(text) ?? false,
+		add(turn, text) {
+			const texts = turns.get(turn) ?? new Set();
+			turns.delete(turn);
+			turns.set(turn, texts.add(text));
+			for (const oldest of turns.keys()) {
+				if (turns.size <= limit) break;
+				turns.delete(oldest);
+			}
+		}
+	};
+}
+function replyDelivery(observed, scope = () => "telegram", interim) {
 	return async (event, channel, context) => {
-		if (completionKind(event.message, event.finishReason) !== "reply") return;
+		const kind = completionKind(event.message, event.finishReason);
+		const interimOn = interim?.enabled() === true;
+		const isInterim = kind === "tool_calls" && interimOn && completionKind(event.message) === "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();
+		if (turn !== void 0 && interim.delivered.has(turn, key)) return;
 		const message = customerMessage(event.message, confirmationLocale(context.session?.auth.current ?? null, currentLocale()));
 		const principal = context.session?.auth.current;
 		const replyTo = principal?.attributes.replyToMessageId;
@@ -42,12 +64,16 @@ function replyDelivery(observed, scope = () => "telegram") {
 					messageIds.push(Number(result.id));
 				}
 			} catch (error) {
-				const reference = reportTelegramError("telegram_reply_delivery_failed", error, { messageIds });
+				const reference = reportTelegramError(isInterim ? "telegram_interim_delivery_failed" : "telegram_reply_delivery_failed", error, { messageIds });
 				throw new TelegramDeliveryError(reference, error instanceof TelegramDeliveryError ? error.delivery : "unknown", messageIds);
 			}
 			return messageIds;
 		});
 		const text = message.text;
+		if (isInterim) {
+			if (turn !== void 0) interim.delivered.add(turn, key);
+			return;
+		}
 		if (observed === void 0 || channel.telegram.chatType === "private") return;
 		const sender = principal?.authenticator === "segmentstream-telegram" ? principal.subject : void 0;
 		const username = principal?.attributes.username;
@@ -71,4 +97,4 @@ function replyDelivery(observed, scope = () => "telegram") {
 	};
 }
 const deliverUnlessSilent = replyDelivery();
-export { completionKind, deliverUnlessSilent, isSilentReply, replyDelivery };
+export { INTERIM_TURNS, completionKind, deliverUnlessSilent, interimTexts, isSilentReply, replyDelivery };

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">;