@rivus/agent 0.14.3 → 0.15.0

package/dist/chunks/rivus-tool.js

@@ -0,0 +1,158 @@
+import { Unsafe } from "typebox";
+//#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/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
+//#region src/core/application/tool-execution/authority/tool-risk-policy.ts
+function requiresToolApproval(risk) {
+	return risk === "irreversible" || risk === "host-control";
+}
+//#endregion
+//#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
+export { InvalidStableJson as a, normalizeStableJson as c, resolveInvocationAuthority as d, requiresToolApproval as i, InvalidInvocationAuthority as l, PI_SKILL_READER_TOOL_NAME as n, InvalidToolInput as o, createPiSkillRuntime as r, createToolInputDigest as s, RivusToolInputRejected as t, createInvocationAuthority as u };

package/dist/chunks/sha256-digest.js

@@ -1,12 +1,7 @@
-import { createHash, randomUUID } from "node:crypto";
-//#region src/platform/identity/random-id.ts
-function createRandomId() {
-	return randomUUID();
-}
-//#endregion
+import { createHash } from "node:crypto";
 //#region src/platform/identity/sha256-digest.ts
 function createSha256Digest(value) {
 	return `sha256:${createHash("sha256").update(value).digest("hex")}`;
 }
 //#endregion
-export { createRandomId as n, createSha256Digest as t };
+export { createSha256Digest as t };