@rivus/agent 0.1.0

package/dist/rivus-plugin-registry.js

@@ -0,0 +1,316 @@
+import { createHash } from "node:crypto";
+//#region src/domain/rivus-plugin.ts
+const RIVUS_PLUGIN_API_VERSION = "1";
+function requiresToolApproval(risk) {
+	return risk === "irreversible" || risk === "host-control";
+}
+var RivusToolInputRejected = class extends Error {
+	name = "RivusToolInputRejected";
+};
+var InvalidRivusPlugin = class extends Error {
+	name = "InvalidRivusPlugin";
+};
+//#endregion
+//#region src/domain/agent-memory.ts
+const MEMORY_SCOPES = [
+	"conversation",
+	"agent-private",
+	"shared-user-profile"
+];
+const RIVUS_MEMORY_TOOL_ID = "memory";
+const RIVUS_MEMORY_TOOL_PLUGIN_ID = "rivus-core";
+const RIVUS_MEMORY_TOOL_VERSION = "1.0.0";
+function createMemoryNamespace(binding) {
+	const encode = (value) => encodeURIComponent(value);
+	switch (binding.scope) {
+		case "conversation": return [
+			binding.tenantId,
+			binding.agentId,
+			binding.subjectId,
+			binding.conversationId ?? "",
+			binding.scope
+		].map(encode).join("/");
+		case "agent-private": return [
+			binding.tenantId,
+			binding.agentId,
+			binding.subjectId,
+			binding.scope
+		].map(encode).join("/");
+		case "shared-user-profile": return [
+			binding.tenantId,
+			binding.subjectId,
+			binding.scope
+		].map(encode).join("/");
+	}
+}
+function restrictMemoryScopesForAudience(scopes, audience) {
+	return audience === "group" ? scopes.filter((scope) => scope === "conversation") : [...scopes];
+}
+function createRivusMemoryToolContract(scopes) {
+	return Object.freeze({
+		description: "Search and read Memory inside Host-bound scopes; propose or request forgetting only in writable private scopes.",
+		digest: "sha256:rivus-memory-v3",
+		id: RIVUS_MEMORY_TOOL_ID,
+		idempotency: "required",
+		inputSchema: Object.freeze({
+			additionalProperties: false,
+			properties: {
+				command: {
+					description: "One of search, read, propose, or forget_request.",
+					enum: [
+						"search",
+						"read",
+						"propose",
+						"forget_request"
+					],
+					type: "string"
+				},
+				id: {
+					description: "Required for read and forget_request.",
+					minLength: 1,
+					type: "string"
+				},
+				input: {
+					additionalProperties: false,
+					description: "Required for propose.",
+					properties: { content: {
+						minLength: 1,
+						type: "string"
+					} },
+					required: ["content"],
+					type: "object"
+				},
+				query: {
+					additionalProperties: false,
+					description: "Required for search.",
+					properties: { query: { type: "string" } },
+					required: ["query"],
+					type: "object"
+				},
+				reason: {
+					description: "Optional reason for forget_request.",
+					type: "string"
+				},
+				...scopes.length === 0 ? {} : { scope: {
+					description: "Optional Host-granted scope for search or propose. Shared User Profile is read-only to the model.",
+					enum: [...scopes],
+					type: "string"
+				} }
+			},
+			required: ["command"],
+			type: "object"
+		}),
+		risk: "mutate",
+		version: RIVUS_MEMORY_TOOL_VERSION
+	});
+}
+//#endregion
+//#region src/application/plugin/deep-freeze.ts
+function deepFreeze(value) {
+	if (value !== null && typeof value === "object" && !Object.isFrozen(value)) {
+		Object.freeze(value);
+		for (const child of Object.values(value)) deepFreeze(child);
+	}
+	return value;
+}
+//#endregion
+//#region src/application/plugin/rivus-plugin-registry.ts
+function createRivusPluginCatalog() {
+	const plugins = /* @__PURE__ */ new Map();
+	const profiles = /* @__PURE__ */ new Map();
+	const tools = /* @__PURE__ */ new Map();
+	const skills = /* @__PURE__ */ new Map();
+	const automations = /* @__PURE__ */ new Map();
+	return {
+		registerPlugin: (plugin) => {
+			validateManifest(plugin.manifest);
+			rejectDuplicate(plugins, plugin.manifest.id, "plugin");
+			const pendingProfiles = [];
+			const pendingTools = [];
+			const pendingSkills = [];
+			const pendingAutomations = [];
+			const pendingIds = /* @__PURE__ */ new Set();
+			const register = (kind, definition, catalog, destination, namespaced) => {
+				validateIdentifier(definition.id, kind);
+				if (namespaced && !definition.id.startsWith(`${plugin.manifest.id}/`)) throw new InvalidRivusPlugin(`${kind} id ${definition.id} must use plugin namespace ${plugin.manifest.id}/`);
+				const key = `${kind}:${definition.id}`;
+				if (pendingIds.has(key) || catalog.has(definition.id)) throw new InvalidRivusPlugin(`duplicate ${kind} id: ${definition.id}`);
+				pendingIds.add(key);
+				destination.push(deepFreeze({
+					...definition,
+					pluginId: plugin.manifest.id
+				}));
+			};
+			plugin.register({
+				registerAgentProfile: (profile) => register("profile", profile, profiles, pendingProfiles, false),
+				registerAutomation: (automation) => register("automation", automation, automations, pendingAutomations, true),
+				registerSkill: (skill) => register("skill", skill, skills, pendingSkills, true),
+				registerTool: (tool) => register("tool", tool, tools, pendingTools, true)
+			});
+			const availableToolIds = /* @__PURE__ */ new Set([...tools.keys(), ...pendingTools.map(({ id }) => id)]);
+			const availableSkillIds = /* @__PURE__ */ new Set([...skills.keys(), ...pendingSkills.map(({ id }) => id)]);
+			const availableProfileIds = /* @__PURE__ */ new Set([...profiles.keys(), ...pendingProfiles.map(({ id }) => id)]);
+			for (const profile of pendingProfiles) {
+				validateMemoryScopes(profile.memory.scopes, `profile ${profile.id}`);
+				validateReferences(profile.tools.allow, availableToolIds, `profile ${profile.id}`, "tool");
+				validateReferences(profile.skills.allow, availableSkillIds, `profile ${profile.id}`, "skill");
+			}
+			for (const automation of pendingAutomations) {
+				if (!availableProfileIds.has(automation.profileId)) throw new InvalidRivusPlugin(`automation ${automation.id} references unknown profile: ${automation.profileId}`);
+				validateReferences(automation.requestedToolIds, availableToolIds, `automation ${automation.id}`, "tool");
+				validateReferences(automation.requestedSkillIds, availableSkillIds, `automation ${automation.id}`, "skill");
+			}
+			plugins.set(plugin.manifest.id, deepFreeze({ ...plugin.manifest }));
+			for (const profile of pendingProfiles) profiles.set(profile.id, profile);
+			for (const tool of pendingTools) tools.set(tool.id, tool);
+			for (const skill of pendingSkills) skills.set(skill.id, skill);
+			for (const automation of pendingAutomations) automations.set(automation.id, automation);
+		},
+		snapshot: () => deepFreeze({
+			automations: [...automations.values()],
+			plugins: [...plugins.values()],
+			profiles: [...profiles.values()],
+			skills: [...skills.values()],
+			tools: [...tools.values()]
+		})
+	};
+}
+function resolveRivusAgentDefinition(catalog, deployment) {
+	const snapshot = catalog.snapshot();
+	const plugin = snapshot.plugins.find((candidate) => candidate.id === deployment.pluginId);
+	if (!plugin) throw new InvalidRivusPlugin(`unknown deployment plugin: ${deployment.pluginId}`);
+	const profile = snapshot.profiles.find((candidate) => candidate.id === deployment.profileId && candidate.pluginId === deployment.pluginId);
+	if (!profile) throw new InvalidRivusPlugin(`unknown profile ${deployment.profileId} for plugin ${deployment.pluginId}`);
+	const requestedTools = uniqueExactIds(deployment.tools.allow, "deployment tool allowlist");
+	const catalogTools = new Map(snapshot.tools.map((tool) => [tool.id, tool]));
+	for (const id of requestedTools) if (!catalogTools.has(id)) throw new InvalidRivusPlugin(`unknown deployment tool: ${id}`);
+	const profileToolIds = uniqueExactIds(profile.tools.allow, "profile tool allowlist");
+	for (const id of profileToolIds) if (!catalogTools.has(id)) throw new InvalidRivusPlugin(`profile ${profile.id} references unknown tool: ${id}`);
+	const toolIds = profileToolIds.filter((id) => requestedTools.includes(id)).sort();
+	const profileMemoryScopes = validateMemoryScopes(profile.memory.scopes, `profile ${profile.id}`);
+	const requestedMemoryScopes = validateMemoryScopes(deployment.memory?.scopes ?? [], `deployment ${deployment.agentId}`);
+	const memoryScopes = profileMemoryScopes.filter((scope) => requestedMemoryScopes.includes(scope));
+	const memoryTool = deployment.memory?.tool === true;
+	if (memoryTool && memoryScopes.length === 0) throw new InvalidRivusPlugin(`deployment ${deployment.agentId} Memory Tool requires at least one granted scope`);
+	const memoryToolContract = createRivusMemoryToolContract(memoryScopes);
+	const resolvedToolIds = [...toolIds, ...memoryTool ? [memoryToolContract.id] : []].sort();
+	const tools = resolvedToolIds.map((id) => id === memoryToolContract.id ? {
+		...memoryToolContract,
+		pluginId: RIVUS_MEMORY_TOOL_PLUGIN_ID
+	} : toResolvedTool(catalogTools.get(id)));
+	const requestedSkills = uniqueExactIds(deployment.skills.allow, "deployment skill allowlist");
+	const catalogSkills = new Map(snapshot.skills.map((skill) => [skill.id, skill]));
+	for (const id of requestedSkills) if (!catalogSkills.has(id)) throw new InvalidRivusPlugin(`unknown deployment skill: ${id}`);
+	const skillIds = uniqueExactIds(profile.skills.allow, "profile skill allowlist").filter((id) => requestedSkills.includes(id)).sort();
+	const skills = skillIds.map((id) => {
+		const skill = catalogSkills.get(id);
+		if (!skill) throw new InvalidRivusPlugin(`profile ${profile.id} references unknown skill: ${id}`);
+		return skill;
+	});
+	const profileRevision = digest({
+		memory: {
+			scopes: memoryScopes,
+			tool: memoryTool
+		},
+		model: profile.model,
+		plugin,
+		profileId: profile.id,
+		skills: skills.map(({ content, digest: skillDigest, id, pluginId, title, version }) => ({
+			content,
+			digest: skillDigest,
+			id,
+			pluginId,
+			title,
+			version
+		})),
+		systemPrompt: profile.systemPrompt,
+		tools
+	});
+	const toolGrantSet = deepFreeze({
+		revision: digest({
+			profileRevision,
+			toolIds: resolvedToolIds
+		}),
+		toolIds: resolvedToolIds
+	});
+	const skillGrantSet = deepFreeze({
+		revision: digest({
+			profileRevision,
+			skillIds
+		}),
+		skillIds
+	});
+	return deepFreeze({
+		agentId: deployment.agentId,
+		endpointIds: [...deployment.endpointIds],
+		memory: {
+			scopes: memoryScopes,
+			tool: memoryTool
+		},
+		model: profile.model,
+		pluginId: deployment.pluginId,
+		profileId: deployment.profileId,
+		profileRevision,
+		skillGrantSet,
+		skills,
+		systemPrompt: profile.systemPrompt,
+		toolGrantSet,
+		tools
+	});
+}
+function validateMemoryScopes(scopes, owner) {
+	const result = /* @__PURE__ */ new Set();
+	for (const scope of scopes) {
+		if (!MEMORY_SCOPES.includes(scope)) throw new InvalidRivusPlugin(`${owner} references unsupported Memory scope: ${String(scope)}`);
+		if (result.has(scope)) throw new InvalidRivusPlugin(`${owner} contains duplicate Memory scope: ${scope}`);
+		result.add(scope);
+	}
+	return [...result];
+}
+function validateManifest(manifest) {
+	validateIdentifier(manifest.id, "plugin");
+	if (manifest.apiVersion !== "1") throw new InvalidRivusPlugin(`unsupported plugin API version ${manifest.apiVersion}; expected 1`);
+	if (manifest.version.trim() === "") throw new InvalidRivusPlugin("plugin version must not be empty");
+}
+function validateIdentifier(id, kind) {
+	if (!/^[a-z0-9][a-z0-9._/-]*$/.test(id) || id.includes("*") || id.includes("//")) throw new InvalidRivusPlugin(`invalid ${kind} id: ${id}`);
+}
+function rejectDuplicate(map, id, kind) {
+	if (map.has(id)) throw new InvalidRivusPlugin(`duplicate ${kind} id: ${id}`);
+}
+function uniqueExactIds(ids, label) {
+	const result = /* @__PURE__ */ new Set();
+	for (const id of ids) {
+		if (id.includes("*")) throw new InvalidRivusPlugin(`${label} does not support wildcard id: ${id}`);
+		validateIdentifier(id, label);
+		if (result.has(id)) throw new InvalidRivusPlugin(`duplicate id in ${label}: ${id}`);
+		result.add(id);
+	}
+	return [...result];
+}
+function validateReferences(ids, available, owner, kind) {
+	for (const id of uniqueExactIds(ids, `${owner} ${kind} references`)) if (!available.has(id)) throw new InvalidRivusPlugin(`${owner} references unknown ${kind}: ${id}`);
+}
+function toResolvedTool(tool) {
+	const { createExecutor: _createExecutor, description, digest: toolDigest, id, idempotency, inputSchema, pluginId, risk, version } = tool;
+	return deepFreeze({
+		description,
+		digest: toolDigest,
+		id,
+		idempotency,
+		inputSchema,
+		pluginId,
+		risk,
+		version
+	});
+}
+function digest(value) {
+	return `sha256:${createHash("sha256").update(stableJson(value)).digest("hex")}`;
+}
+function stableJson(value) {
+	if (Array.isArray(value)) return `[${value.map(stableJson).join(",")}]`;
+	if (value !== null && typeof value === "object") return `{${Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, child]) => `${JSON.stringify(key)}:${stableJson(child)}`).join(",")}}`;
+	return JSON.stringify(value);
+}
+//#endregion
+export { RIVUS_MEMORY_TOOL_ID as a, createMemoryNamespace as c, InvalidRivusPlugin as d, RIVUS_PLUGIN_API_VERSION as f, MEMORY_SCOPES as i, createRivusMemoryToolContract as l, requiresToolApproval as m, resolveRivusAgentDefinition as n, RIVUS_MEMORY_TOOL_PLUGIN_ID as o, RivusToolInputRejected as p, deepFreeze as r, RIVUS_MEMORY_TOOL_VERSION as s, createRivusPluginCatalog as t, restrictMemoryScopesForAudience as u };

package/dist/rivus-plugin-testkit.d.ts

@@ -0,0 +1,291 @@
+//#region src/domain/agent-memory.d.ts
+declare const MEMORY_SCOPES: readonly ["conversation", "agent-private", "shared-user-profile"];
+declare const RIVUS_MEMORY_TOOL_ID = "memory";
+declare const RIVUS_MEMORY_TOOL_PLUGIN_ID = "rivus-core";
+declare const RIVUS_MEMORY_TOOL_VERSION = "1.0.0";
+type MemoryScope = (typeof MEMORY_SCOPES)[number];
+type MemoryState = "proposed" | "confirmed" | "superseded" | "tombstoned";
+type MemoryInvocationAudience = "group" | "private";
+interface AgentMemoryIdentity {
+  readonly audience: MemoryInvocationAudience;
+  readonly conversationId?: string;
+  readonly subjectId: string;
+  readonly tenantId: string;
+}
+interface AgentMemoryAuthority extends AgentMemoryIdentity {
+  readonly scopes: ReadonlyArray<MemoryScope>;
+}
+interface MemoryBinding {
+  readonly agentId: string;
+  readonly conversationId?: string;
+  readonly scope: MemoryScope;
+  readonly subjectId: string;
+  readonly tenantId: string;
+}
+interface MemoryRecord {
+  readonly content: string;
+  readonly conversationSafe: boolean;
+  readonly id: string;
+  readonly revision: number;
+  readonly scope: MemoryScope;
+  readonly state: MemoryState;
+  readonly tombstoneReason?: string;
+}
+interface AgentMemorySnapshot {
+  readonly binding: MemoryBinding;
+  readonly record: MemoryRecord;
+}
+declare function createMemoryNamespace(binding: MemoryBinding): string;
+declare function restrictMemoryScopesForAudience(scopes: ReadonlyArray<MemoryScope>, audience: MemoryInvocationAudience): ReadonlyArray<MemoryScope>;
+declare function createRivusMemoryToolContract(scopes: ReadonlyArray<MemoryScope>): Readonly<{
+  description: "Search and read Memory inside Host-bound scopes; propose or request forgetting only in writable private scopes.";
+  digest: "sha256:rivus-memory-v3";
+  id: "memory";
+  idempotency: "required";
+  inputSchema: Readonly<{
+    additionalProperties: false;
+    properties: {
+      scope?: {
+        description: string;
+        enum: ("conversation" | "agent-private" | "shared-user-profile")[];
+        type: string;
+      };
+      command: {
+        description: string;
+        enum: string[];
+        type: string;
+      };
+      id: {
+        description: string;
+        minLength: number;
+        type: string;
+      };
+      input: {
+        additionalProperties: boolean;
+        description: string;
+        properties: {
+          content: {
+            minLength: number;
+            type: string;
+          };
+        };
+        required: string[];
+        type: string;
+      };
+      query: {
+        additionalProperties: boolean;
+        description: string;
+        properties: {
+          query: {
+            type: string;
+          };
+        };
+        required: string[];
+        type: string;
+      };
+      reason: {
+        description: string;
+        type: string;
+      };
+    };
+    required: string[];
+    type: "object";
+  }>;
+  risk: "mutate";
+  version: "1.0.0";
+}>;
+//#endregion
+//#region src/domain/rivus-plugin.d.ts
+declare const RIVUS_PLUGIN_API_VERSION = "1";
+type RivusToolRisk = "observe" | "mutate" | "irreversible" | "host-control";
+type RivusToolIdempotency = "none" | "supported" | "required";
+declare function requiresToolApproval(risk: RivusToolRisk): boolean;
+declare class RivusToolInputRejected extends Error {
+  readonly name: string;
+}
+interface RivusPluginManifest {
+  readonly apiVersion: string;
+  readonly id: string;
+  readonly version: string;
+}
+interface RivusToolExecutor {
+  execute(input: unknown, context: RivusToolExecutionContext): unknown;
+}
+interface RivusToolExecutionContext {
+  readonly agentId: string;
+  readonly instanceId: string;
+  readonly memory?: AgentMemoryAuthority;
+  readonly runId: string;
+  readonly callId: string;
+  readonly operationId?: string;
+  readonly policyEpoch: number;
+  readonly toolId: string;
+  readonly toolVersion: string;
+  readonly sessionKey: string;
+}
+interface RivusToolFactoryContext {
+  readonly toolId: string;
+  readonly toolVersion: string;
+}
+interface RivusToolDescriptor {
+  readonly id: string;
+  readonly version: string;
+  readonly digest: string;
+  readonly description: string;
+  readonly inputSchema: unknown;
+  readonly risk: RivusToolRisk;
+  readonly idempotency: RivusToolIdempotency;
+  readonly createExecutor: (context: RivusToolFactoryContext) => RivusToolExecutor;
+}
+interface RivusHostToolDescriptor extends RivusToolDescriptor {
+  readonly replayCompleted?: (input: unknown, completedResult: unknown, context: RivusToolExecutionContext) => unknown;
+}
+interface RivusSkillDescriptor {
+  readonly id: string;
+  readonly version: string;
+  readonly digest: string;
+  readonly title: string;
+  readonly content: string;
+}
+interface RivusAutomationTemplate {
+  readonly id: string;
+  readonly profileId: string;
+  readonly requestedSkillIds: ReadonlyArray<string>;
+  readonly requestedToolIds: ReadonlyArray<string>;
+  readonly createInput: (tick: RivusAutomationTickContext) => RivusAutomationInput;
+}
+interface RivusAutomationTickContext {
+  readonly occurrence: string;
+}
+interface RivusAutomationInput {
+  readonly text: string;
+}
+interface RivusAgentProfile {
+  readonly id: string;
+  readonly displayName: string;
+  readonly systemPrompt: string;
+  readonly model: Readonly<Record<string, unknown>>;
+  readonly tools: {
+    readonly allow: ReadonlyArray<string>;
+  };
+  readonly skills: {
+    readonly allow: ReadonlyArray<string>;
+  };
+  readonly memory: {
+    readonly scopes: ReadonlyArray<MemoryScope>;
+  };
+}
+interface RivusPluginRegistry {
+  registerAgentProfile(profile: RivusAgentProfile): void;
+  registerTool(tool: RivusToolDescriptor): void;
+  registerSkill(skill: RivusSkillDescriptor): void;
+  registerAutomation(template: RivusAutomationTemplate): void;
+}
+interface RivusPlugin {
+  readonly manifest: RivusPluginManifest;
+  register(registry: RivusPluginRegistry): void;
+}
+interface RegisteredRivusPlugin extends RivusPluginManifest {}
+interface RegisteredRivusTool extends RivusToolDescriptor {
+  readonly pluginId: string;
+}
+interface RegisteredRivusSkill extends RivusSkillDescriptor {
+  readonly pluginId: string;
+}
+interface RegisteredRivusAutomation extends RivusAutomationTemplate {
+  readonly pluginId: string;
+}
+interface RegisteredRivusAgentProfile extends RivusAgentProfile {
+  readonly pluginId: string;
+}
+interface RivusPluginCatalogSnapshot {
+  readonly plugins: ReadonlyArray<RegisteredRivusPlugin>;
+  readonly profiles: ReadonlyArray<RegisteredRivusAgentProfile>;
+  readonly tools: ReadonlyArray<RegisteredRivusTool>;
+  readonly skills: ReadonlyArray<RegisteredRivusSkill>;
+  readonly automations: ReadonlyArray<RegisteredRivusAutomation>;
+}
+interface RivusPluginCatalog {
+  registerPlugin(plugin: RivusPlugin): void;
+  snapshot(): RivusPluginCatalogSnapshot;
+}
+interface RivusAgentDeployment {
+  readonly agentId: string;
+  readonly pluginId: string;
+  readonly profileId: string;
+  readonly endpointIds: ReadonlyArray<string>;
+  readonly memory?: {
+    readonly scopes: ReadonlyArray<MemoryScope>;
+    readonly tool: boolean;
+  };
+  readonly skills: {
+    readonly allow: ReadonlyArray<string>;
+  };
+  readonly tools: {
+    readonly allow: ReadonlyArray<string>;
+  };
+}
+interface RivusResolvedToolDescriptor {
+  readonly id: string;
+  readonly version: string;
+  readonly digest: string;
+  readonly description: string;
+  readonly inputSchema: unknown;
+  readonly risk: RivusToolRisk;
+  readonly idempotency: RivusToolIdempotency;
+  readonly pluginId: string;
+}
+interface RivusToolGrantSet {
+  readonly toolIds: ReadonlyArray<string>;
+  readonly revision: string;
+}
+interface RivusSkillGrantSet {
+  readonly skillIds: ReadonlyArray<string>;
+  readonly revision: string;
+}
+interface ResolvedRivusAgentDefinition {
+  readonly agentId: string;
+  readonly pluginId: string;
+  readonly profileId: string;
+  readonly endpointIds: ReadonlyArray<string>;
+  readonly profileRevision: string;
+  readonly systemPrompt: string;
+  readonly model: Readonly<Record<string, unknown>>;
+  readonly memory: {
+    readonly scopes: ReadonlyArray<MemoryScope>;
+    readonly tool: boolean;
+  };
+  readonly skillGrantSet: RivusSkillGrantSet;
+  readonly skills: ReadonlyArray<RegisteredRivusSkill>;
+  readonly tools: ReadonlyArray<RivusResolvedToolDescriptor>;
+  readonly toolGrantSet: RivusToolGrantSet;
+}
+declare class InvalidRivusPlugin extends Error {
+  readonly name = "InvalidRivusPlugin";
+}
+//#endregion
+//#region src/testing/rivus-plugin-testkit.d.ts
+interface RivusPluginLifecycleProbe {
+  activate(): Promise<{
+    readonly dispose: () => Promise<void> | void;
+    readonly activeResources: () => number;
+  }>;
+}
+interface RivusPluginConformanceInput {
+  readonly plugin: RivusPlugin;
+  readonly deployment: RivusAgentDeployment;
+  readonly lifecycle?: RivusPluginLifecycleProbe;
+}
+interface RivusPluginConformanceReport {
+  readonly pluginId: string;
+  readonly profileId: string;
+  readonly profileRevision: string;
+  readonly toolIds: ReadonlyArray<string>;
+}
+declare class RivusPluginConformanceError extends Error {
+  readonly name = "RivusPluginConformanceError";
+}
+declare function assertRivusPluginConforms(input: RivusPluginConformanceInput): Promise<RivusPluginConformanceReport>;
+declare function createFakeRivusPlugin(): RivusPlugin;
+//#endregion
+export { RivusToolExecutionContext as A, AgentMemorySnapshot as B, RivusPluginCatalogSnapshot as C, RivusSkillDescriptor as D, RivusResolvedToolDescriptor as E, RivusToolInputRejected as F, MemoryScope as G, MemoryBinding as H, RivusToolRisk as I, RIVUS_MEMORY_TOOL_PLUGIN_ID as J, MemoryState as K, requiresToolApproval as L, RivusToolFactoryContext as M, RivusToolGrantSet as N, RivusSkillGrantSet as O, RivusToolIdempotency as P, restrictMemoryScopesForAudience as Q, AgentMemoryAuthority as R, RivusPluginCatalog as S, RivusPluginRegistry as T, MemoryInvocationAudience as U, MEMORY_SCOPES as V, MemoryRecord as W, createMemoryNamespace as X, RIVUS_MEMORY_TOOL_VERSION as Y, createRivusMemoryToolContract as Z, RivusAutomationInput as _, assertRivusPluginConforms as a, RivusHostToolDescriptor as b, RIVUS_PLUGIN_API_VERSION as c, RegisteredRivusPlugin as d, RegisteredRivusSkill as f, RivusAgentProfile as g, RivusAgentDeployment as h, RivusPluginLifecycleProbe as i, RivusToolExecutor as j, RivusToolDescriptor as k, RegisteredRivusAgentProfile as l, ResolvedRivusAgentDefinition as m, RivusPluginConformanceInput as n, createFakeRivusPlugin as o, RegisteredRivusTool as p, RIVUS_MEMORY_TOOL_ID as q, RivusPluginConformanceReport as r, InvalidRivusPlugin as s, RivusPluginConformanceError as t, RegisteredRivusAutomation as u, RivusAutomationTemplate as v, RivusPluginManifest as w, RivusPlugin as x, RivusAutomationTickContext as y, AgentMemoryIdentity as z };

package/dist/rivus-plugin-testkit.js

@@ -0,0 +1,62 @@
+import { n as resolveRivusAgentDefinition, t as createRivusPluginCatalog } from "./rivus-plugin-registry.js";
+//#region src/testing/rivus-plugin-testkit.ts
+var RivusPluginConformanceError = class extends Error {
+	name = "RivusPluginConformanceError";
+};
+async function assertRivusPluginConforms(input) {
+	const catalog = createRivusPluginCatalog();
+	catalog.registerPlugin(input.plugin);
+	const resolved = resolveRivusAgentDefinition(catalog, input.deployment);
+	const requested = new Set(input.deployment.tools.allow);
+	if (resolved.toolGrantSet.toolIds.some((id) => !requested.has(id))) throw new RivusPluginConformanceError("resolved ToolGrantSet expanded beyond deployment request");
+	if (input.lifecycle) {
+		const lifecycle = await input.lifecycle.activate();
+		await lifecycle.dispose();
+		if (lifecycle.activeResources() !== 0) throw new RivusPluginConformanceError("plugin dispose leaked active resources");
+	}
+	return Object.freeze({
+		pluginId: input.plugin.manifest.id,
+		profileId: resolved.profileId,
+		profileRevision: resolved.profileRevision,
+		toolIds: resolved.toolGrantSet.toolIds
+	});
+}
+function createFakeRivusPlugin() {
+	return {
+		manifest: {
+			apiVersion: "1",
+			id: "fake-plugin",
+			version: "1.0.0"
+		},
+		register: (registry) => {
+			registry.registerTool({
+				createExecutor: () => ({ execute: async () => ({ ok: true }) }),
+				description: "Read fake data",
+				digest: "sha256:fake-read",
+				id: "fake-plugin/read",
+				idempotency: "supported",
+				inputSchema: { type: "object" },
+				risk: "observe",
+				version: "1.0.0"
+			});
+			registry.registerSkill({
+				content: "Use only fake data.",
+				digest: "sha256:fake-skill",
+				id: "fake-plugin/read-skill",
+				title: "Fake read",
+				version: "1.0.0"
+			});
+			registry.registerAgentProfile({
+				displayName: "Fake Profile",
+				id: "fake-profile",
+				memory: { scopes: ["agent-private"] },
+				model: { provider: "fake" },
+				skills: { allow: ["fake-plugin/read-skill"] },
+				systemPrompt: "Read fake data.",
+				tools: { allow: ["fake-plugin/read"] }
+			});
+		}
+	};
+}
+//#endregion
+export { assertRivusPluginConforms as n, createFakeRivusPlugin as r, RivusPluginConformanceError as t };