@rivus/agent 0.6.1 → 0.7.0

package/dist/pi-tool-proxy.d.ts

@@ -94,6 +94,9 @@ interface InvocationAuthorityRef {
 }
 interface InvocationAuthority {
   readonly agentId: string;
+  readonly allowedActorOpenIds?: ReadonlyArray<string>;
+  readonly conversationId?: string;
+  readonly endpointId?: string;
   readonly instanceId: string;
   readonly memory?: AgentMemoryAuthority;
   readonly runId: string;

package/dist/pi.js

@@ -88,6 +88,9 @@ function createPiToolProxyDefinitions(options) {
 				const result = await options.broker.execute({
 					authority: createInvocationAuthority({
 						agentId: options.agentId,
+						allowedActorOpenIds: invocation.allowedActorOpenIds,
+						...invocation.memory?.conversationId ? { conversationId: invocation.memory.conversationId } : {},
+						endpointId: invocation.endpointId,
 						instanceId: options.instanceId,
 						...invocation.memory ? { memory: {
 							...invocation.memory,

package/dist/rivus-daemon-cli.js

@@ -1,5 +1,5 @@
 import { t as MEMORY_SCOPES } from "./agent-memory.js";
-import { n as resolveRivusAgentDefinition, r as deepFreeze, t as createRivusPluginCatalog } from "./rivus-plugin-registry.js";
+import { h as narrowBackgroundSessionDefinition, n as resolveRivusAgentDefinition, r as deepFreeze, t as createRivusPluginCatalog } from "./rivus-plugin-registry.js";
 import { createRequire } from "node:module";
 import { Effect } from "effect";
 import { createHash, randomUUID } from "node:crypto";
@@ -109,7 +109,7 @@ async function loadRivusDeployment(options) {
 			continue;
 		}
 		try {
-			const baseDefinition = resolveRivusAgentDefinition(catalog, agent);
+			const baseDefinition = resolveRivusAgentDefinition(catalog, agent, { backgroundSessions: options.manifest.backgroundSessions?.enabled === true });
 			const projectSpace = agent.projectSpaceId ? options.manifest.projectSpaces?.find(({ id }) => id === agent.projectSpaceId) : void 0;
 			const definition = projectSpace ? deepFreeze({
 				...baseDefinition,
@@ -224,6 +224,13 @@ function validateRivusDeploymentManifest(manifest) {
 	if (!defaultEndpoint) throw new Error(`default endpoint does not exist: ${manifest.defaultEndpointId}`);
 	if (defaultEndpoint.agentId !== defaultAgent.agentId) throw new Error("default endpoint is not bound to the default agent");
 	if (!defaultEndpoint.enabled) throw new Error("default endpoint must be enabled");
+	if (manifest.backgroundSessions) validateBackgroundSessions(manifest.backgroundSessions);
+}
+function validateBackgroundSessions(config) {
+	if (config.required && !config.enabled) throw new Error("backgroundSessions.required requires backgroundSessions.enabled");
+	if (config.leaseRenewalIntervalMs >= config.leaseMs) throw new Error("backgroundSessions.leaseRenewalIntervalMs must be shorter than leaseMs");
+	if (config.stepTimeoutMs <= 0 || config.maxConcurrentSessions <= 0 || config.leaseMs <= 0) throw new Error("backgroundSessions durations and concurrency must be positive");
+	if (config.retryBackoffMs <= 0 || config.sessionLifetimeMs <= 0 || config.maxConsecutiveFailures <= 0) throw new Error("backgroundSessions retry and lifetime limits must be positive");
 }
 function validateRelativeProjectPath(value, owner) {
 	if (value.trim() === "" || isAbsolute(value) || value.includes("\0")) throw new Error(`${owner} must be a non-empty relative path`);
@@ -433,6 +440,7 @@ function createFeishuCardRollover(options) {
 	const leaseMs = options.leaseMs ?? 51e4;
 	if (!Number.isSafeInteger(leaseMs) || leaseMs < 1) throw new Error("Feishu card stream lease must be a positive integer");
 	const counters = createCounters();
+	const latestTextByRun = /* @__PURE__ */ new Map();
 	const liveRuns = /* @__PURE__ */ new Map();
 	const semaphore = Effect.unsafeMakeSemaphore(1);
 	const exclusive = (effect) => semaphore.withPermits(1)(effect);
@@ -448,7 +456,7 @@ function createFeishuCardRollover(options) {
 	const presentationId = (runId, generation) => `${runId}#${generation}`;
 	const publishProgress = (action) => Effect.suspend(() => {
 		const chain = options.store.chain(action.runId);
-		if (chain && acceptsCardPresentationProgress(chain)) return options.publisher.publish(action);
+		if (chain && acceptsCardPresentationProgress(chain)) return options.publisher.publish(action).pipe(Effect.tap(() => Effect.sync(() => latestTextByRun.set(action.runId, action.text))));
 		return recordNow({
 			...chain ? {
 				generation: chain.activeGeneration,
@@ -458,20 +466,28 @@ function createFeishuCardRollover(options) {
 			type: "stale_update_dropped"
 		});
 	});
-	const publishTerminal = (action) => options.publisher.publish(action).pipe(Effect.tapError((error) => recordNow({
-		error,
-		runId: action.runId,
-		type: "terminal_delivery_failed"
-	})), Effect.tap(() => options.store.markTerminal({
-		runId: action.runId,
-		terminalReceiptId: `${action.runId}:${action.type}`
-	}).pipe(Effect.catchAll((error) => recordNow({
-		error,
-		runId: action.runId,
-		type: "presentation_write_failed"
-	})))), Effect.ensuring(Effect.sync(() => {
-		liveRuns.delete(action.runId);
-	})));
+	const publishTerminal = (action) => {
+		const latestText = latestTextByRun.get(action.runId);
+		const resolvedAction = action.type === "cancel" && action.text === void 0 && latestText !== void 0 ? {
+			...action,
+			text: latestText
+		} : action;
+		return options.publisher.publish(resolvedAction).pipe(Effect.tapError((error) => recordNow({
+			error,
+			runId: action.runId,
+			type: "terminal_delivery_failed"
+		})), Effect.tap(() => options.store.markTerminal({
+			runId: action.runId,
+			terminalReceiptId: `${action.runId}:${action.type}`
+		}).pipe(Effect.catchAll((error) => recordNow({
+			error,
+			runId: action.runId,
+			type: "presentation_write_failed"
+		})))), Effect.ensuring(Effect.sync(() => {
+			latestTextByRun.delete(action.runId);
+			liveRuns.delete(action.runId);
+		})));
+	};
 	const publishAction = (action) => {
 		switch (action.type) {
 			case "update_text": return publishProgress(action);
@@ -505,6 +521,7 @@ function createFeishuCardRollover(options) {
 		};
 		const predecessor = start.presentation;
 		const generation = predecessor.generation + 1;
+		const text = latestTextByRun.get(runId);
 		record({
 			cardId: predecessor.cardId,
 			generation,
@@ -517,7 +534,8 @@ function createFeishuCardRollover(options) {
 		const created = yield* options.createSuccessor({
 			generation,
 			presentationId: successorId,
-			run
+			run,
+			...text === void 0 ? {} : { text }
 		}).pipe(Effect.map((target) => ({ target })), Effect.catchAll((error) => options.store.failHandoff({
 			failedAt: startedAt.toISOString(),
 			runId
@@ -539,6 +557,7 @@ function createFeishuCardRollover(options) {
 		};
 		yield* options.publisher.publish({
 			runId,
+			...text === void 0 ? {} : { text },
 			type: "handoff"
 		}).pipe(Effect.catchAll((error) => recordNow({
 			cardId: predecessor.cardId,
@@ -584,6 +603,7 @@ function createFeishuCardRollover(options) {
 				runId: run.runId,
 				sourceMessageId: run.messageId
 			});
+			latestTextByRun.delete(run.runId);
 			liveRuns.set(run.runId, run);
 			return presentation;
 		})),
@@ -605,6 +625,7 @@ function createFeishuCardRollover(options) {
 		},
 		publish: (action) => exclusive(publishAction(action)),
 		releaseRun: (runId) => Effect.sync(() => {
+			latestTextByRun.delete(runId);
 			liveRuns.delete(runId);
 		}),
 		recover: () => exclusive(Effect.gen(function* () {
@@ -642,6 +663,19 @@ function createCounters() {
 	};
 }
 //#endregion
+//#region src/application/background-session/background-session-config.ts
+const DEFAULT_BACKGROUND_SESSION_STEP_TIMEOUT_MS = 300 * 1e3;
+const DEFAULT_BACKGROUND_SESSION_MAX_CONCURRENT_SESSIONS = 4;
+const DEFAULT_BACKGROUND_SESSION_LEASE_MS = 3e4;
+const DEFAULT_BACKGROUND_SESSION_LEASE_RENEWAL_INTERVAL_MS = 1e4;
+const DEFAULT_BACKGROUND_SESSION_MAX_CONSECUTIVE_FAILURES = 3;
+const DEFAULT_BACKGROUND_SESSION_RETRY_BACKOFF_MS = 3e4;
+const DEFAULT_BACKGROUND_SESSION_LIFETIME_MS = 1440 * 60 * 1e3;
+const DEFAULT_BACKGROUND_SESSION_SUPERVISOR_INTERVAL_MS = 1e3;
+function resolveBackgroundSessionSupervisorIntervalMs(leaseMs) {
+	return Math.min(5e3, Math.max(200, Math.floor(leaseMs / 10)));
+}
+//#endregion
 //#region src/infrastructure/config/rivus-deployment-manifest.ts
 var RivusDeploymentManifestError = class extends Error {
 	manifestPath;
@@ -670,12 +704,17 @@ function parseManifest(value) {
 	exactKeys(root, [
 		"agents",
 		"automations",
+		"backgroundSessions",
 		"defaultAgentId",
 		"defaultEndpointId",
 		"endpoints",
 		"plugins",
 		"projectSpaces"
-	], "manifest", ["automations", "projectSpaces"]);
+	], "manifest", [
+		"automations",
+		"backgroundSessions",
+		"projectSpaces"
+	]);
 	const plugins = array(root.plugins, "manifest.plugins").map((entry, index) => {
 		const plugin = record(entry, `manifest.plugins[${index}]`);
 		exactKeys(plugin, [
@@ -802,9 +841,11 @@ function parseManifest(value) {
 			workingDirectory: string(projectSpace.workingDirectory, `manifest.projectSpaces[${index}].workingDirectory`)
 		});
 	});
+	const backgroundSessions = root.backgroundSessions === void 0 ? void 0 : parseBackgroundSessions(record(root.backgroundSessions, "manifest.backgroundSessions"));
 	return Object.freeze({
 		agents: Object.freeze(agents),
 		automations: Object.freeze(automations),
+		...backgroundSessions ? { backgroundSessions } : {},
 		defaultAgentId: string(root.defaultAgentId, "manifest.defaultAgentId"),
 		defaultEndpointId: string(root.defaultEndpointId, "manifest.defaultEndpointId"),
 		endpoints: Object.freeze(endpoints),
@@ -812,6 +853,38 @@ function parseManifest(value) {
 		projectSpaces: Object.freeze(projectSpaces)
 	});
 }
+function parseBackgroundSessions(value) {
+	exactKeys(value, [
+		"enabled",
+		"leaseMs",
+		"leaseRenewalIntervalMs",
+		"maxConsecutiveFailures",
+		"maxConcurrentSessions",
+		"required",
+		"retryBackoffMs",
+		"sessionLifetimeMs",
+		"stepTimeoutMs"
+	], "manifest.backgroundSessions", [
+		"leaseMs",
+		"leaseRenewalIntervalMs",
+		"maxConsecutiveFailures",
+		"maxConcurrentSessions",
+		"retryBackoffMs",
+		"sessionLifetimeMs",
+		"stepTimeoutMs"
+	]);
+	return Object.freeze({
+		enabled: boolean(value.enabled, "manifest.backgroundSessions.enabled"),
+		required: boolean(value.required, "manifest.backgroundSessions.required"),
+		stepTimeoutMs: positiveInteger(value.stepTimeoutMs ?? 3e5, "manifest.backgroundSessions.stepTimeoutMs"),
+		maxConcurrentSessions: positiveInteger(value.maxConcurrentSessions ?? 4, "manifest.backgroundSessions.maxConcurrentSessions"),
+		leaseMs: positiveInteger(value.leaseMs ?? 3e4, "manifest.backgroundSessions.leaseMs"),
+		leaseRenewalIntervalMs: positiveInteger(value.leaseRenewalIntervalMs ?? 1e4, "manifest.backgroundSessions.leaseRenewalIntervalMs"),
+		maxConsecutiveFailures: positiveInteger(value.maxConsecutiveFailures ?? 3, "manifest.backgroundSessions.maxConsecutiveFailures"),
+		retryBackoffMs: positiveInteger(value.retryBackoffMs ?? 3e4, "manifest.backgroundSessions.retryBackoffMs"),
+		sessionLifetimeMs: positiveInteger(value.sessionLifetimeMs ?? 864e5, "manifest.backgroundSessions.sessionLifetimeMs")
+	});
+}
 function record(value, path) {
 	if (value === null || typeof value !== "object" || Array.isArray(value)) throw new Error(`${path} must be an object`);
 	return value;
@@ -1178,7 +1251,7 @@ function createAgentInstanceRegistry(options = {}) {
 			skillGrantRevision: definition.skillGrantSet.revision,
 			toolGrantRevision: definition.toolGrantSet.revision
 		});
-		const bindingId = binding.kind === "endpoint" ? binding.endpointId : binding.automationId;
+		const bindingId = binding.kind === "endpoint" ? binding.endpointId : binding.kind === "automation" ? binding.automationId : binding.agentId;
 		const bindingKey = `${binding.kind}:${bindingId}:${definition.agentId}`;
 		const existing = records.get(bindingKey);
 		if (existing) {
@@ -1203,6 +1276,10 @@ function createAgentInstanceRegistry(options = {}) {
 			automationId,
 			kind: "automation"
 		}, definition),
+		resolveBackgroundSession: (agentId, definition) => resolveBinding({
+			agentId,
+			kind: "background-session"
+		}, definition),
 		resolveEndpoint: (endpointId, definition) => resolveBinding({
 			endpointId,
 			kind: "endpoint"
@@ -1282,6 +1359,7 @@ function createRivusAgentHost(options) {
 	const definitions = new Map(options.definitions.map((definition) => [definition.agentId, definition]));
 	const endpoints = /* @__PURE__ */ new Map();
 	const automations = /* @__PURE__ */ new Map();
+	const backgroundSessions = /* @__PURE__ */ new Map();
 	for (const endpoint of options.endpoints) {
 		if (endpoints.has(endpoint.id)) throw new InvalidRivusEndpointBinding(`duplicate endpoint: ${endpoint.id}`);
 		const definition = definitions.get(endpoint.agentId);
@@ -1294,6 +1372,11 @@ function createRivusAgentHost(options) {
 		if (!definitions.has(automation.definition.agentId)) throw new InvalidRivusEndpointBinding(`unknown automation agent: ${automation.definition.agentId}`);
 		automations.set(automation.id, options.runtimePool.registry.resolveAutomation(automation.id, automation.definition));
 	}
+	for (const backgroundSession of options.backgroundSessions ?? []) {
+		if (backgroundSessions.has(backgroundSession.agentId)) throw new InvalidRivusEndpointBinding(`duplicate background session agent: ${backgroundSession.agentId}`);
+		if (!definitions.has(backgroundSession.agentId)) throw new InvalidRivusEndpointBinding(`unknown background session agent: ${backgroundSession.agentId}`);
+		backgroundSessions.set(backgroundSession.agentId, options.runtimePool.registry.resolveBackgroundSession(backgroundSession.agentId, backgroundSession.definition));
+	}
 	const resolveEndpoint = (endpointId) => {
 		const instance = endpoints.get(endpointId);
 		if (!instance) throw new InvalidRivusEndpointBinding(`unknown endpoint: ${endpointId}`);
@@ -1304,11 +1387,19 @@ function createRivusAgentHost(options) {
 		if (!instance) throw new InvalidRivusEndpointBinding(`unknown automation: ${automationId}`);
 		return instance;
 	};
+	const resolveBackgroundSession = (agentId) => {
+		const instance = backgroundSessions.get(agentId);
+		if (!instance) throw new InvalidRivusEndpointBinding(`unknown background session agent: ${agentId}`);
+		return instance;
+	};
 	return {
+		cancelBackgroundSession: (agentId, input) => options.runtimePool.cancel(resolveBackgroundSession(agentId), input),
 		cancelEndpoint: (endpointId, input) => options.runtimePool.cancel(resolveEndpoint(endpointId), input),
 		handleAutomation: (automationId, input) => options.runtimePool.run(resolveAutomation(automationId), input),
+		handleBackgroundSession: (agentId, input) => options.runtimePool.run(resolveBackgroundSession(agentId), input),
 		handleEndpoint: (endpointId, input) => options.runtimePool.run(resolveEndpoint(endpointId), input),
 		resolveAutomation,
+		resolveBackgroundSession,
 		resolveEndpoint
 	};
 }
@@ -1345,9 +1436,15 @@ async function createRivusDeploymentDaemon(options) {
 	})));
 	const definitions = new Map(deployment.definitions.map((definition) => [definition.agentId, definition]));
 	const automationDefinitions = new Map(deployment.automationDefinitions.map((definition) => [definition.id, definition]));
+	const backgroundSessionsConfig = deployment.manifest.backgroundSessions;
+	const backgroundDefinitions = /* @__PURE__ */ new Map();
+	if (backgroundSessionsConfig?.enabled) for (const agent of deployment.agents) {
+		if (agent.status !== "enabled" || !agent.definition) continue;
+		backgroundDefinitions.set(agent.agentId, narrowBackgroundSessionDefinition(agent.definition));
+	}
 	const runtimePool = createAgentRuntimePool({
 		createRuntime: (instance) => {
-			const definition = instance.binding.kind === "automation" ? automationDefinitions.get(instance.binding.automationId)?.runtimeDefinition : definitions.get(instance.agentId);
+			const definition = instance.binding.kind === "automation" ? automationDefinitions.get(instance.binding.automationId)?.runtimeDefinition : instance.binding.kind === "background-session" ? backgroundDefinitions.get(instance.agentId) : definitions.get(instance.agentId);
 			if (!definition) throw new RivusDeploymentDaemonLifecycleError(`runtime instance references unknown agent: ${instance.agentId}`);
 			const projectSpace = definition.projectSpaceId ? projectSpaces.get(definition.projectSpaceId) : void 0;
 			return options.createRuntime({
@@ -1378,11 +1475,20 @@ async function createRivusDeploymentDaemon(options) {
 			lifecycle: definition.enabled && agentEnabled ? "stopped" : "disabled"
 		};
 	});
+	const backgroundSessionSlot = backgroundSessionsConfig ? {
+		agentEnabled: backgroundDefinitions.size > 0,
+		definition: backgroundSessionsConfig,
+		lifecycle: backgroundSessionsConfig.enabled && backgroundDefinitions.size > 0 ? "stopped" : "disabled"
+	} : void 0;
 	const host = createRivusAgentHost({
 		automations: automationSlots.filter((slot) => slot.definition.enabled && slot.agentEnabled && slot.resolvedDefinition !== void 0).map((slot) => ({
 			definition: slot.resolvedDefinition.runtimeDefinition,
 			id: slot.definition.id
 		})),
+		...backgroundSessionSlot ? { backgroundSessions: [...backgroundDefinitions].map(([agentId, definition]) => ({
+			agentId,
+			definition
+		})) } : {},
 		definitions: deployment.definitions,
 		endpoints: slots.filter((slot) => slot.definition.enabled && slot.agentEnabled).map((slot) => ({
 			agentId: slot.definition.agentId,
@@ -1410,7 +1516,15 @@ async function createRivusDeploymentDaemon(options) {
 		agentId: slot.definition.agentId,
 		automationId: slot.definition.id
 	});
-	const allSlots = [...slots, ...automationSlots];
+	const backgroundSessionStatus = (slot) => Object.freeze({
+		...componentStatus(slot),
+		...slot.adapter?.status ? { supervisor: slot.adapter.status() } : {}
+	});
+	const allSlots = [
+		...slots,
+		...automationSlots,
+		...backgroundSessionSlot ? [backgroundSessionSlot] : []
+	];
 	const isReady = () => allSlots.every(isSlotReady);
 	const failedRequiredEndpointIds = () => slots.filter((slot) => slot.definition.enabled && slot.definition.required && slot.lifecycle !== "running").map((slot) => slot.definition.id);
 	const failedRequiredAutomationIds = () => automationSlots.filter((slot) => slot.definition.enabled && slot.definition.required && slot.lifecycle !== "running").map((slot) => slot.definition.id);
@@ -1423,6 +1537,7 @@ async function createRivusDeploymentDaemon(options) {
 	const status = () => Object.freeze({
 		agents: deployment.agents,
 		automations: Object.freeze(automationSlots.map(automationStatus)),
+		...backgroundSessionSlot ? { backgroundSessions: backgroundSessionStatus(backgroundSessionSlot) } : {},
 		defaultAgentId: deployment.manifest.defaultAgentId,
 		defaultEndpointId: deployment.manifest.defaultEndpointId,
 		endpoints: Object.freeze(slots.map(endpointStatus)),
@@ -1487,6 +1602,18 @@ async function createRivusDeploymentDaemon(options) {
 				});
 				degraded ||= slotDegraded;
 			}
+			if (backgroundSessionSlot) {
+				const slotDegraded = await startSlot(backgroundSessionSlot, true, async () => {
+					if (!options.createBackgroundSession) throw new RivusDeploymentDaemonLifecycleError("deployment bootstrap does not provide Background Session adapters");
+					return options.createBackgroundSession({
+						agentIds: [...backgroundDefinitions.keys()],
+						cancel: (input) => host.cancelBackgroundSession(input.agentId, input),
+						config: backgroundSessionSlot.definition,
+						run: (input) => host.handleBackgroundSession(input.agentId, input)
+					});
+				});
+				degraded ||= slotDegraded;
+			}
 			lifecycle = degraded ? "degraded" : "running";
 			assertRequiredReadiness();
 		},
@@ -1500,6 +1627,7 @@ async function createRivusDeploymentDaemon(options) {
 			lifecycle = "stopping";
 			const errors = [];
 			await stopSlots(automationSlots, errors);
+			if (backgroundSessionSlot) await stopSlots([backgroundSessionSlot], errors);
 			await stopSlots(slots, errors);
 			try {
 				await runtimePool.disposeAll();
@@ -1640,6 +1768,7 @@ async function createConfiguredRivusDeploymentDaemon(options) {
 	const manifest = await loadRivusDeploymentManifest(options.manifestPath, options.manifestOptions);
 	return createRivusDeploymentDaemon({
 		...options.createAutomation ? { createAutomation: options.createAutomation } : {},
+		...options.createBackgroundSession ? { createBackgroundSession: options.createBackgroundSession } : {},
 		createEndpoint: options.createEndpoint,
 		createRuntime: options.createRuntime,
 		deploymentRoot: dirname(options.manifestPath),
@@ -2954,6 +3083,17 @@ function toRedactedDeploymentManifest(manifest) {
 			templateId,
 			timeZone
 		})),
+		...manifest.backgroundSessions ? { backgroundSessions: {
+			enabled: manifest.backgroundSessions.enabled,
+			leaseMs: manifest.backgroundSessions.leaseMs,
+			leaseRenewalIntervalMs: manifest.backgroundSessions.leaseRenewalIntervalMs,
+			maxConsecutiveFailures: manifest.backgroundSessions.maxConsecutiveFailures,
+			maxConcurrentSessions: manifest.backgroundSessions.maxConcurrentSessions,
+			required: manifest.backgroundSessions.required,
+			retryBackoffMs: manifest.backgroundSessions.retryBackoffMs,
+			sessionLifetimeMs: manifest.backgroundSessions.sessionLifetimeMs,
+			stepTimeoutMs: manifest.backgroundSessions.stepTimeoutMs
+		} } : {},
 		defaultAgentId: manifest.defaultAgentId,
 		defaultEndpointId: manifest.defaultEndpointId,
 		endpoints: manifest.endpoints.map(({ agentId, credentialRef, enabled, id, required, sessionNamespace }) => ({
@@ -3095,4 +3235,4 @@ function hasRecoveryRunner(daemon) {
 	return typeof daemon.openRecoveryControl === "function";
 }
 //#endregion
-export { CardPresentationTransitionDenied as A, FeishuEndpointCredentialError as B, loadRivusDaemonConfig as C, loadRivusDeploymentManifest as D, RivusDeploymentManifestError as E, completeCardPresentationHandoff as F, validateRivusDeploymentManifest as G, loadMergedLocalEnvFile as H, createCardPresentationChain as I, failCardPresentationHandoff as L, activeCardPresentation as M, beginCardPresentationHandoff as N, DEFAULT_CARD_STREAM_LEASE_MS as O, compensateCardPresentationHandoff as P, isCardPresentationHandoffDue as R, RivusDaemonConfigError as S, resolveNodeRivusPluginModulePath as T, RivusPluginLoadError as U, resolveFeishuEndpointCredentials as V, loadRivusDeployment as W, createStableId as _, InvalidRivusProjectSpace as a, createRivusEnvFromOpenClawConfig as b, RivusDeploymentReadinessError as c, createRivusAgentHost as d, AgentInstanceBusy as f, createAgentInstanceRegistry as g, AgentInstanceConflict as h, resolveRivusProjectSpace as i, acceptsCardPresentationProgress as j, createFeishuCardRollover as k, createRivusDeploymentDaemon as l, createAgentRuntimePool as m, createRivusDeploymentCliProcess as n, RivusDeploymentAutomationReadinessError as o, AgentRuntimeDisposed as p, createConfiguredRivusDeploymentDaemon as r, RivusDeploymentDaemonLifecycleError as s, runRivusDaemonCli as t, InvalidRivusEndpointBinding as u, createRivusDaemonShutdownController as v, loadNodeRivusPluginModule as w, formatRivusEnvFile as x, OpenClawEnvImportError as y, markCardPresentationTerminal as z };
+export { loadRivusDeployment as $, DEFAULT_BACKGROUND_SESSION_LIFETIME_MS as A, acceptsCardPresentationProgress as B, loadRivusDaemonConfig as C, loadRivusDeploymentManifest as D, RivusDeploymentManifestError as E, DEFAULT_BACKGROUND_SESSION_SUPERVISOR_INTERVAL_MS as F, createCardPresentationChain as G, beginCardPresentationHandoff as H, resolveBackgroundSessionSupervisorIntervalMs as I, markCardPresentationTerminal as J, failCardPresentationHandoff as K, DEFAULT_CARD_STREAM_LEASE_MS as L, DEFAULT_BACKGROUND_SESSION_MAX_CONSECUTIVE_FAILURES as M, DEFAULT_BACKGROUND_SESSION_RETRY_BACKOFF_MS as N, DEFAULT_BACKGROUND_SESSION_LEASE_MS as O, DEFAULT_BACKGROUND_SESSION_STEP_TIMEOUT_MS as P, RivusPluginLoadError as Q, createFeishuCardRollover as R, RivusDaemonConfigError as S, resolveNodeRivusPluginModulePath as T, compensateCardPresentationHandoff as U, activeCardPresentation as V, completeCardPresentationHandoff as W, resolveFeishuEndpointCredentials as X, FeishuEndpointCredentialError as Y, loadMergedLocalEnvFile as Z, createStableId as _, InvalidRivusProjectSpace as a, createRivusEnvFromOpenClawConfig as b, RivusDeploymentReadinessError as c, createRivusAgentHost as d, validateRivusDeploymentManifest as et, AgentInstanceBusy as f, createAgentInstanceRegistry as g, AgentInstanceConflict as h, resolveRivusProjectSpace as i, DEFAULT_BACKGROUND_SESSION_MAX_CONCURRENT_SESSIONS as j, DEFAULT_BACKGROUND_SESSION_LEASE_RENEWAL_INTERVAL_MS as k, createRivusDeploymentDaemon as l, createAgentRuntimePool as m, createRivusDeploymentCliProcess as n, RivusDeploymentAutomationReadinessError as o, AgentRuntimeDisposed as p, isCardPresentationHandoffDue as q, createConfiguredRivusDeploymentDaemon as r, RivusDeploymentDaemonLifecycleError as s, runRivusDaemonCli as t, InvalidRivusEndpointBinding as u, createRivusDaemonShutdownController as v, loadNodeRivusPluginModule as w, formatRivusEnvFile as x, OpenClawEnvImportError as y, CardPresentationTransitionDenied as z };