@rivus/agent 0.13.2 → 0.14.0

package/dist/chunks/module.js

@@ -0,0 +1,267 @@
+import { a as deepFreeze, c as validateRivusCatalogIdentifier, d as RIVUS_RUNTIME_TOOL_IDS, i as createRivusPluginCatalog, l as validateRivusMemoryScopes, o as uniqueRivusCatalogIds, p as InvalidRivusPlugin, s as uniqueRivusRuntimeToolIds } from "./api.js";
+import { t as createSha256Digest } from "./sha256-digest.js";
+import { q as createBackgroundSessionToolContracts } from "./api2.js";
+//#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/modules/agent-catalog/application/resolution/rivus-agent-definition-resolver.ts
+function createRivusAgentDefinitionResolver(providers) {
+	return Object.freeze({ resolve: (catalog, deployment) => resolveRivusAgentDefinition(catalog, deployment, providers) });
+}
+function resolveRivusAgentDefinition(catalog, deployment, providers) {
+	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, 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({
+		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 = deepFreeze({
+		revision: digest({
+			profileRevision,
+			toolIds: resolvedProfileToolIds
+		}),
+		toolIds: resolvedProfileToolIds
+	});
+	const skillGrantSet = deepFreeze({
+		revision: digest({
+			profileRevision,
+			skillIds
+		}),
+		skillIds
+	});
+	const runtimeToolGrantSet = deepFreeze({
+		revision: digest({
+			profileRevision,
+			toolIds: runtimeToolIds
+		}),
+		toolIds: runtimeToolIds
+	});
+	return extendRuntimeTools(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);
+}
+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) {
+	if (contributions.length === 0) return definition;
+	const additions = contributions.map(({ tool }) => deepFreeze({ ...tool }));
+	const additionIds = additions.map(({ id }) => id).sort();
+	return deepFreeze({
+		...definition,
+		toolGrantSet: {
+			revision: digest({
+				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 deepFreeze({
+		description,
+		digest: toolDigest,
+		id,
+		idempotency,
+		inputSchema,
+		pluginId,
+		risk,
+		version
+	});
+}
+function digest(value) {
+	return createSha256Digest(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
+//#region src/modules/agent-catalog/module.ts
+function createRivusAgentCatalog(options = {}) {
+	const resolver = createRivusAgentDefinitionResolver(options.toolDescriptorProviders ?? []);
+	return Object.freeze({
+		createPluginCatalog: createRivusPluginCatalog,
+		resolve: (catalog, deployment) => resolver.resolve(catalog, deployment)
+	});
+}
+//#endregion
+export { RIVUS_MEMORY_TOOL_VERSION as a, RIVUS_MEMORY_TOOL_PLUGIN_ID as i, createRivusHostToolDescriptorProvider as n, createRivusMemoryToolContract as o, RIVUS_MEMORY_TOOL_ID as r, createRivusAgentCatalog as t };