@rivus/agent 0.16.2 → 0.16.6

package/dist/chunks/rivus-agent-definition-resolver.js

@@ -1,508 +0,0 @@
-import { o as createBackgroundSessionToolContracts } from "./background-session-authority.js";
-//#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/core/application/agent-catalog/contracts/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/adapters/agent/memory/rivus-memory-tool-contract.ts
-const RIVUS_MEMORY_TOOL_ID = "memory";
-const RIVUS_MEMORY_TOOL_PLUGIN_ID = "rivus-core";
-const RIVUS_MEMORY_TOOL_VERSION = "1.0.0";
-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. Confirmed Project and Shared User Profile Memory are read-only to the model.",
-					enum: [...scopes],
-					type: "string"
-				} }
-			},
-			required: ["command"],
-			type: "object"
-		}),
-		risk: "mutate",
-		version: RIVUS_MEMORY_TOOL_VERSION
-	});
-}
-//#endregion
-//#region src/adapters/agent/catalog/rivus-host-tool-descriptor-provider.ts
-function createRivusHostToolDescriptorProvider(options) {
-	return Object.freeze({ provide: ({ deployment, memoryScopes }) => {
-		const contributions = [];
-		if (deployment.memory?.tool === true) contributions.push({
-			scope: "profile",
-			tool: Object.freeze({
-				...createRivusMemoryToolContract(memoryScopes),
-				pluginId: RIVUS_MEMORY_TOOL_PLUGIN_ID
-			})
-		});
-		if (options.backgroundSessions) contributions.push(...createBackgroundSessionToolContracts().map(toRuntimeContribution));
-		return Object.freeze(contributions);
-	} });
-}
-function toRuntimeContribution(tool) {
-	return Object.freeze({
-		scope: "runtime",
-		tool: Object.freeze({ ...tool })
-	});
-}
-//#endregion
-//#region src/core/application/agent-catalog/contracts/rivus-plugin.ts
-const RIVUS_PLUGIN_API_VERSION = "1";
-var InvalidRivusPlugin = class extends Error {
-	name = "InvalidRivusPlugin";
-};
-//#endregion
-//#region src/core/application/agent-catalog/catalog/rivus-catalog-validation.ts
-const MEMORY_SCOPES = [
-	"conversation",
-	"agent-private",
-	"project",
-	"shared-user-profile"
-];
-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 validateRivusCatalogRegistration(item, existing, pending) {
-	validateRivusCatalogIdentifier(item.id, item.kind);
-	if (item.namespaced && !item.id.startsWith(`${item.pluginId}/`)) throw new InvalidRivusPlugin(`${item.kind} id ${item.id} must use plugin namespace ${item.pluginId}/`);
-	const key = `${item.kind}:${item.id}`;
-	if (pending.has(key) || existing.has(item.id)) throw new InvalidRivusPlugin(`duplicate ${item.kind} id: ${item.id}`);
-}
-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`)) validateRivusCatalogReference(id, available, owner, kind);
-}
-function validateRivusCatalogReference(id, available, owner, kind) {
-	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/core/application/agent-catalog/catalog/rivus-plugin-catalog.ts
-function createRivusPluginCatalog(runtime) {
-	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);
-			if (plugins.has(plugin.manifest.id)) throw new InvalidRivusPlugin(`duplicate plugin id: ${plugin.manifest.id}`);
-			const pendingProfiles = [];
-			const pendingTools = [];
-			const pendingSkills = [];
-			const pendingAutomations = [];
-			const pendingIds = /* @__PURE__ */ new Set();
-			const register = (kind, definition, catalog, destination, namespaced) => {
-				validateRivusCatalogRegistration({
-					id: definition.id,
-					kind,
-					namespaced,
-					pluginId: plugin.manifest.id
-				}, catalog, pendingIds);
-				const key = `${kind}:${definition.id}`;
-				pendingIds.add(key);
-				destination.push(runtime.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) {
-				validateRivusCatalogReference(automation.profileId, availableProfileIds, `automation ${automation.id}`, "profile");
-				validateRivusCatalogReferences(automation.requestedToolIds, availableToolIds, `automation ${automation.id}`, "tool");
-				validateRivusCatalogReferences(automation.requestedSkillIds, availableSkillIds, `automation ${automation.id}`, "skill");
-			}
-			plugins.set(plugin.manifest.id, runtime.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: () => runtime.deepFreeze({
-			automations: [...automations.values()],
-			plugins: [...plugins.values()],
-			profiles: [...profiles.values()],
-			skills: [...skills.values()],
-			tools: [...tools.values()]
-		})
-	};
-}
-//#endregion
-//#region src/core/application/agent-catalog/resolution/rivus-tool-grant-set.ts
-function narrowRivusToolGrantSet(parent, restrictions, runtime) {
-	const toolIds = intersectToolIds([parent.toolIds, ...restrictions]);
-	return runtime.deepFreeze({
-		revision: runtime.digest(JSON.stringify({
-			parentRevision: parent.revision,
-			toolIds
-		})),
-		toolIds
-	});
-}
-function intersectRivusToolIds(sets, runtime) {
-	const toolIds = intersectToolIds(sets);
-	return runtime.deepFreeze({
-		revision: runtime.digest(JSON.stringify(toolIds)),
-		toolIds
-	});
-}
-function createRivusToolGrantSetOperations(runtime) {
-	return Object.freeze({
-		intersect: (sets) => intersectRivusToolIds(sets, runtime),
-		narrow: (parent, restrictions) => narrowRivusToolGrantSet(parent, restrictions, runtime)
-	});
-}
-function intersectToolIds(sets) {
-	const [first = [], ...rest] = sets;
-	return [...new Set(first)].filter((id) => rest.every((set) => set.includes(id))).sort();
-}
-//#endregion
-//#region src/core/application/agent-catalog/resolution/rivus-agent-grant-restriction.ts
-function restrictRivusAgentDefinitionGrants(definition, restriction, runtime) {
-	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 = runtime.deepFreeze({
-		revision: runtime.digest(JSON.stringify({
-			parentRevision: definition.skillGrantSet.revision,
-			skillIds
-		})),
-		skillIds
-	});
-	const runtimeToolGrantSet = runtime.deepFreeze({
-		revision: runtime.digest(JSON.stringify({
-			parentRevision: definition.runtimeToolGrantSet.revision,
-			toolIds: runtimeToolIds
-		})),
-		toolIds: runtimeToolIds
-	});
-	return runtime.deepFreeze({
-		...definition,
-		memory: {
-			scopes: memoryScopes,
-			tool: restriction.memory.tool
-		},
-		runtimeToolGrantSet,
-		skillGrantSet,
-		skills,
-		toolGrantSet: narrowRivusToolGrantSet(definition.toolGrantSet, [toolIds], runtime),
-		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
-//#region src/core/application/agent-catalog/resolution/rivus-agent-definition-resolver.ts
-function createRivusAgentDefinitionResolver(providers, runtime) {
-	return Object.freeze({ resolve: (catalog, deployment) => resolveRivusAgentDefinition(catalog, deployment, providers, runtime) });
-}
-function createRivusAgentCatalog(providers, runtime) {
-	const resolver = createRivusAgentDefinitionResolver(providers, runtime);
-	return Object.freeze({
-		createPluginCatalog: () => createRivusPluginCatalog(runtime),
-		resolve: (catalog, deployment) => resolver.resolve(catalog, deployment),
-		restrictGrants: (definition, restriction) => restrictRivusAgentDefinitionGrants(definition, restriction, runtime)
-	});
-}
-function resolveRivusAgentDefinition(catalog, deployment, providers, runtime) {
-	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 memoryScopes = resolveMemoryScopes(profile, deployment);
-	const runtimeToolIds = resolveRuntimeTools(profile, deployment);
-	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 contributions = providers.flatMap((provider) => provider.provide({
-		deployment,
-		memoryScopes,
-		profile
-	}));
-	const profileContributions = contributions.filter(({ scope }) => scope === "profile");
-	const runtimeContributions = contributions.filter(({ scope }) => scope === "runtime");
-	validateToolContributions(snapshot.tools, contributions);
-	if (memoryTool && !profileContributions.some(({ tool }) => tool.id === "memory")) throw new InvalidRivusPlugin(`deployment ${deployment.agentId} Memory Tool descriptor is unavailable`);
-	const pluginTools = resolvePluginTools(snapshot.tools, profile, deployment);
-	const profileToolsById = new Map(profileContributions.map(({ tool }) => [tool.id, runtime.deepFreeze({ ...tool })]));
-	const resolvedProfileToolIds = [...pluginTools.keys(), ...profileToolsById.keys()].sort();
-	const tools = resolvedProfileToolIds.map((id) => pluginTools.get(id) ?? profileToolsById.get(id));
-	const skills = resolveSkills(snapshot.skills, profile, deployment);
-	const skillIds = skills.map(({ id }) => id);
-	const profileRevision = digest(runtime, {
-		memory: {
-			scopes: memoryScopes,
-			tool: memoryTool
-		},
-		model: profile.model,
-		plugin,
-		profileId: profile.id,
-		runtimeTools: runtimeToolIds,
-		skills: skills.map(({ content, digest: skillDigest, id, pluginId, title, version }) => ({
-			content,
-			digest: skillDigest,
-			id,
-			pluginId,
-			title,
-			version
-		})),
-		systemPrompt: profile.systemPrompt,
-		tools
-	});
-	const toolGrantSet = runtime.deepFreeze({
-		revision: digest(runtime, {
-			profileRevision,
-			toolIds: resolvedProfileToolIds
-		}),
-		toolIds: resolvedProfileToolIds
-	});
-	const skillGrantSet = runtime.deepFreeze({
-		revision: digest(runtime, {
-			profileRevision,
-			skillIds
-		}),
-		skillIds
-	});
-	const runtimeToolGrantSet = runtime.deepFreeze({
-		revision: digest(runtime, {
-			profileRevision,
-			toolIds: runtimeToolIds
-		}),
-		toolIds: runtimeToolIds
-	});
-	return extendRuntimeTools(runtime.deepFreeze({
-		agentId: deployment.agentId,
-		endpointIds: [...deployment.endpointIds],
-		memory: {
-			scopes: memoryScopes,
-			tool: memoryTool
-		},
-		model: profile.model,
-		pluginId: deployment.pluginId,
-		profileId: deployment.profileId,
-		...deployment.projectSpaceId ? { projectSpaceId: deployment.projectSpaceId } : {},
-		profileRevision,
-		runtimeToolGrantSet,
-		skillGrantSet,
-		skills,
-		systemPrompt: profile.systemPrompt,
-		toolGrantSet,
-		tools
-	}), runtimeContributions, runtime);
-}
-function resolveRuntimeTools(profile, deployment) {
-	const profileToolIds = uniqueRivusRuntimeToolIds(profile.runtimeTools?.allow ?? [], `profile ${profile.id}`);
-	const requestedToolIds = uniqueRivusRuntimeToolIds(deployment.runtimeTools?.allow ?? [], `deployment ${deployment.agentId}`);
-	const profileToolIdSet = new Set(profileToolIds);
-	const requestedToolIdSet = new Set(requestedToolIds);
-	return RIVUS_RUNTIME_TOOL_IDS.filter((id) => profileToolIdSet.has(id) && requestedToolIdSet.has(id));
-}
-function resolveMemoryScopes(profile, deployment) {
-	const profileScopes = validateRivusMemoryScopes(profile.memory.scopes, `profile ${profile.id}`);
-	const requestedScopes = validateRivusMemoryScopes(deployment.memory?.scopes ?? [], `deployment ${deployment.agentId}`);
-	return profileScopes.filter((scope) => requestedScopes.includes(scope));
-}
-function resolvePluginTools(registeredTools, profile, deployment) {
-	const requestedTools = uniqueRivusCatalogIds(deployment.tools.allow, "deployment tool allowlist");
-	const catalogTools = new Map(registeredTools.map((tool) => [tool.id, tool]));
-	for (const id of requestedTools) if (!catalogTools.has(id)) throw new InvalidRivusPlugin(`unknown deployment tool: ${id}`);
-	const profileToolIds = uniqueRivusCatalogIds(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 grantedIds = profileToolIds.filter((id) => requestedTools.includes(id)).sort();
-	return new Map(grantedIds.map((id) => [id, toResolvedTool(catalogTools.get(id))]));
-}
-function resolveSkills(registeredSkills, profile, deployment) {
-	const requestedSkills = uniqueRivusCatalogIds(deployment.skills.allow, "deployment skill allowlist");
-	const catalogSkills = new Map(registeredSkills.map((skill) => [skill.id, skill]));
-	for (const id of requestedSkills) if (!catalogSkills.has(id)) throw new InvalidRivusPlugin(`unknown deployment skill: ${id}`);
-	return uniqueRivusCatalogIds(profile.skills.allow, "profile skill allowlist").filter((id) => requestedSkills.includes(id)).sort().map((id) => {
-		const skill = catalogSkills.get(id);
-		if (!skill) throw new InvalidRivusPlugin(`profile ${profile.id} references unknown skill: ${id}`);
-		return skill;
-	});
-}
-function validateToolContributions(registeredTools, contributions) {
-	const knownIds = new Set(registeredTools.map(({ id }) => id));
-	for (const { tool } of contributions) {
-		validateRivusCatalogIdentifier(tool.id, "contributed tool");
-		validateRivusCatalogIdentifier(tool.pluginId, "contributed tool plugin");
-		if (knownIds.has(tool.id)) throw new InvalidRivusPlugin(`duplicate contributed tool id: ${tool.id}`);
-		if (tool.version.trim() === "" || tool.digest.trim() === "") throw new InvalidRivusPlugin(`contributed tool ${tool.id} requires a version and digest`);
-		knownIds.add(tool.id);
-	}
-}
-function extendRuntimeTools(definition, contributions, runtime) {
-	if (contributions.length === 0) return definition;
-	const additions = contributions.map(({ tool }) => runtime.deepFreeze({ ...tool }));
-	const additionIds = additions.map(({ id }) => id).sort();
-	return runtime.deepFreeze({
-		...definition,
-		toolGrantSet: {
-			revision: digest(runtime, {
-				parentRevision: definition.toolGrantSet.revision,
-				toolIds: additionIds
-			}),
-			toolIds: [...definition.toolGrantSet.toolIds, ...additionIds].sort()
-		},
-		tools: [...definition.tools, ...additions]
-	});
-}
-function toResolvedTool(tool) {
-	const { createExecutor: _createExecutor, description, digest: toolDigest, id, idempotency, inputSchema, pluginId, risk, version } = tool;
-	return {
-		description,
-		digest: toolDigest,
-		id,
-		idempotency,
-		inputSchema,
-		pluginId,
-		risk,
-		version
-	};
-}
-function digest(runtime, value) {
-	return runtime.digest(stableJson(value));
-}
-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_PLUGIN_API_VERSION as a, RIVUS_MEMORY_TOOL_PLUGIN_ID as c, RIVUS_RUNTIME_TOOL_IDS as d, isRivusRuntimeToolId as f, InvalidRivusPlugin as i, RIVUS_MEMORY_TOOL_VERSION as l, createRivusToolGrantSetOperations as n, createRivusHostToolDescriptorProvider as o, deepFreeze as p, createRivusPluginCatalog as r, RIVUS_MEMORY_TOOL_ID as s, createRivusAgentCatalog as t, createRivusMemoryToolContract as u };