@segmentstream/agent 0.23.16 → 0.24.1

package/dist/extension/tools/attachments_stage.mjs

@@ -9,7 +9,7 @@ import segmentstream from "../extension.mjs";
 import { actorOf } from "../lib/actor.mjs";
 import { sessionSandbox } from "../lib/sandbox-session.mjs";
 import { attachmentOwner, optionalString, stringArgument, toolAttachments } from "../lib/attachment-tools.mjs";
-import { readStoredFile } from "../lib/stored-files.mjs";
+import { storedFileGrant } from "../lib/stored-files.mjs";
 import { createHash } from "node:crypto";
 import { posix } from "node:path";
 import { defineDynamic, defineTool } from "eve/tools";
@@ -21,6 +21,15 @@ function stagedFileName(filename) {
 	const stem = (dot > 0 ? base.slice(0, dot) : base).normalize("NFKD").replace(/[^\w.-]+/g, "_").replace(/^[._-]+|[._-]+$/g, "").slice(0, 120);
 	return `${stem === "" ? "file" : stem}${extension}`;
 }
+async function holds(sandbox, path, sha256) {
+	try {
+		const hashed = await sandbox.run({ command: `sha256sum -- '${path.replaceAll("'", `'\\''`)}' 2>/dev/null` });
+		return hashed.exitCode === 0 && hashed.stdout.slice(0, 64) === sha256;
+	} catch (error) {
+		console.warn("A staged file could not be checked; staging it again.", error);
+		return false;
+	}
+}
 function stagedFilePath(sha256, filename) {
 	return `${STAGED_FILES_DIRECTORY}/${sha256.slice(0, 16)}/${stagedFileName(filename)}`;
 }
@@ -51,27 +60,51 @@ const tool = defineTool({
 		const entity = optionalString(input, "entity");
 		const property = optionalString(input, "property");
 		if (entity === void 0 && property !== void 0) throw new TypeError("property requires entity.");
-		const { attachment, bytes } = entity === void 0 ? await toolAttachments().read(attachmentOwner({
-			principal: ctx.session.auth.current,
-			sessionId: ctx.session.id
-		}), id) : await readStoredFile({
-			entity,
-			id,
-			...property === void 0 ? {} : { property }
-		}, ctx.session.auth.current);
-		const sha256 = createHash("sha256").update(bytes).digest("hex");
-		if (sha256 !== attachment.sha256) throw new Error("The file's bytes differ from its recorded SHA-256; nothing was staged.");
-		const path = stagedFilePath(sha256, attachment.filename);
-		await (await sessionSandbox(ctx)).writeBinaryFile({
-			path,
-			content: bytes
-		});
+		const sandboxOf = () => sessionSandbox(ctx);
+		let staged;
+		if (entity === void 0) {
+			const { attachment, bytes } = await toolAttachments().read(attachmentOwner({
+				principal: ctx.session.auth.current,
+				sessionId: ctx.session.id
+			}), id);
+			const sha256 = createHash("sha256").update(bytes).digest("hex");
+			if (sha256 !== attachment.sha256) throw new Error("The file's bytes differ from its recorded SHA-256; nothing was staged.");
+			const path = stagedFilePath(sha256, attachment.filename);
+			await (await sandboxOf()).writeBinaryFile({
+				path,
+				content: bytes
+			});
+			staged = {
+				path,
+				file: {
+					...attachment,
+					size: bytes.byteLength
+				}
+			};
+		} else {
+			const grant = await storedFileGrant({
+				entity,
+				id,
+				...property === void 0 ? {} : { property }
+			}, ctx.session.auth.current);
+			const path = stagedFilePath(grant.file.sha256, grant.file.filename);
+			const sandbox = await sandboxOf();
+			if (!await holds(sandbox, path, grant.file.sha256)) await sandbox.writeBinaryFile({
+				path,
+				content: await grant.read()
+			});
+			staged = {
+				path,
+				file: grant.file
+			};
+		}
+		const { path, file } = staged;
 		return workflowToolResult({
 			path,
-			filename: attachment.filename,
-			content_type: attachment.contentType,
-			size: bytes.byteLength,
-			sha256,
+			filename: file.filename,
+			content_type: file.contentType,
+			size: file.size,
+			sha256: file.sha256,
 			...entity === void 0 ? { attachment_id: id } : {
 				entity,
 				record_id: id,

package/dist/extension/tools/questions_ask.mjs

@@ -5,7 +5,7 @@ const __filename = __eveFileURLToPath(import.meta.url);
 __eveDirname(__filename);
 __eveCreateRequire(import.meta.url);
 import { agentTaskIdOf, agentTaskSessions } from "../lib/agent-task.mjs";
-import { i as memberIdOf } from "../../_chunks/principal-69qoDdqy.mjs";
+import { i as memberIdOf } from "../../_chunks/principal-DMNXj4PX.mjs";
 import { n as workflowToolResult } from "../../_chunks/workflow-serializable-DU7WeCIW.mjs";
 import { pendingQuestions, questionKey } from "../lib/questions.mjs";
 import { stringArgument } from "../lib/attachment-tools.mjs";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@segmentstream/agent",
-  "version": "0.23.16",
+  "version": "0.24.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",

package/dist/extension/lib/confirmation-outcome.d.ts

@@ -1,27 +0,0 @@
-import type { DeferredConfirmation } from "./deferred-confirmations.js";
-/** Model-only correlation plus bounded display context; never forward business input or results. */
-export declare function confirmationOutcome(record: DeferredConfirmation, status: Exclude<DeferredConfirmation["status"], "pending">, detail?: {
-    readonly execution?: "not_started" | "uncertain";
-    readonly editRequested?: boolean;
-    readonly error?: {
-        readonly code: string;
-        readonly message: string;
-    };
-}): {
-    execution?: "not_started" | "uncertain";
-    editRequested?: boolean;
-    error?: {
-        readonly code: string;
-        readonly message: string;
-    };
-    context?: {
-        targets?: {
-            label: string;
-            value: string;
-        }[] | undefined;
-        request?: string | undefined;
-    } | undefined;
-    confirmation: string;
-    status: "failed" | "expired" | "done" | "cancelled" | "approved";
-    summary: string;
-};

package/dist/extension/lib/confirmation-outcome.mjs

@@ -1,34 +0,0 @@
-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 { humanText } from "./confirmation-description.mjs";
-import { confirmationCopy } from "./telegram/confirmation-text.mjs";
-function confirmationOutcome(record, status, detail = {}) {
-	const description = record.data.confirmation.description;
-	const request = confirmationCopy(record.data.confirmation.copy)?.question;
-	const targets = [...description?.targets ?? [], ...description?.chatPost ? [{
-		label: "→",
-		value: description.chatPost.title
-	}] : []].flatMap((target) => {
-		const label = humanText(target.label);
-		const value = humanText(target.value, 3584);
-		return label === void 0 || value === void 0 ? [] : [{
-			label,
-			value
-		}];
-	});
-	return {
-		confirmation: record.id,
-		status,
-		summary: humanText(description?.action) ?? "❓",
-		...request === void 0 && targets.length === 0 ? {} : { context: {
-			...request === void 0 ? {} : { request },
-			...targets.length === 0 ? {} : { targets }
-		} },
-		...detail
-	};
-}
-export { confirmationOutcome };

package/dist/extension/lib/deferred-confirmations.d.ts

@@ -1,41 +0,0 @@
-import type { RuntimeEnvelope } from "./runtime-envelope.js";
-import { type Confirmation } from "./confirmations.js";
-import { type Environment } from "./environment.js";
-import { type RuntimeToken } from "./runtime-token.js";
-import type { TelegramTexts } from "./telegram/texts.js";
-export interface DeferredConfirmation {
-    readonly id: string;
-    readonly key: string;
-    readonly memberId: string;
-    readonly inputHash: string;
-    readonly expiresAt: number;
-    readonly status: "pending" | "approved" | "cancelled" | "expired" | "done" | "failed";
-    readonly data: {
-        readonly runtimeSource?: RuntimeEnvelope["source"];
-        readonly action: string;
-        readonly input: Readonly<Record<string, unknown>>;
-        readonly confirmation: Confirmation;
-        readonly sessionId: string;
-        readonly callId: string;
-        readonly chatId: string;
-        readonly threadId: string;
-        readonly requester: string;
-        readonly locale?: string;
-        readonly requesterName?: string;
-        readonly messageId?: string;
-        readonly address?: string;
-    };
-}
-export type DeferredOptions = {
-    readonly texts?: () => TelegramTexts;
-    readonly environment?: Environment;
-    readonly token?: RuntimeToken;
-    readonly fetch?: typeof fetch;
-};
-export declare const deferredKey: (id: string) => string;
-/** Private deployment-authenticated ledger; the model never gets this transport. */
-export declare function deferredConfirmations(options?: DeferredOptions): {
-    command<T>(command: unknown): Promise<T>;
-};
-/** Re-authorize before prepare; the ontology also authenticates the member on tools/call. */
-export declare function runDeferredAction(record: DeferredConfirmation, options: DeferredOptions): Promise<Record<string, unknown>>;

package/dist/extension/lib/deferred-confirmations.mjs

@@ -1,77 +0,0 @@
-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 { redactDiagnostic } from "./diagnostics.mjs";
-import { appOrigin } from "./environment.mjs";
-import { runtimeToken } from "./runtime-token.mjs";
-import { member } from "./actor.mjs";
-import { chatPostDigest, isChatPost } from "./chat-post-confirmation.mjs";
-import { inputHash } from "./confirmations.mjs";
-import { ontologyTools } from "./ontology-tools.mjs";
-import { createHash } from "node:crypto";
-const deferredKey = (id) => createHash("sha256").update(id).digest("hex").slice(0, 20);
-function deferredConfirmations(options = {}) {
-	return { async command(command) {
-		const credential = await (options.token ?? runtimeToken)();
-		try {
-			const response = await (options.fetch ?? fetch)(`${appOrigin(options.environment ?? process.env)}/api/ontology/agent/confirmations`, {
-				method: "POST",
-				redirect: "error",
-				signal: AbortSignal.timeout(15e3),
-				headers: {
-					authorization: `Bearer ${credential}`,
-					"content-type": "application/json"
-				},
-				body: JSON.stringify(command)
-			});
-			if (!response.ok) throw new Error(`Confirmation ledger unavailable (HTTP ${response.status}).`, { cause: await response.text() });
-			return (await response.json()).result;
-		} catch (error) {
-			throw new Error("Confirmation ledger request failed.", { cause: redactDiagnostic(error, new Set([credential])) });
-		}
-	} };
-}
-async function runDeferredAction(record, options) {
-	if (record.inputHash !== inputHash(record.data.input)) throw new Error("The confirmed input changed.");
-	const tools = ontologyTools(options);
-	await tools.labels(member(record.memberId), record.data.action, record.data.input);
-	const preview = record.data.confirmation.description?.chatPost;
-	if (isChatPost(record.data.action)) {
-		const input = Object.fromEntries(Object.entries(record.data.input).filter(([key]) => key !== "_confirmation"));
-		const current = (await tools.describe(member(record.memberId), record.data.action, input)).chatPost;
-		if (!preview || !current || chatPostDigest(preview) !== chatPostDigest(current)) throw new Error("The confirmed chat destination or attribution changed.");
-	}
-	const envelope = {
-		version: 1,
-		session_id: record.data.sessionId,
-		call_id: record.data.callId,
-		operation_id: record.id,
-		...record.data.runtimeSource === void 0 ? {} : { source: record.data.runtimeSource },
-		...preview ? {
-			source: {
-				provider: "telegram",
-				chat_id: record.data.chatId,
-				thread_id: record.data.threadId,
-				...record.data.runtimeSource
-			},
-			expected: {
-				chat_id: preview.chatId,
-				digest: chatPostDigest(preview)
-			}
-		} : {}
-	};
-	const result = await ontologyTools({
-		...options,
-		envelope
-	}).rpc(member(record.memberId), "tools/call", {
-		name: record.data.action.split("__").at(-1),
-		arguments: record.data.input
-	});
-	const output = result.structuredContent;
-	if (result.isError === true || (output?.validation)?.ok === false || preview !== void 0 && output?.status !== "sent") throw new Error("The confirmed action did not complete; its outcome may be uncertain.", { cause: result });
-	return result;
-}
-export { deferredConfirmations, deferredKey, runDeferredAction };

package/dist/extension/lib/telegram/confirmation-expiry.d.ts

@@ -1,5 +0,0 @@
-import type { TelegramSettings } from "../../config.js";
-import { type DeferredConfirmation, type DeferredOptions } from "../deferred-confirmations.js";
-import { type TelegramTexts } from "./texts.js";
-/** A bounded sweep; concurrent webhooks/schedules compete for the same atomic expiry claim. */
-export declare function expireScheduledConfirmations(connection: string, notify: (record: DeferredConfirmation, result: Readonly<Record<string, unknown>>) => Promise<unknown>, options?: DeferredOptions, settings?: TelegramSettings, texts?: TelegramTexts): Promise<void>;

package/dist/extension/lib/telegram/confirmation-expiry.mjs

@@ -1,62 +0,0 @@
-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 { proxyEnvironment } from "../environment.mjs";
-import { runtimeToken } from "../runtime-token.mjs";
-import { withTelegramTexts } from "./texts.mjs";
-import { telegramSendScope } from "./send-queue.mjs";
-import { conversations } from "../conversations.mjs";
-import { m as safeTelegramFetch, p as reportTelegramError } from "../../../_chunks/inbound-request-gJ5wpsBF.mjs";
-import { connectionProxy } from "../connection-proxy.mjs";
-import { deferredConfirmations } from "../deferred-confirmations.mjs";
-import { expireDeferredRecord } from "./deferred-confirmations.mjs";
-import { TELEGRAM_PLACEHOLDER_TOKEN, TELEGRAM_PROXY_ORIGIN, telegramProxyFetch } from "./proxy-fetch.mjs";
-import { telegramPreviewEnvironment } from "@segmentstream-cloud/ontology/telegram";
-async function expireScheduledConfirmations(connection, notify, options = {}, settings, texts = {}) {
-	const environment = options.environment ?? process.env;
-	const token = options.token ?? runtimeToken;
-	const archive = conversations({
-		environment,
-		token,
-		fetch: options.fetch
-	});
-	const scope = telegramSendScope(environment, connection);
-	const proxy = connectionProxy({
-		environment: proxyEnvironment(environment),
-		connection,
-		token,
-		fetch: options.fetch
-	});
-	const transport = safeTelegramFetch(telegramProxyFetch(proxy, scope), scope, {
-		settings,
-		ownOrigins: telegramPreviewEnvironment(environment).appOrigins
-	});
-	const records = await deferredConfirmations(options).command({ operation: "expired" });
-	for (const record of records) try {
-		await withTelegramTexts(texts, () => expireDeferredRecord(record, { telegram: { editMessageText: async (input) => {
-			const response = await transport(`${TELEGRAM_PROXY_ORIGIN}/bot${TELEGRAM_PLACEHOLDER_TOKEN}/editMessageText`, {
-				method: "POST",
-				headers: { "content-type": "application/json" },
-				body: JSON.stringify({
-					chat_id: record.data.chatId,
-					message_id: input.messageId,
-					text: input.text,
-					reply_markup: input.replyMarkup
-				})
-			});
-			const result = await response.json();
-			if (!response.ok || result.ok !== true) throw new Error(`Telegram confirmation expiry failed: ${result.description ?? response.status}`);
-			return {
-				ok: true,
-				status: response.status,
-				body: result
-			};
-		} } }, options, archive, notify), () => record.data.locale ?? "en");
-	} catch (error) {
-		reportTelegramError("deferred_expiry_failed", error);
-	}
-}
-export { expireScheduledConfirmations };

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

@@ -1,26 +0,0 @@
-import type { TelegramCallbackQuery, TelegramContext, TelegramHandle, TelegramEventContext } from "eve/channels/telegram";
-import type { SessionContext } from "eve/context";
-import { type DeferredConfirmation, type DeferredOptions } from "../deferred-confirmations.js";
-import { type Conversations } from "../conversations.js";
-import type { AgentIdentities } from "../identities.js";
-import { type ObservedMessages } from "./observed.js";
-export declare const isDeferredCallback: (data?: string) => boolean;
-export declare const deferredCallback: (record: DeferredConfirmation, choice: "y" | "n" | "e") => string;
-export declare function archiveDeferred(record: DeferredConfirmation, phase: string, archive: Conversations, errorText?: string): Promise<void>;
-/** Called at the durable tool-result boundary. Pending cards never become eve input requests. */
-export declare function postDeferredCard(id: string, channel: TelegramEventContext, ctx: SessionContext, options: DeferredOptions, archive: Conversations, observed?: ObservedMessages): Promise<void>;
-/** Every callback re-resolves the live identity. The database arbitrates concurrent presses. */
-export declare function handleDeferredCallback(input: {
-    readonly context: TelegramContext;
-    readonly query: TelegramCallbackQuery;
-    readonly identities: AgentIdentities;
-    readonly archive: Conversations;
-    readonly options: DeferredOptions;
-    readonly observed?: ObservedMessages;
-}): Promise<void>;
-/** A database-clock expiry claim is shared by webhooks and the minute schedule. */
-export declare function expireDeferredRecord(record: DeferredConfirmation, context: {
-    readonly telegram: Pick<TelegramHandle, "editMessageText">;
-}, options: DeferredOptions, archive: Conversations, notify: NonNullable<import("./inbound-request.js").InboundRequest["confirmationEvent"]>, observed?: ObservedMessages): Promise<void>;
-/** Webhooks also reconcile expiry if the host's minute scheduler is delayed. */
-export declare function expireDeferredCards(context: TelegramContext, options: DeferredOptions, archive: Conversations, observed?: ObservedMessages): Promise<void>;