@rivus/agent 0.14.2 → 0.14.4

package/dist/chunks/tool-input-digest.js

@@ -0,0 +1,158 @@
+import { Unsafe } from "typebox";
+//#region src/adapters/pi/skills/pi-skill-tool.ts
+const PI_SKILL_READER_TOOL_NAME = "rivus_read_skill";
+function createPiSkillRuntime(skills) {
+	if (skills.length === 0) return Object.freeze({ prompt: "" });
+	const skillsById = new Map(skills.map((skill) => [skill.id, skill]));
+	const prompt = [
+		"Granted Skills are versioned instructions loaded on demand.",
+		`Before following a Skill, call ${PI_SKILL_READER_TOOL_NAME} with its exact ID and follow the returned content.`,
+		"Granted Skill catalog:",
+		...skills.map((skill) => `- ${skill.id} | ${skill.title} | v${skill.version} | ${skill.digest}`)
+	].join("\n");
+	const tool = {
+		description: "Read the full versioned instructions for one Skill granted to this Agent Runtime.",
+		execute: async (_callId, input) => {
+			const skillId = readSkillId(input);
+			const skill = skillsById.get(skillId);
+			if (!skill) throw new Error(`Skill is not granted: ${skillId}`);
+			const details = {
+				contentLength: skill.content.length,
+				digest: skill.digest,
+				skillId: skill.id,
+				title: skill.title,
+				version: skill.version
+			};
+			return {
+				content: [{
+					text: skill.content,
+					type: "text"
+				}],
+				details
+			};
+		},
+		executionMode: "sequential",
+		label: "Read granted Skill",
+		name: PI_SKILL_READER_TOOL_NAME,
+		parameters: Unsafe({
+			additionalProperties: false,
+			properties: { skillId: {
+				description: "Exact Skill ID from the granted Skill catalog.",
+				type: "string"
+			} },
+			required: ["skillId"],
+			type: "object"
+		}),
+		promptSnippet: `${PI_SKILL_READER_TOOL_NAME}: read one granted Skill by exact ID`
+	};
+	return Object.freeze({
+		prompt,
+		tool
+	});
+}
+function readSkillId(input) {
+	if (input === null || typeof input !== "object" || Array.isArray(input) || typeof input.skillId !== "string") throw new Error("Skill reader input requires a string skillId");
+	return input.skillId;
+}
+//#endregion
+//#region src/core/application/agent-catalog/contracts/rivus-tool.ts
+var RivusToolInputRejected = class extends Error {
+	name = "RivusToolInputRejected";
+};
+//#endregion
+//#region src/core/application/tool-execution/authority/invocation-authority-registry.ts
+const authorities = /* @__PURE__ */ new WeakMap();
+let localAuthoritySequence = 0;
+var InvalidInvocationAuthority = class extends Error {
+	name = "InvalidInvocationAuthority";
+};
+function createInvocationAuthority(authority, identity = { next: () => String(++localAuthoritySequence) }) {
+	const reference = Object.freeze({ id: `authority:${identity.next()}` });
+	authorities.set(reference, normalizeInvocationAuthority(authority));
+	return reference;
+}
+function resolveInvocationAuthority(reference) {
+	const authority = authorities.get(reference);
+	if (!authority) throw new InvalidInvocationAuthority("invocation authority was not issued by this host");
+	return authority;
+}
+function normalizeInvocationAuthority(authority) {
+	if (!isRecord(authority) || typeof authority.sourceMessageId !== "string" || !authority.sourceMessageId.trim()) throw new InvalidInvocationAuthority("invocation authority requires a trusted source message id");
+	if (authority.endpointId !== void 0 && (!authority.endpointId || !authority.endpointId.trim())) throw new InvalidInvocationAuthority("invocation authority requires a trusted endpoint id");
+	return Object.freeze({
+		...authority,
+		...authority.allowedActorOpenIds === void 0 ? {} : { allowedActorOpenIds: Object.freeze([...authority.allowedActorOpenIds]) },
+		...authority.memory === void 0 ? {} : { memory: freezeMemoryAuthority(authority.memory) },
+		toolGrantSet: freezeGrantSet(authority.toolGrantSet)
+	});
+}
+function freezeMemoryAuthority(value) {
+	const scopes = value.audience === "group" ? value.scopes.filter(isGroupMemoryScope) : [...value.scopes];
+	return Object.freeze({
+		...value,
+		scopes: Object.freeze(scopes)
+	});
+}
+function freezeGrantSet(value) {
+	return Object.freeze({
+		revision: value.revision,
+		toolIds: Object.freeze([...value.toolIds])
+	});
+}
+function isGroupMemoryScope(value) {
+	return value === "conversation" || value === "project";
+}
+function isRecord(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+//#endregion
+//#region src/core/application/tool-execution/authority/tool-risk-policy.ts
+function requiresToolApproval(risk) {
+	return risk === "irreversible" || risk === "host-control";
+}
+//#endregion
+//#region src/core/application/tool-execution/brokerage/tool-input-digest.ts
+var InvalidStableJson = class extends Error {
+	name = "InvalidStableJson";
+};
+var InvalidToolInput = class extends InvalidStableJson {
+	name = "InvalidToolInput";
+};
+function createToolInputDigest(input, digest) {
+	try {
+		return digest(serializeStableJson(input, /* @__PURE__ */ new Set()));
+	} catch (error) {
+		if (error instanceof InvalidStableJson) throw new InvalidToolInput(error.message);
+		throw error;
+	}
+}
+function normalizeStableJson(value) {
+	return JSON.parse(serializeStableJson(value, /* @__PURE__ */ new Set()));
+}
+function serializeStableJson(value, ancestors) {
+	if (value === null) return "null";
+	if (typeof value === "string" || typeof value === "boolean") return JSON.stringify(value);
+	if (typeof value === "number") {
+		if (!Number.isFinite(value)) throw new InvalidStableJson("stable JSON numbers must be finite");
+		return JSON.stringify(value);
+	}
+	if (typeof value !== "object" || value === null) throw new InvalidStableJson("value must contain only stable JSON values");
+	if (ancestors.has(value)) throw new InvalidStableJson("stable JSON must not contain cycles");
+	ancestors.add(value);
+	try {
+		if (Array.isArray(value)) {
+			const output = [];
+			for (let index = 0; index < value.length; index += 1) {
+				if (!Object.hasOwn(value, index)) throw new InvalidStableJson("stable JSON arrays must not contain holes");
+				output.push(serializeStableJson(value[index], ancestors));
+			}
+			return `[${output.join(",")}]`;
+		}
+		if (Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null) throw new InvalidStableJson("stable JSON objects must be plain objects");
+		return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${serializeStableJson(value[key], ancestors)}`).join(",")}}`;
+	} finally {
+		ancestors.delete(value);
+	}
+}
+//#endregion
+export { requiresToolApproval as a, resolveInvocationAuthority as c, createPiSkillRuntime as d, normalizeStableJson as i, RivusToolInputRejected as l, InvalidToolInput as n, InvalidInvocationAuthority as o, createToolInputDigest as r, createInvocationAuthority as s, InvalidStableJson as t, PI_SKILL_READER_TOOL_NAME as u };