@segmentstream/agent 0.12.2 → 0.14.0

package/README.md

@@ -189,13 +189,13 @@ continue using GET lookup. Starter templates and pins remain unchanged in this s
 
 ## What the extension contributes
 
-| Name                                                               | Slot           | What it does                                                                                                                                                                    |
-| ------------------------------------------------------------------ | -------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `segmentstream__ontology`                                          | `connections`  | The app's `/mcp`, resolved per turn for the turn's member. No member, no connection.                                                                                            |
-| `segmentstream__telegram`                                          | `channels`     | `POST /eve/v1/telegram`: Telegram through the connection, with pairing, routing and voice.                                                                                      |
-| `segmentstream__attachments_list`, `_read`, `_promote`, `_discard` | `tools`        | The member's temporary attachments in this chat: list, read, keep through an action, drop.                                                                                      |
-| `segmentstream__attachments_send`                                  | `tools`        | Sends readable stored ontology files into the current Telegram chat and topic.                                                                                                  |
-| platform rules                                                     | `instructions` | Changes go through actions; `describe` indexes or inspects refs; `discover` searches metadata; tools are already narrowed; when to answer `[SILENT]`; how to handle attachments |
+| Name                                                                 | Slot           | What it does                                                                                                                                                                    |
+| -------------------------------------------------------------------- | -------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `segmentstream__ontology_describe`, `_discover`, `_inspect`, `_call` | `tools`        | Permission-filtered metadata, schema inspection and action calls as the current member.                                                                                         |
+| `segmentstream__telegram`                                            | `channels`     | `POST /eve/v1/telegram`: Telegram through the connection, with pairing, routing and voice.                                                                                      |
+| `segmentstream__attachments_list`, `_read`, `_promote`, `_discard`   | `tools`        | The member's temporary attachments in this chat: list, read, keep through an action, drop.                                                                                      |
+| `segmentstream__attachments_send`                                    | `tools`        | Sends readable stored ontology files into the current Telegram chat and topic.                                                                                                  |
+| platform rules                                                       | `instructions` | Changes go through actions; `describe` indexes or inspects refs; `discover` searches metadata; tools are already narrowed; when to answer `[SILENT]`; how to handle attachments |
 
 ### The ontology
 
@@ -222,15 +222,17 @@ share a group chat's session never share a client.
   proxy. The token stays in SegmentStream.
 - **Webhook.** A webhook is accepted only with `X-Telegram-Bot-Api-Secret-Token` equal to
   `SEGMENTSTREAM_AGENT_WEBHOOK_SECRET`, compared in constant time. The platform generates the
-  secret and registers the webhook after each production deployment, and sets the bot's menu
-  button, shown in private chats, to open the workspace app.
+  secret and registers the webhook after each production deployment. A workspace-supplied
+  `menuButton.text` enables the app menu button; omitting it resets the provider menu to its default
+  for Agent SDK 0.13 or later. Pre-0.13 archives without menu copy retain their existing provider menu.
 - **Production only.** Outside `VERCEL_ENV=production` the route answers 200 and does nothing, so a
   preview never answers a real chat. Without `channels.telegram` it answers 404.
 - **Pairing.** Bots and channel posts are archived without starting turns. The sender's Telegram
   account is checked on every message, so revocation takes effect immediately. Unlinked group
   speech and attachment metadata remain raw context, including edits; no unlinked voice is decoded or gets
-  a reply. An unknown private sender gets a neutral connection button to `/agent/connect?code=…`,
-  valid for ten minutes; revoked or inactive private senders get a neutral refusal marker.
+  a reply. An unknown private sender gets the workspace pairing prompt and button to `/agent/connect?code=…`,
+  valid for ten minutes; revoked or inactive private senders receive configured refusal copy,
+  or no message when it is absent.
 - **Who the agent is.** A paired sender's turn runs with the principal id `telegram:<user>`
   (`telegram:<chat>:<user>` in groups) and the attributes `memberId`, `memberName`, `roles`,
   `chatId`, `chatType` and `username`.
@@ -516,7 +518,7 @@ ontology SDK along with this extension. See the repository's
 [conversation storage guide](../../docs/agent-conversation-storage.md) for APIs, retention,
 eve's existing storage, and Telegram's delivery limits.
 
-### Exact chat posting protocol (prepared in agent SDK 0.6.0)
+### Exact chat posting protocol
 
 An authenticated `tools/list` advertises `_meta: { "segmentstream/chat-post": 1 }` on
 `chat_post_message`. Without this marker,
@@ -525,12 +527,12 @@ missing/incomplete preview metadata is denied. The versioned connection has its
 
 The runtime reads `me` for the server-derived `attribution`, and `chat_list({ chat })` for exactly
 one eligible destination: `{ items: [{ id, title, provider, external_id }], next_cursor: null }`.
-Provider is currently `telegram`. The final plain text is exactly `attribution + ": " + text`;
+Provider is currently `telegram`. The final plain text is `text + separator + attribution`, with a blank line as the neutral separator;
 `reply_to` is optional. A preview digest is SHA-256 of the JSON array of chat ID, provider,
 external ID, title, attribution, text, final text and nullable reply target, in that order.
 The target/attribution are resolved again immediately before executing the frozen call.
 
-Eve supplies the model-hidden `_segmentstream` argument on **all** calls of a negotiated connection.
+The SDK constructs model-hidden `_segmentstream` metadata for approved runtime posts.
 It contains `version: 1`, `session_id` and `call_id`. A consumed, unexpired chat approval additionally
 supplies `operation_id`, source provider/chat/topic coordinates and `expected: { chat_id, digest }`.
 The operation ID is `hq:` plus SHA-256 of the JSON array `[session_id, call_id]`; it stays stable
@@ -538,7 +540,8 @@ on replay and changes for a revision. The model cannot provide an idempotency ke
 The ontology must authenticate runtime provenance, consume/remove the envelope before strict input
 validation for ordinary tools, derive the posting key from the operation, and recompute attribution.
 External OAuth/service callers still supply their own `idempotency_key` and cannot use this envelope.
-These server changes belong to the later ontology stage; do not advertise the marker prematurely.
+The coordinated ontology SDK implements this protocol; deploy the compatible ontology before
+using agent exact posting.
 
 Source previews, accepted decisions and receipts use existing archive events with operation-linked
 `toolCallId`/event IDs. A cancelled Edit carries its pending revision question in the authoritative
@@ -546,10 +549,12 @@ Eve resolution, so member/topic routing survives a cold start. No second provide
 
 ## Release and migration
 
-The tested release uses agent SDK 0.6.4, Eve 0.76.3 and ontology SDK 0.28.3.
-Deploy the agent first, then backend archive migration 0033/API, then the ontology
-with its declared Telegram provider mapping and explicit `agent_chat:post_message`
-grant. Older ontologies keep ordinary tools working without the extra envelope.
+The coordinated release uses Agent SDK 0.14.0, Eve 0.76.3, Ontology SDK 0.50.0 and App SDK 0.24.1.
+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.
+Supply the required workspace presentation before upgrading the agent to 0.13.x.
+Older ontologies keep ordinary tools working without the extra envelope.
 An older archive returning only `{stored:true}` cannot authorize a send.
 
 Rollback
@@ -615,7 +620,7 @@ can redeliver the same source; the hook and attachment reservation must preserve
 idempotent source membership, storage results and the single acknowledgement.
 Such a failure must not become an HTTP success with no queued work.
 
-### Legacy held approvals
+### Deferred approvals and legacy recovery
 
 Deferred mode supplies four eager tools: `segmentstream__ontology_discover`,
 `segmentstream__ontology_describe`, `segmentstream__ontology_inspect` and `segmentstream__ontology_call`. Registration
@@ -636,11 +641,13 @@ actionable explanation. Reply delivery carries the owning turn's reply anchor
 explicitly after restore. Omitting the version preserves existing closed lifecycle
 data schemas; workspaces opt in only after their hook accepts the additional fields.
 
-Explicit `confirmations.mode: "held"` overrides the deferred default. Switching a package version
-does not migrate already-running held turns. In deferred mode the Telegram adapter reads the owning session's
+`confirmations.mode: "held"` is rejected. Already-running held turns still need recovery.
+The Telegram adapter reads the owning session's
 recorded approval inputs and requests cancellation of that exact turn before admitting a new
 addressed message. It never approves the old call or reuses the old member's authorization.
 Cancellation failure requests webhook replay; terminal/resolved approvals are left alone.
 Deferred mode retains its ten-minute database deadline and minute expiry sweep. Runtime health
 reports the effective confirmation mode and attachment-lifecycle presence behind its existing
 runtime authentication; source pins and public health alone are not settings-adoption proof.
+
+Telegram 0.13.0 requires workspace-authored pairing and confirmation text. See [workspace Telegram text](../../docs/agent.md#workspace-telegram-text) for keys, limits, neutral fallbacks and unsupported Eve buttons.

package/dist/_chunks/{build-metadata-CLprTpsn.mjs → build-metadata-BB2uSGsI.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.12.2";
+var version = "0.14.0";
 function agentBuild(environment = process.env) {
 	return {
 		agent: version,

package/dist/_chunks/{inbound-request-BrWspFw5.mjs → inbound-request-BXhiIph-.mjs}

@@ -4,15 +4,16 @@ import { createRequire as __eveCreateRequire } from "node:module";
 const __filename = __eveFileURLToPath(import.meta.url);
 __eveDirname(__filename);
 __eveCreateRequire(import.meta.url);
+import { telegramText } from "../extension/lib/telegram/texts.mjs";
 import { isTechnicalText } from "../extension/lib/customer-text-safety.mjs";
 import { redactDiagnostic } from "../extension/lib/diagnostics.mjs";
 import { isConfirmationText } from "../extension/lib/telegram/confirmation-text.mjs";
 import { chatPostCardLinks, isExactChatPostCard } from "../extension/lib/telegram/chat-post-card.mjs";
 import { plainTelegramText, splitTelegramText, telegramMarkdown } from "../extension/lib/telegram/format.mjs";
 import { inTelegramSendQueue } from "../extension/lib/telegram/send-queue.mjs";
-import { telegramPreviewOptions, telegramTextLinks } from "@segmentstream-cloud/ontology/telegram";
 import { randomBytes, randomUUID } from "node:crypto";
 import { AsyncLocalStorage } from "node:async_hooks";
+import { telegramPreviewOptions, telegramTextLinks } from "@segmentstream-cloud/ontology/telegram";
 const deliveryLocale = new AsyncLocalStorage();
 function withDeliveryLocale(locale, run, threadId, replyTo, chatId) {
 	return deliveryLocale.run({
@@ -28,15 +29,16 @@ function currentLocale() {
 function currentThreadId() {
 	return deliveryLocale.getStore()?.threadId ?? currentInboundRequest()?.threadId;
 }
-function customerCopy() {
+function customerCopy(locale = currentLocale()) {
 	return {
-		failed: "⚠️",
-		recovery: "⚠️",
-		attachment: "⚠️",
-		authorization: "⚠️",
-		response: "⚠️",
-		connected: "✅",
-		disconnected: "❌"
+		failed: telegramText("notice", "failed", locale),
+		recovery: telegramText("notice", "recovery", locale),
+		attachment: telegramText("notice", "attachment", locale),
+		authorization: telegramText("notice", "authorization", locale),
+		response: telegramText("notice", "response", locale),
+		connected: telegramText("notice", "connected", locale),
+		disconnected: telegramText("notice", "disconnected", locale),
+		cancelled: telegramText("notice", "cancelled", locale)
 	};
 }
 function redactCredentials(value) {
@@ -46,7 +48,7 @@ function redactCredentials(value) {
 	return value;
 }
 function reportTelegramError(operation, error, metadata = {}, secrets = new Set()) {
-	const errorId = randomBytes(4).toString("hex").toUpperCase();
+	const errorId = randomBytes(4).toString("hex");
 	const credentials = new Set([...secrets, ...[process.env.AI_GATEWAY_API_KEY, process.env.VERCEL_OIDC_TOKEN].filter((value) => value !== void 0)]);
 	console.error("[segmentstream] Telegram delivery diagnostic", {
 		...metadata,
@@ -57,8 +59,8 @@ function reportTelegramError(operation, error, metadata = {}, secrets = new Set(
 	return errorId;
 }
 function failureText(errorId, kind = "failed", _locale = currentLocale()) {
-	if (kind === "cancelled") return `⏹ ${errorId}`;
-	return `${customerCopy()[kind]} ${errorId}`;
+	const text = customerCopy(_locale)[kind];
+	return text === void 0 ? errorId : `${text} ${errorId}`;
 }
 function customerText(text, locale = currentLocale()) {
 	if (!isTechnicalText(text)) return text;
@@ -118,6 +120,7 @@ function safeTelegramFetch(fetchImpl, scope = "telegram", previews = {}) {
 		"sendMessage",
 		"editMessageText",
 		"editMessageCaption",
+		"editMessageReplyMarkup",
 		"answerCallbackQuery",
 		"sendPhoto",
 		"sendDocument",
@@ -160,14 +163,13 @@ function safeTelegramFetch(fetchImpl, scope = "telegram", previews = {}) {
 		const markup = body.reply_markup;
 		if (Array.isArray(markup?.inline_keyboard)) {
 			if ((textBlocked || typeof body.text === "string" && body.text.length > 4096) && markup.inline_keyboard.some((row) => row.some((button) => typeof button.callback_data === "string" && button.callback_data.startsWith("ss-confirm:")))) throw new Error("Approval buttons require the complete, safe confirmation text.");
-			markup.inline_keyboard = markup.inline_keyboard.map((row) => row.map((button) => {
-				if (typeof button.text !== "string" || !isTechnicalText(button.text)) return button;
+			const rows = markup.inline_keyboard.map((row) => row.filter((button) => {
+				if (typeof button.text !== "string" || !isTechnicalText(button.text)) return true;
 				reportTelegramError("technical_button_label_blocked", { text: button.text });
-				return {
-					...button,
-					text: "➡️"
-				};
-			}));
+				return false;
+			})).filter((row) => row.length > 0);
+			if (rows.length === 0 && markup.inline_keyboard.length > 0) delete body.reply_markup;
+			else markup.inline_keyboard = rows;
 		}
 		const send = async () => {
 			const parts = url.endsWith("/sendMessage") && typeof body.text === "string" && !isExactChatPostCard(body.text) ? splitTelegramText({

package/dist/_chunks/principal-VFQWqe5S.mjs

@@ -0,0 +1,126 @@
+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 { n as currentInboundRequest } from "./inbound-request-BXhiIph-.mjs";
+import { randomUUID } from "node:crypto";
+function telegramRuntimeSource(message, files, callbackQueryId) {
+	const attachments = [];
+	for (const file of message.attachments) {
+		const staged = files?.get(file.fileId);
+		if (staged?.status !== "stored" || attachments.length >= 10) continue;
+		let kind = file.kind;
+		for (const candidate of [
+			"voice",
+			"audio",
+			"video",
+			"video_note",
+			"sticker",
+			"animation"
+		]) {
+			const raw = message.raw[candidate];
+			if (raw !== null && typeof raw === "object" && !Array.isArray(raw) && raw.file_id === file.fileId) kind = candidate;
+		}
+		attachments.push({
+			file_id: file.fileId,
+			kind,
+			staged_id: staged.attachment.id,
+			...file.fileUniqueId === void 0 ? {} : { file_unique_id: file.fileUniqueId },
+			media_type: staged.attachment.contentType
+		});
+	}
+	return {
+		provider: "telegram",
+		chat_id: message.chat.id,
+		thread_id: String(message.messageThreadId ?? ""),
+		message_id: message.messageId,
+		...message.replyToMessage === void 0 ? {} : { reply_to_message_id: message.replyToMessage.messageId },
+		...message.from === void 0 ? {} : { sender: message.from.id },
+		...callbackQueryId === void 0 ? {} : { callback_query_id: callbackQueryId },
+		...attachments.length === 0 ? {} : { attachments }
+	};
+}
+function principalRuntimeSource(principal) {
+	if (principal?.authenticator !== "segmentstream-telegram") return;
+	const value = principal.attributes.segmentstreamRuntimeSource;
+	if (typeof value !== "string") return;
+	try {
+		return JSON.parse(value);
+	} catch {
+		return;
+	}
+}
+function runtimeEnvelope(input = {}) {
+	const source = input.source ?? principalRuntimeSource(input.principal);
+	return {
+		version: 1,
+		session_id: input.sessionId ?? randomUUID(),
+		call_id: input.callId ?? randomUUID(),
+		...source === void 0 ? {} : { source }
+	};
+}
+function compatibleRuntimeEnvelope(envelope, extended) {
+	const source = envelope.source;
+	return extended || source === void 0 ? envelope : {
+		...envelope,
+		source: {
+			provider: source.provider,
+			chat_id: source.chat_id,
+			thread_id: source.thread_id
+		}
+	};
+}
+const RUNTIME_SOURCE_PROTOCOL = "segmentstream/runtime-source";
+const TELEGRAM_AUTHENTICATOR = "segmentstream-telegram";
+function isGroup(message) {
+	return message.chat.type === "group" || message.chat.type === "supergroup";
+}
+function telegramPrincipal(input) {
+	const { message, member } = input;
+	const sender = message.from.id;
+	const attributes = {
+		memberId: member.id,
+		segmentstreamRuntimeSource: JSON.stringify(telegramRuntimeSource(message, currentInboundRequest()?.files, input.callbackQueryId)),
+		identityProvider: "telegram",
+		roles: member.roles,
+		chatId: message.chat.id,
+		chatType: message.chat.type
+	};
+	if (member.name !== null) attributes.memberName = member.name;
+	if (message.messageThreadId !== void 0) attributes.messageThreadId = String(message.messageThreadId);
+	if (message.from.username !== void 0) attributes.username = message.from.username;
+	const locale = member.locale ?? message.from.languageCode;
+	if (locale !== void 0) attributes.locale = locale;
+	const language = input.conversationLanguage ?? conversationLanguage([message.text || message.caption]);
+	if (language !== void 0) attributes.conversationLanguage = language;
+	return {
+		authenticator: TELEGRAM_AUTHENTICATOR,
+		issuer: "telegram",
+		principalId: isGroup(message) ? `telegram:${message.chat.id}:${sender}` : `telegram:${sender}`,
+		principalType: "user",
+		subject: sender,
+		attributes
+	};
+}
+function conversationLanguage(texts) {
+	for (const text of texts) {
+		if (/[\u0430-\u044f\u0451]/iu.test(text)) return "ru";
+		if ((text.match(/\b[a-z]+\b/gi)?.length ?? 0) >= 3) return "en";
+	}
+}
+function memberIdOf(principal) {
+	const memberId = principal?.attributes.memberId;
+	return typeof memberId === "string" && memberId !== "" ? memberId : void 0;
+}
+function rolesOf(principal) {
+	const roles = principal?.attributes.roles;
+	if (typeof roles === "string") return [roles];
+	return roles ?? [];
+}
+function identityProviderOf(principal) {
+	const provider = principal?.attributes.identityProvider;
+	return typeof provider === "string" && provider !== "" ? provider : void 0;
+}
+export { rolesOf as a, compatibleRuntimeEnvelope as c, telegramRuntimeSource as d, memberIdOf as i, principalRuntimeSource as l, conversationLanguage as n, telegramPrincipal as o, identityProviderOf as r, RUNTIME_SOURCE_PROTOCOL as s, TELEGRAM_AUTHENTICATOR as t, runtimeEnvelope as u };

package/dist/extension/_manifest.json

@@ -8,7 +8,6 @@
     "dynamicTool": 79,
     "channel": 58,
     "schedule": 31,
-    "connection": 46,
     "hook": 44,
     "instructions": 2,
     "dynamicInstructions": 37,

package/dist/extension/config.d.ts

@@ -1,5 +1,7 @@
 import { type GroupPolicyInput } from "@segmentstream-cloud/ontology/groups";
 import { type GroupPolicy } from "./lib/group-routing/policy.js";
+import type { WorkspaceActionHook } from "./lib/telegram/workspace-action.js";
+import { type TelegramTexts } from "./lib/telegram/texts.js";
 import type { AttachmentLifecycle } from "./lib/telegram/lifecycle.js";
 import { type TelegramLinkPreviews } from "@segmentstream-cloud/ontology/telegram";
 export declare const TELEGRAM_POLICIES: readonly ["mention", "smart"];
@@ -40,12 +42,13 @@ export interface FirstContactSettings {
     readonly version: string;
     readonly notice: LocalizedText;
 }
-export declare const ADMISSION_REPLY_KEYS: readonly ["limited", "perSenderLimited", "workspaceLimited", "registrationsLimited", "groupPairingRequired", "refused"];
+export declare const ADMISSION_REPLY_KEYS: readonly ["pairingRequired", "pairingButton", "groupPairingButton", "limited", "perSenderLimited", "workspaceLimited", "registrationsLimited", "groupPairingRequired", "refused"];
 export type AdmissionReplies = Partial<Record<(typeof ADMISSION_REPLY_KEYS)[number], LocalizedText>>;
 export interface AdmissionSettings {
     readonly firstContact: FirstContactSettings | null;
     readonly limits: AdmissionLimits;
     readonly replies: AdmissionReplies;
+    readonly texts?: TelegramTexts;
 }
 /**
  * `agent/segmentstream.json` as authored. A JSON import widens string literals to `string` and
@@ -54,6 +57,7 @@ export interface AdmissionSettings {
  */
 export interface SegmentStreamAgentConfigInput {
     readonly groups?: GroupPolicyInput;
+    readonly texts?: TelegramTexts;
     readonly firstContact?: FirstContactSettings;
     readonly limits?: AdmissionLimitsInput;
     readonly replies?: AdmissionReplies;
@@ -72,6 +76,12 @@ export interface SegmentStreamAgentConfigInput {
             readonly linkPreviews?: string;
             /** Additional exact HTTP(S) origins belonging to this workspace. */
             readonly additionalOwnOrigins?: readonly string[];
+            readonly callbacks?: Omit<WorkspaceActionHook, "contextVersion"> & {
+                readonly contextVersion: number;
+            };
+            readonly menuButton?: {
+                readonly text: LocalizedText;
+            };
             readonly attachmentLifecycle?: Omit<AttachmentLifecycle, "contextVersion"> & {
                 readonly contextVersion?: number;
             };
@@ -102,7 +112,7 @@ export interface SegmentStreamAgentConfigInput {
         readonly connection?: boolean;
     };
     readonly confirmations?: {
-        /** `deferred` (default) returns immediately; `held` uses eve approval. */
+        /** `deferred` (default) returns immediately. Eve button approvals are unsupported. */
         readonly mode?: string;
     };
     readonly sessions?: {
@@ -128,11 +138,15 @@ export interface TelegramSettings {
         readonly topicScope?: boolean;
         readonly commandsAddress?: boolean;
     };
+    readonly callbacks?: WorkspaceActionHook;
     readonly connection: string;
     readonly policy: TelegramPolicy;
     readonly linkPreviews?: TelegramLinkPreviews;
     readonly additionalOwnOrigins?: readonly string[];
     readonly attachmentLifecycle?: AttachmentLifecycle;
+    readonly menuButton?: {
+        readonly text: LocalizedText;
+    };
 }
 /** The chat models `segmentstream.model()` chooses between, as AI Gateway model ids. */
 export interface ChatModelChoice {
@@ -175,7 +189,7 @@ export interface SegmentStreamAgentConfig extends AdmissionSettings {
         readonly connection: boolean;
     };
     readonly confirmations: {
-        readonly mode: "deferred" | "held";
+        readonly mode: "deferred";
     };
     readonly sessions: SessionSettings;
 }
@@ -196,8 +210,12 @@ export declare class SegmentStreamAgentConfigError extends Error {
     readonly name = "SegmentStreamAgentConfigError";
     constructor(issues: ReadonlyArray<ConfigIssue>);
 }
+/** Exact historical pins retain the pre-0.13 presentation contract at the archive boundary. */
+export declare function isLegacyAgentArchive(version: string | undefined): boolean;
 /** Validates the authored configuration and applies the defaults. */
-export declare function validateConfig(input: unknown): Validation;
+export declare function validateConfig(input: unknown, options?: {
+    readonly archiveSdkVersion?: string;
+}): Validation;
 /**
  * The Standard Schema eve validates the mount with. `types` exists only for type inference, as the
  * Standard Schema specification allows.
@@ -206,7 +224,7 @@ export declare const configSchema: {
     readonly "~standard": {
         readonly version: 1;
         readonly vendor: "segmentstream";
-        readonly validate: typeof validateConfig;
+        readonly validate: (input: unknown) => Validation;
         readonly types: {
             readonly input: SegmentStreamAgentConfigInput;
             readonly output: SegmentStreamAgentConfig;