@rivus/agent 0.13.2 → 0.14.1

package/dist/chunks/api.d.ts

@@ -0,0 +1,70 @@
+import { Effect } from "effect";
+
+//#region src/modules/memory/application/compaction/compaction-service.d.ts
+interface CompactionInput {
+  readonly tenantId: string;
+  readonly agentId: string;
+  readonly instanceId: string;
+  readonly conversationId: string;
+  readonly profileRevision: string;
+  readonly watermark: number;
+  readonly transcript: ReadonlyArray<string>;
+}
+interface CompactionSnapshot extends Omit<CompactionInput, "transcript"> {
+  readonly id: string;
+  readonly summary: string;
+}
+declare class CompactionError extends Error {
+  readonly name = "CompactionError";
+}
+//#endregion
+//#region src/modules/memory/domain/scope/memory-scope.d.ts
+declare const MEMORY_SCOPES: readonly ["conversation", "agent-private", "project", "shared-user-profile"];
+type MemoryScope = (typeof MEMORY_SCOPES)[number];
+type MemoryInvocationAudience = "group" | "private";
+interface AgentMemoryIdentity {
+  readonly audience: MemoryInvocationAudience;
+  readonly conversationId?: string;
+  readonly projectId?: string;
+  readonly subjectId: string;
+  readonly tenantId: string;
+}
+interface AgentMemoryAuthority extends AgentMemoryIdentity {
+  readonly scopes: ReadonlyArray<MemoryScope>;
+}
+interface MemoryBinding {
+  readonly agentId: string;
+  readonly conversationId?: string;
+  readonly projectId?: string;
+  readonly scope: MemoryScope;
+  readonly subjectId: string;
+  readonly tenantId: string;
+}
+declare function createMemoryNamespace(binding: MemoryBinding): string;
+declare function restrictMemoryScopesForAudience(scopes: ReadonlyArray<MemoryScope>, audience: MemoryInvocationAudience): ReadonlyArray<MemoryScope>;
+//#endregion
+//#region src/modules/memory/domain/record/memory-record.d.ts
+type MemoryState = "proposed" | "confirmed" | "superseded" | "tombstoned";
+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;
+}
+//#endregion
+//#region src/modules/memory/application/storage/agent-memory-service.d.ts
+interface MemorySearchQuery {
+  readonly query: string;
+}
+declare class AgentMemoryError extends Error {
+  readonly name = "AgentMemoryError";
+}
+//#endregion
+export { MemoryState as a, MEMORY_SCOPES as c, MemoryScope as d, createMemoryNamespace as f, CompactionSnapshot as g, CompactionInput as h, MemoryRecord as i, MemoryBinding as l, CompactionError as m, MemorySearchQuery as n, AgentMemoryAuthority as o, restrictMemoryScopesForAudience as p, AgentMemorySnapshot as r, AgentMemoryIdentity as s, AgentMemoryError as t, MemoryInvocationAudience as u };

package/dist/chunks/api.js

@@ -0,0 +1,471 @@
+import { t as createSha256Digest } from "./sha256-digest.js";
+import { Effect } from "effect";
+//#region src/modules/memory/application/compaction/compaction-service.ts
+var CompactionError = class extends Error {
+	name = "CompactionError";
+};
+function createEffectCompactionService(options) {
+	const candidates = /* @__PURE__ */ new Map();
+	const committed = /* @__PURE__ */ new Map();
+	const serial = Effect.unsafeMakeSemaphore(1);
+	return {
+		createCandidate: (input) => {
+			const safeInput = Object.freeze({
+				agentId: input.agentId,
+				conversationId: input.conversationId,
+				instanceId: input.instanceId,
+				profileRevision: input.profileRevision,
+				tenantId: input.tenantId,
+				transcript: Object.freeze([...input.transcript]),
+				watermark: input.watermark
+			});
+			return options.compactor.compact(safeInput).pipe(Effect.map((summary) => Object.freeze({
+				agentId: input.agentId,
+				conversationId: input.conversationId,
+				id: `compaction:${options.identity.next()}`,
+				instanceId: input.instanceId,
+				profileRevision: input.profileRevision,
+				summary,
+				tenantId: input.tenantId,
+				watermark: input.watermark
+			})), Effect.tap((candidate) => Effect.sync(() => candidates.set(candidate.id, candidate))));
+		},
+		commit: (candidateId) => serial.withPermits(1)(Effect.suspend(() => {
+			const candidate = candidates.get(candidateId);
+			if (!candidate) return Effect.fail(new CompactionError(`unknown compaction candidate: ${candidateId}`));
+			const key = `${candidate.instanceId}/${candidate.conversationId}`;
+			const current = committed.get(key);
+			if (current && current.watermark >= candidate.watermark) return Effect.fail(new CompactionError("compaction watermark conflict"));
+			return Effect.sync(() => {
+				committed.set(key, candidate);
+				candidates.delete(candidateId);
+				return candidate;
+			});
+		})),
+		current: (instanceId, conversationId) => committed.get(`${instanceId}/${conversationId}`)
+	};
+}
+//#endregion
+//#region src/modules/memory/domain/record/memory-record.ts
+var MemoryRecordError = class extends Error {
+	name = "MemoryRecordError";
+};
+function proposeMemory(scope, contentInput, id) {
+	const content = contentInput.trim();
+	if (!content) throw new MemoryRecordError("memory content must not be empty");
+	if (!id.trim()) throw new MemoryRecordError("memory id must not be empty");
+	return Object.freeze({
+		content,
+		conversationSafe: false,
+		id,
+		revision: 1,
+		scope,
+		state: "proposed"
+	});
+}
+function confirmMemory(current, input) {
+	requireRevision(current, input.expectedRevision);
+	if (current.state !== "proposed") throw new MemoryRecordError("only proposed memory can be confirmed");
+	return Object.freeze({
+		...current,
+		conversationSafe: input.conversationSafe ?? false,
+		revision: current.revision + 1,
+		state: "confirmed"
+	});
+}
+function forgetMemory(current, input) {
+	requireRevision(current, input.expectedRevision);
+	if (current.state === "tombstoned") throw new MemoryRecordError(`memory is already forgotten: ${current.id}`);
+	const reason = input.reason?.trim();
+	return Object.freeze({
+		...current,
+		revision: current.revision + 1,
+		state: "tombstoned",
+		...reason ? { tombstoneReason: reason } : {}
+	});
+}
+function isVisibleMemory(record) {
+	if (record.state === "tombstoned" || record.state === "superseded") return false;
+	return record.scope !== "shared-user-profile" && record.scope !== "project" || record.state === "confirmed";
+}
+function isValidMemoryTransition(previous, next) {
+	if (!sameBinding(previous.binding, next.binding) || previous.record.id !== next.record.id || previous.record.content !== next.record.content || previous.record.scope !== next.record.scope || next.record.revision !== previous.record.revision + 1) return false;
+	switch (previous.record.state) {
+		case "proposed": return (next.record.state === "confirmed" || next.record.state === "tombstoned") && (!next.record.conversationSafe || next.record.state === "confirmed");
+		case "confirmed":
+		case "superseded": return next.record.state === "tombstoned" && next.record.conversationSafe === previous.record.conversationSafe;
+		case "tombstoned": return false;
+	}
+}
+function sameBinding(left, right) {
+	return left.agentId === right.agentId && left.conversationId === right.conversationId && left.projectId === right.projectId && left.scope === right.scope && left.subjectId === right.subjectId && left.tenantId === right.tenantId;
+}
+function requireRevision(current, expectedRevision) {
+	if (current.revision !== expectedRevision) throw new MemoryRecordError("memory revision conflict");
+}
+//#endregion
+//#region src/modules/memory/domain/scope/memory-scope.ts
+const MEMORY_SCOPES = [
+	"conversation",
+	"agent-private",
+	"project",
+	"shared-user-profile"
+];
+var MemoryScopeError = class extends Error {
+	name = "MemoryScopeError";
+};
+function normalizeMemoryBinding(binding) {
+	const tenantId = binding.tenantId.trim();
+	const agentId = binding.agentId.trim();
+	const subjectId = binding.subjectId.trim();
+	if (!tenantId || !agentId || !subjectId || !MEMORY_SCOPES.includes(binding.scope)) throw new MemoryScopeError("Memory binding requires trusted tenant, Agent, subject, and scope");
+	const conversationId = binding.conversationId?.trim();
+	const projectId = binding.projectId?.trim();
+	if (binding.scope === "conversation" && !conversationId) throw new MemoryScopeError("Conversation Memory requires a trusted conversation identity");
+	if (binding.scope !== "conversation" && conversationId) throw new MemoryScopeError("Only Conversation Memory accepts a conversation identity");
+	if (binding.scope === "project" && !projectId) throw new MemoryScopeError("Project Memory requires a trusted Project Space identity");
+	if (binding.scope !== "project" && projectId) throw new MemoryScopeError("Only Project Memory accepts a Project Space identity");
+	return Object.freeze({
+		agentId,
+		...conversationId ? { conversationId } : {},
+		...projectId ? { projectId } : {},
+		scope: binding.scope,
+		subjectId,
+		tenantId
+	});
+}
+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 "project": return [
+			binding.tenantId,
+			binding.agentId,
+			binding.projectId ?? "",
+			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" || scope === "project") : [...scopes];
+}
+//#endregion
+//#region src/modules/memory/application/storage/agent-memory-repository.ts
+var AgentMemoryRepositoryConflict = class extends Error {
+	name = "AgentMemoryRepositoryConflict";
+};
+//#endregion
+//#region src/modules/memory/application/storage/agent-memory-service.ts
+var AgentMemoryError = class extends Error {
+	name = "AgentMemoryError";
+};
+function createMemoryService(options) {
+	return { bind: (bindingInput) => {
+		let binding;
+		try {
+			binding = normalizeMemoryBinding(bindingInput);
+		} catch (error) {
+			throw asAgentMemoryError(error);
+		}
+		const update = (id, transition) => Effect.gen(function* () {
+			const current = yield* options.repository.get(binding, id);
+			if (!current) return yield* Effect.fail(new AgentMemoryError(`memory not found: ${id}`));
+			const record = yield* Effect.try({
+				catch: asAgentMemoryError,
+				try: () => transition(current)
+			});
+			return yield* options.repository.save({
+				binding,
+				record
+			}).pipe(Effect.mapError(mapRepositoryConflict));
+		});
+		const handle = {
+			namespace: createMemoryNamespace(binding),
+			scope: binding.scope,
+			confirm: (input) => update(input.id, (current) => confirmMemory(current, {
+				expectedRevision: input.expectedRevision,
+				...input.conversationSafe === void 0 ? {} : { conversationSafe: input.conversationSafe }
+			})),
+			forgetRequest: (input) => update(input.id, (current) => forgetMemory(current, {
+				expectedRevision: input.expectedRevision,
+				...input.reason === void 0 ? {} : { reason: input.reason }
+			})),
+			inspect: (id) => options.repository.get(binding, id),
+			propose: (input) => Effect.gen(function* () {
+				const id = yield* Effect.try({
+					catch: (error) => error,
+					try: () => options.identity.next()
+				});
+				const record = yield* Effect.try({
+					catch: asAgentMemoryError,
+					try: () => proposeMemory(binding.scope, input.content, `memory:${id}`)
+				});
+				return yield* options.repository.save({
+					binding,
+					record
+				}).pipe(Effect.mapError(mapRepositoryConflict));
+			}),
+			read: (id) => options.repository.get(binding, id).pipe(Effect.map((record) => record && isVisibleMemory(record) ? record : void 0)),
+			search: ({ query }) => options.repository.list(binding).pipe(Effect.map((records) => {
+				const normalized = query.trim().toLowerCase();
+				return records.filter((record) => isVisibleMemory(record) && record.content.toLowerCase().includes(normalized));
+			}))
+		};
+		return Object.freeze(handle);
+	} };
+}
+function mapRepositoryConflict(error) {
+	return error instanceof AgentMemoryRepositoryConflict ? new AgentMemoryError("memory revision conflict") : error;
+}
+function asAgentMemoryError(error) {
+	if (error instanceof AgentMemoryError) return error;
+	if (error instanceof MemoryRecordError || error instanceof MemoryScopeError) return new AgentMemoryError(error.message);
+	return new AgentMemoryError(error instanceof Error ? error.message : String(error));
+}
+//#endregion
+//#region src/modules/agent-catalog/domain/plugin/rivus-plugin.ts
+const RIVUS_PLUGIN_API_VERSION = "1";
+var InvalidRivusPlugin = class extends Error {
+	name = "InvalidRivusPlugin";
+};
+//#endregion
+//#region src/modules/agent-catalog/domain/runtime-tool/rivus-runtime-tool.ts
+const RIVUS_RUNTIME_TOOL_IDS = Object.freeze([
+	"read",
+	"bash",
+	"edit",
+	"write",
+	"grep",
+	"find",
+	"ls"
+]);
+function isRivusRuntimeToolId(value) {
+	return RIVUS_RUNTIME_TOOL_IDS.includes(value);
+}
+//#endregion
+//#region src/modules/agent-catalog/domain/tool/rivus-tool.ts
+var RivusToolInputRejected = class extends Error {
+	name = "RivusToolInputRejected";
+};
+//#endregion
+//#region src/modules/agent-catalog/domain/policy/rivus-catalog-policy.ts
+function validateRivusPluginManifest(manifest) {
+	validateRivusCatalogIdentifier(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 validateRivusCatalogIdentifier(id, kind) {
+	if (!/^[a-z0-9][a-z0-9._/-]*$/.test(id) || id.includes("*") || id.includes("//")) throw new InvalidRivusPlugin(`invalid ${kind} id: ${id}`);
+}
+function uniqueRivusCatalogIds(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}`);
+		validateRivusCatalogIdentifier(id, label);
+		if (result.has(id)) throw new InvalidRivusPlugin(`duplicate id in ${label}: ${id}`);
+		result.add(id);
+	}
+	return [...result];
+}
+function validateRivusCatalogReferences(ids, available, owner, kind) {
+	for (const id of uniqueRivusCatalogIds(ids, `${owner} ${kind} references`)) if (!available.has(id)) throw new InvalidRivusPlugin(`${owner} references unknown ${kind}: ${id}`);
+}
+function validateRivusMemoryScopes(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 uniqueRivusRuntimeToolIds(ids, owner) {
+	const result = /* @__PURE__ */ new Set();
+	for (const id of ids) {
+		if (typeof id === "string" && id.includes("*")) throw new InvalidRivusPlugin(`${owner} does not support wildcard Runtime Tool: ${id}`);
+		if (typeof id !== "string" || !isRivusRuntimeToolId(id)) throw new InvalidRivusPlugin(`${owner} references unknown Runtime Tool: ${String(id)}`);
+		if (result.has(id)) throw new InvalidRivusPlugin(`${owner} contains duplicate Runtime Tool: ${id}`);
+		result.add(id);
+	}
+	return [...result];
+}
+//#endregion
+//#region src/platform/values/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/modules/agent-catalog/application/catalog/rivus-plugin-catalog.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) => {
+			validateRivusPluginManifest(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) => {
+				validateRivusCatalogIdentifier(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) {
+				validateRivusMemoryScopes(profile.memory.scopes, `profile ${profile.id}`);
+				uniqueRivusRuntimeToolIds(profile.runtimeTools?.allow ?? [], `profile ${profile.id}`);
+				validateRivusCatalogReferences(profile.tools.allow, availableToolIds, `profile ${profile.id}`, "tool");
+				validateRivusCatalogReferences(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}`);
+				validateRivusCatalogReferences(automation.requestedToolIds, availableToolIds, `automation ${automation.id}`, "tool");
+				validateRivusCatalogReferences(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 rejectDuplicate(map, id, kind) {
+	if (map.has(id)) throw new InvalidRivusPlugin(`duplicate ${kind} id: ${id}`);
+}
+//#endregion
+//#region src/modules/agent-catalog/application/resolution/rivus-tool-grant-set.ts
+function narrowRivusToolGrantSet(parent, restrictions) {
+	const toolIds = intersectToolIds([parent.toolIds, ...restrictions]);
+	return deepFreeze({
+		revision: createSha256Digest(JSON.stringify({
+			parentRevision: parent.revision,
+			toolIds
+		})),
+		toolIds
+	});
+}
+function intersectRivusToolIds(sets) {
+	const toolIds = intersectToolIds(sets);
+	return deepFreeze({
+		revision: createSha256Digest(JSON.stringify(toolIds)),
+		toolIds
+	});
+}
+function intersectToolIds(sets) {
+	const [first = [], ...rest] = sets;
+	return [...new Set(first)].filter((id) => rest.every((set) => set.includes(id))).sort();
+}
+//#endregion
+//#region src/modules/agent-catalog/application/resolution/rivus-agent-grant-restriction.ts
+function restrictRivusAgentDefinitionGrants(definition, restriction) {
+	const toolIds = uniqueIds(restriction.toolIds);
+	const skillIds = uniqueIds(restriction.skillIds);
+	const runtimeToolIds = uniqueRuntimeToolIds(restriction.runtimeToolIds);
+	const memoryScopes = uniqueScopes(restriction.memory.scopes);
+	const toolsById = new Map(definition.tools.map((tool) => [tool.id, tool]));
+	const skillsById = new Map(definition.skills.map((skill) => [skill.id, skill]));
+	const tools = toolIds.map((toolId) => {
+		const tool = toolsById.get(toolId);
+		if (!tool) throw new Error(`Agent grant restriction requests ungranted Tool: ${toolId}`);
+		return tool;
+	});
+	const skills = skillIds.map((skillId) => {
+		const skill = skillsById.get(skillId);
+		if (!skill) throw new Error(`Agent grant restriction requests ungranted Skill: ${skillId}`);
+		return skill;
+	});
+	for (const scope of memoryScopes) if (!definition.memory.scopes.includes(scope)) throw new Error(`Agent grant restriction requests ungranted Memory scope: ${scope}`);
+	for (const runtimeToolId of runtimeToolIds) if (!definition.runtimeToolGrantSet.toolIds.includes(runtimeToolId)) throw new Error(`Agent grant restriction requests ungranted Runtime Tool: ${runtimeToolId}`);
+	if (restriction.memory.tool && !definition.memory.tool) throw new Error("Agent grant restriction cannot enable an ungranted Memory Tool");
+	const skillGrantSet = deepFreeze({
+		revision: createSha256Digest(JSON.stringify({
+			parentRevision: definition.skillGrantSet.revision,
+			skillIds
+		})),
+		skillIds
+	});
+	const runtimeToolGrantSet = deepFreeze({
+		revision: createSha256Digest(JSON.stringify({
+			parentRevision: definition.runtimeToolGrantSet.revision,
+			toolIds: runtimeToolIds
+		})),
+		toolIds: runtimeToolIds
+	});
+	return deepFreeze({
+		...definition,
+		memory: {
+			scopes: memoryScopes,
+			tool: restriction.memory.tool
+		},
+		runtimeToolGrantSet,
+		skillGrantSet,
+		skills,
+		toolGrantSet: narrowRivusToolGrantSet(definition.toolGrantSet, [toolIds]),
+		tools
+	});
+}
+function uniqueRuntimeToolIds(ids) {
+	const requested = /* @__PURE__ */ new Set();
+	for (const id of ids) {
+		if (!isRivusRuntimeToolId(id)) throw new Error(`Agent grant restriction requests unknown Runtime Tool: ${id}`);
+		requested.add(id);
+	}
+	return RIVUS_RUNTIME_TOOL_IDS.filter((id) => requested.has(id));
+}
+function uniqueIds(ids) {
+	return [...new Set(ids)].sort();
+}
+function uniqueScopes(scopes) {
+	return [...new Set(scopes)].sort();
+}
+//#endregion
+export { createEffectCompactionService as C, CompactionError as S, AgentMemoryRepositoryConflict as _, deepFreeze as a, restrictMemoryScopesForAudience as b, validateRivusCatalogIdentifier as c, RIVUS_RUNTIME_TOOL_IDS as d, isRivusRuntimeToolId as f, createMemoryService as g, AgentMemoryError as h, createRivusPluginCatalog as i, validateRivusMemoryScopes as l, RIVUS_PLUGIN_API_VERSION as m, intersectRivusToolIds as n, uniqueRivusCatalogIds as o, InvalidRivusPlugin as p, narrowRivusToolGrantSet as r, uniqueRivusRuntimeToolIds as s, restrictRivusAgentDefinitionGrants as t, RivusToolInputRejected as u, MEMORY_SCOPES as v, isValidMemoryTransition as x, createMemoryNamespace as y };