@rivus/agent 0.14.2 → 0.14.4

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

@@ -1,9 +1,21 @@
-import { o as AgentMemoryAuthority } from "./api.js";
-import { ot as RivusToolRisk, rt as RivusToolGrantSet } from "./api2.js";
+import { y as RivusToolRisk } from "./rivus-skill.js";
 import { Effect } from "effect";
 import { TSchema } from "typebox";
 
-//#region src/modules/tool-execution/domain/authority/invocation-authority.d.ts
+//#region src/core/application/tool-execution/authority/invocation-authority-registry.d.ts
+type InvocationMemoryScope = "conversation" | "agent-private" | "project" | "shared-user-profile";
+interface InvocationMemoryAuthority {
+  readonly audience: "group" | "private";
+  readonly conversationId?: string;
+  readonly projectId?: string;
+  readonly scopes: ReadonlyArray<InvocationMemoryScope>;
+  readonly subjectId: string;
+  readonly tenantId: string;
+}
+interface InvocationToolGrantSet {
+  readonly revision: string;
+  readonly toolIds: ReadonlyArray<string>;
+}
 interface InvocationAuthorityRef {
   readonly id: string;
 }
@@ -13,84 +25,21 @@ interface InvocationAuthority {
   readonly conversationId?: string;
   readonly endpointId?: string;
   readonly instanceId: string;
-  readonly memory?: AgentMemoryAuthority;
+  readonly memory?: InvocationMemoryAuthority;
   readonly runId: string;
   readonly sessionKey: string;
   readonly sourceMessageId: string;
   readonly tenantKey: string;
-  readonly toolGrantSet: RivusToolGrantSet;
+  readonly toolGrantSet: InvocationToolGrantSet;
 }
 declare class InvalidInvocationAuthority extends Error {
   readonly name = "InvalidInvocationAuthority";
 }
 //#endregion
-//#region src/modules/tool-execution/domain/authority/tool-risk.d.ts
-declare function requiresToolApproval(risk: RivusToolRisk): boolean;
-//#endregion
-//#region src/modules/tool-execution/domain/operation/tool-operation.d.ts
-interface ToolOperationBinding {
-  readonly agentId: string;
-  readonly inputDigest: string;
-  readonly instanceId: string;
-  readonly sourceMessageId: string;
-  readonly toolId: string;
-  readonly toolVersion: string;
-}
-type ToolOperationState = {
-  readonly status: "pending";
-} | {
-  readonly result: unknown;
-  readonly status: "completed";
-} | {
-  readonly reason: string;
-  readonly status: "reconciliation-required";
-} | {
-  readonly status: "aborted";
-};
-interface ToolOperationReconciliationAction {
-  readonly actorId: string;
-  readonly at: string;
-  readonly note: string;
-}
-interface ToolOperationReconciliation extends ToolOperationReconciliationAction {
-  readonly outcome: "applied" | "not-applied";
-}
-interface ToolOperationRecord {
-  readonly binding: ToolOperationBinding;
-  readonly operationId: string;
-  readonly reconciliation?: ToolOperationReconciliation;
-  readonly revision: number;
-  readonly state: ToolOperationState;
-}
-type ToolOperationReconciliationOutcome = {
-  readonly result: unknown;
-  readonly status: "applied";
-} | {
-  readonly status: "not-applied";
-};
-type ToolOperationBeginResult = {
-  readonly status: "acquired";
-} | {
-  readonly result: unknown;
-  readonly status: "completed";
-} | {
-  readonly status: "blocked";
-  readonly reason: string;
-};
-type ToolOperationInspectResult = {
-  readonly status: "missing";
-} | {
-  readonly result: unknown;
-  readonly status: "completed";
-} | {
-  readonly status: "blocked";
-  readonly reason: string;
-};
-//#endregion
-//#region src/modules/tool-execution/application/authority/invocation-authority-registry.d.ts
-declare function createInvocationAuthority(authority: InvocationAuthority): InvocationAuthorityRef;
+//#region src/core/application/tool-execution/authority/tool-risk-policy.d.ts
+type ToolRisk = "observe" | "mutate" | "irreversible" | "host-control";
 //#endregion
-//#region src/modules/tool-execution/application/brokerage/tool-broker-ports.d.ts
+//#region src/core/application/tool-execution/brokerage/tool-broker-ports.d.ts
 interface AuthorizationPolicyState {
   readonly epoch: number;
   readonly revokedToolIds: ReadonlyArray<string>;
@@ -107,10 +56,8 @@ interface ToolApprovalRequest {
   readonly callId: string;
   readonly toolId: string;
   readonly toolVersion: string;
-  readonly risk: RivusToolRisk;
+  readonly risk: ToolRisk;
 }
-//#endregion
-//#region src/modules/tool-execution/application/brokerage/tool-broker.d.ts
 interface ToolExecutionRequest {
   readonly approvalId?: string;
   readonly authority: InvocationAuthorityRef;
@@ -120,21 +67,6 @@ interface ToolExecutionRequest {
   readonly toolId: string;
   readonly version: string;
 }
-declare class ToolInvocationDenied extends Error {
-  readonly name = "ToolInvocationDenied";
-}
-//#endregion
-//#region src/modules/tool-execution/domain/input/stable-tool-input.d.ts
-declare class InvalidStableJson extends Error {
-  readonly name: string;
-}
-declare class InvalidToolInput extends InvalidStableJson {
-  readonly name = "InvalidToolInput";
-}
-declare function normalizeStableJson(value: unknown): unknown;
-//#endregion
-//#region src/modules/tool-execution/application/brokerage/tool-input-digest.d.ts
-declare function createToolInputDigest(input: unknown): string;
 //#endregion
 //#region src/adapters/pi/tool-execution/pi-tool-definition.d.ts
 type PiToolContent = {
@@ -185,4 +117,4 @@ interface PiToolApprovalGateway {
   requestApproval(request: PiToolApprovalRequest): Promise<void>;
 }
 //#endregion
-export { InvalidInvocationAuthority as C, requiresToolApproval as S, InvocationAuthorityRef as T, ToolOperationInspectResult as _, PiToolResult as a, ToolOperationRecord as b, InvalidToolInput as c, ToolInvocationDenied as d, AuthorizationPolicyState as f, ToolOperationBinding as g, ToolOperationBeginResult as h, PiToolDefinition as i, normalizeStableJson as l, createInvocationAuthority as m, PiToolApprovalRequest as n, createToolInputDigest as o, ToolApprovalRequest as p, PiToolContent as r, InvalidStableJson as s, PiToolApprovalGateway as t, ToolExecutionRequest as u, ToolOperationReconciliation as v, InvocationAuthority as w, ToolOperationState as x, ToolOperationReconciliationOutcome as y };
+export { PiToolResult as a, ToolExecutionRequest as c, InvocationAuthorityRef as d, PiToolDefinition as i, InvalidInvocationAuthority as l, PiToolApprovalRequest as n, AuthorizationPolicyState as o, PiToolContent as r, ToolApprovalRequest as s, PiToolApprovalGateway as t, InvocationAuthority as u };

package/dist/chunks/pi.js

@@ -1,6 +1,6 @@
 import { l as toEffectAgentLoopInput } from "./agent-loop.js";
-import "./api.js";
-import { h as requiresToolApproval, o as createToolInputDigest, p as createInvocationAuthority } from "./pi-skill-tool.js";
+import { t as createSha256Digest } from "./sha256-digest.js";
+import { a as requiresToolApproval, r as createToolInputDigest$1, s as createInvocationAuthority } from "./tool-input-digest.js";
 import { createHash } from "node:crypto";
 import { readFile, realpath, stat } from "node:fs/promises";
 import { isAbsolute, join, relative } from "node:path";
@@ -294,6 +294,9 @@ function createPiToolProxyDefinitions$1(options) {
 		};
 	});
 }
+function createToolInputDigest(input) {
+	return createToolInputDigest$1(input, createSha256Digest);
+}
 function createPiToolNameResolver$1(tools) {
 	const toolIdsByPiName = new Map(tools.map((tool) => [toPiToolName(tool.id), tool.id]));
 	return (toolName) => toolIdsByPiName.get(toolName) ?? toolName;

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

@@ -0,0 +1,508 @@
+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 };