@rivus/agent 0.6.0 → 0.6.1

package/dist/tool-input-digest.js

@@ -0,0 +1,126 @@
+import { s as restrictMemoryScopesForAudience } from "./agent-memory.js";
+import { createHash, randomUUID } from "node:crypto";
+import { Unsafe } from "typebox";
+//#region src/infrastructure/pi/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/application/delegation/tool-authority.ts
+const authorities = /* @__PURE__ */ new WeakMap();
+var InvalidInvocationAuthority = class extends Error {
+	name = "InvalidInvocationAuthority";
+};
+function createInvocationAuthority(authority) {
+	if (!authority.sourceMessageId.trim()) throw new InvalidInvocationAuthority("invocation authority requires a trusted source message id");
+	const reference = Object.freeze({ id: `authority:${randomUUID()}` });
+	const memory = authority.memory ? Object.freeze({
+		...authority.memory,
+		scopes: Object.freeze(restrictMemoryScopesForAudience(authority.memory.scopes, authority.memory.audience))
+	}) : void 0;
+	authorities.set(reference, Object.freeze({
+		...authority,
+		...memory ? { memory } : {}
+	}));
+	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;
+}
+//#endregion
+//#region src/application/delegation/tool-input-digest.ts
+var InvalidStableJson = class extends Error {
+	name = "InvalidStableJson";
+};
+var InvalidToolInput = class extends InvalidStableJson {
+	name = "InvalidToolInput";
+};
+function createToolInputDigest(input) {
+	let canonical;
+	try {
+		canonical = normalizeStableJson(input);
+	} catch (error) {
+		if (error instanceof InvalidStableJson) throw new InvalidToolInput(error.message);
+		throw error;
+	}
+	return `sha256:${createHash("sha256").update(JSON.stringify(canonical)).digest("hex")}`;
+}
+function normalizeStableJson(value) {
+	return canonicalize(value, /* @__PURE__ */ new Set());
+}
+function canonicalize(value, ancestors) {
+	if (value === null || typeof value === "string" || typeof value === "boolean") return value;
+	if (typeof value === "number") {
+		if (!Number.isFinite(value)) throw new InvalidStableJson("stable JSON numbers must be finite");
+		return Object.is(value, -0) ? 0 : value;
+	}
+	if (typeof value !== "object") 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)) return Array.from({ length: value.length }, (_, index) => {
+			if (!Object.hasOwn(value, index)) throw new InvalidStableJson("stable JSON arrays must not contain holes");
+			return canonicalize(value[index], ancestors);
+		});
+		const prototype = Object.getPrototypeOf(value);
+		if (prototype !== Object.prototype && prototype !== null) throw new InvalidStableJson("stable JSON objects must be plain objects");
+		return Object.fromEntries(Object.entries(value).sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0).map(([key, entry]) => [key, canonicalize(entry, ancestors)]));
+	} finally {
+		ancestors.delete(value);
+	}
+}
+//#endregion
+export { InvalidInvocationAuthority as a, PI_SKILL_READER_TOOL_NAME as c, normalizeStableJson as i, createPiSkillRuntime as l, InvalidToolInput as n, createInvocationAuthority as o, createToolInputDigest as r, resolveInvocationAuthority as s, InvalidStableJson as t };

package/examples/pi-feishu-deployment.bootstrap.ts

@@ -36,9 +36,6 @@ import {
   createLazyFeishuWebSocketEventDispatcher,
   createPiAgentLoop,
   createProjectMemoryPromptPreparer,
-  createPiSkillRuntime,
-  createPiToolNameResolver,
-  createPiToolProxyDefinitions,
   createPiSessionRegistry,
   createRoutedHumanInteractionToolApprovalService,
   createSessionScheduler,
@@ -66,7 +63,12 @@ import {
   type RivusDeploymentBootstrapContext,
   type RivusThinkingLevel
 } from "@rivus/agent";
-import { createPiProjectSkillReadTool } from "@rivus/agent/pi";
+import {
+  createPiProjectSkillReadTool,
+  createPiSkillRuntime,
+  createPiToolNameResolver,
+  createPiToolProxyDefinitions
+} from "@rivus/agent/pi";
 
 type PiSessionOptions = NonNullable<Parameters<typeof createAgentSession>[0]>;
 
@@ -233,6 +235,7 @@ export async function createRivusDeploymentAdapters(context: RivusDeploymentBoot
         agentId: input.agentId,
         botOpenId,
         cardRollover: cardRollover.transport,
+        finalizeRun: (runId) => cardRollover.rollover.releaseRun(runId),
         cancel: input.cancel,
         endpointId: input.endpointId,
         eventDispatcher: createLazyFeishuWebSocketEventDispatcher(() => new Lark.EventDispatcher({})),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rivus/agent",
-  "version": "0.6.0",
+  "version": "0.6.1",
   "description": "A local agent daemon core built around a usable agent harness and domain events.",
   "type": "module",
   "license": "MIT",