@rivus/agent 0.13.2 → 0.14.0

package/examples/pi-feishu.bootstrap.ts

@@ -1,4 +1,5 @@
-import { mkdir, writeFile } from "node:fs/promises";
+import { mkdir } from "node:fs/promises";
+import { homedir } from "node:os";
 import { Effect } from "effect";
 import * as Lark from "@larksuiteoapi/node-sdk";
 import { AuthStorage, createAgentSession, ModelRegistry, SessionManager } from "@earendil-works/pi-coding-agent";
@@ -7,6 +8,7 @@ import {
   createJsonFileFeishuCardTargetRegistry,
   createJsonlAgentEventLog,
   createLazyFeishuWebSocketEventDispatcher,
+  mergePiProviderBaseUrlOverride,
   createRivusDaemonStatusHttpServer,
   createPiAgentLoop,
   createPiSessionRegistry,
@@ -24,6 +26,12 @@ import {
   type FeishuReceiveMessagePayload,
   type FeishuReceiveMessageReplayOptions
 } from "@rivus/agent";
+import {
+  createPiSkillReadTools,
+  createPiSessionResources,
+  resolvePiSessionToolNames,
+  validatePiSkillCommand
+} from "@rivus/agent/pi";
 
 type PiSessionOptions = NonNullable<Parameters<typeof createAgentSession>[0]>;
 
@@ -32,21 +40,42 @@ const CARD_TARGETS_FILE = `${STATE_DIR}/feishu-card-targets.json`;
 const EVENT_LOG_FILE = `${STATE_DIR}/agent-events.jsonl`;
 const PI_AUTH_FILE = `${STATE_DIR}/pi-auth.json`;
 const PI_MODELS_FILE = `${STATE_DIR}/pi-models.json`;
+const PI_AGENT_DIR = `${STATE_DIR}/pi-agent`;
 
 export async function createRivusDaemonProcess(
   context: RivusDaemonBootstrapContext
 ): Promise<RivusDaemonProcess & RivusDaemonPromptRunner & RivusDaemonStatusReporter & RivusDaemonFeishuReplayRunner> {
-  await mkdir(STATE_DIR, { recursive: true });
+  await mkdir(PI_AGENT_DIR, { recursive: true });
 
   const piSessionOptions = await createPiSessionOptions(context);
   const sessionRegistry = createPiSessionRegistry({
     createSession: async () => {
-      const result = await createAgentSession({
-        ...piSessionOptions,
-        sessionManager: SessionManager.create(process.cwd())
+      const cwd = process.cwd();
+      const resources = await createPiSessionResources({
+        agentDir: PI_AGENT_DIR,
+        cwd,
+        homeDirectory: homedir()
+      });
+      const customTools = createPiSkillReadTools({
+        cwd,
+        runtimeToolIds: [],
+        skillPaths: resources.skillNames.size > 0 ? resources.skillPaths : []
       });
+      const result = await createAgentSession(
+        resources.withSessionOptions({
+          ...piSessionOptions,
+          customTools,
+          excludeTools: [],
+          sessionManager: SessionManager.create(cwd),
+          tools: [...resolvePiSessionToolNames([], customTools)]
+        })
+      );
       return {
         dispose: () => result.session.dispose(),
+        preparePrompt: (input) => {
+          validatePiSkillCommand(input.text, resources.skillNames);
+          return input.text;
+        },
         session: result.session
       };
     }
@@ -207,19 +236,5 @@ function readOptionalPort(value: string | undefined): number | undefined {
 }
 
 async function writeProviderBaseUrlOverride(provider: string, baseUrl: string): Promise<void> {
-  await writeFile(
-    PI_MODELS_FILE,
-    `${JSON.stringify(
-      {
-        providers: {
-          [provider]: {
-            baseUrl
-          }
-        }
-      },
-      null,
-      2
-    )}\n`,
-    "utf8"
-  );
+  await mergePiProviderBaseUrlOverride({ baseUrl, filePath: PI_MODELS_FILE, provider });
 }

package/examples/rivus-starter.plugin.mjs

@@ -1,6 +1,7 @@
 import { readCurrentWeather } from "./current-weather.mjs";
 
 const TOOL_ID = "rivus-starter/current-weather";
+const RUNTIME_TOOLS = ["read", "bash", "edit", "write", "grep", "find", "ls"];
 
 export default {
   manifest: {
@@ -34,8 +35,9 @@ export default {
     registry.registerAgentProfile({
       displayName: "Rivus Agent",
       id: "agent-a",
-      memory: { scopes: [] },
+      memory: { scopes: ["agent-private"] },
       model: {},
+      runtimeTools: { allow: RUNTIME_TOOLS },
       skills: { allow: [] },
       systemPrompt:
         "You are a concise local assistant. For current or today's weather, call current-weather. If the user did not name a location, omit location and report the Tool's resolved place.",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rivus/agent",
-  "version": "0.13.2",
+  "version": "0.14.0",
   "description": "A local agent daemon core built around a usable agent harness and domain events.",
   "type": "module",
   "license": "MIT",
@@ -45,7 +45,12 @@
     "./mcp": {
       "types": "./dist/mcp.d.ts",
       "import": "./dist/mcp.js"
-    }
+    },
+    "./bootstrap/pi-feishu": {
+      "types": "./dist/bootstrap/pi-feishu.d.ts",
+      "import": "./dist/bootstrap/pi-feishu.js"
+    },
+    "./plugin/starter": "./examples/rivus-starter.plugin.mjs"
   },
   "files": [
     "dist",
@@ -68,6 +73,7 @@
     "format:check": "vp fmt --check",
     "lint": "vp lint",
     "lint:fix": "vp lint --fix",
+    "package-api:update": "vp pack && node scripts/package-api-report.mjs --write",
     "package:check": "node scripts/check-npm-package.mjs",
     "prepublishOnly": "npm run check",
     "release:check": "node scripts/check-npm-release.mjs",

package/dist/agent-loop.js

@@ -1,121 +0,0 @@
-import { Effect, Stream } from "effect";
-//#region src/application/agent/agent-loop.ts
-function createAgentLoopTextDelta(delta) {
-	return {
-		delta,
-		type: "assistant_text_delta"
-	};
-}
-function createAgentLoopTurnStart() {
-	return { type: "turn_start" };
-}
-function normalizeAgentLoopEvent(event) {
-	return typeof event === "string" ? createAgentLoopTextDelta(event) : event;
-}
-function createAgentLoopThinkingDelta(delta) {
-	return {
-		delta,
-		type: "assistant_thinking_delta"
-	};
-}
-function createAgentLoopModelExecutionStart(options) {
-	return {
-		...options,
-		type: "model_execution_start"
-	};
-}
-function createAgentLoopModelExecutionEnd(options) {
-	return {
-		...options,
-		type: "model_execution_end"
-	};
-}
-function createAgentLoopSkillExecutionStart(options) {
-	return {
-		...options,
-		type: "skill_execution_start"
-	};
-}
-function createAgentLoopSkillExecutionEnd(options) {
-	return {
-		...options,
-		type: "skill_execution_end"
-	};
-}
-function createAgentLoopToolExecutionStart(options) {
-	return {
-		input: options.input,
-		toolCallId: options.toolCallId,
-		toolName: options.toolName,
-		type: "tool_execution_start"
-	};
-}
-function createAgentLoopToolExecutionUpdate(options) {
-	return {
-		input: options.input,
-		partialResult: options.partialResult,
-		toolCallId: options.toolCallId,
-		toolName: options.toolName,
-		type: "tool_execution_update"
-	};
-}
-function createAgentLoopToolExecutionEnd(options) {
-	return {
-		isError: options.isError,
-		result: options.result,
-		toolCallId: options.toolCallId,
-		toolName: options.toolName,
-		type: "tool_execution_end"
-	};
-}
-function createEventAgentLoop(options) {
-	return { run: (input) => {
-		const events = typeof options.events === "function" ? options.events(input) : options.events;
-		if (isPromiseLike(events)) return Stream.fromEffect(Effect.tryPromise({
-			try: () => events,
-			catch: (cause) => cause
-		})).pipe(Stream.flatMap((resolvedEvents) => Stream.fromIterable(resolvedEvents)), Stream.map(normalizeAgentLoopEvent));
-		return Stream.fromIterable(events).pipe(Stream.map(normalizeAgentLoopEvent));
-	} };
-}
-function createAsyncIterableAgentLoop(options) {
-	return { run: (input) => Stream.fromAsyncIterable(options.run(input), (error) => error).pipe(Stream.map(normalizeAgentLoopEvent)) };
-}
-function createAgentLoopFromCallback(run) {
-	return { run: (input) => Stream.fromEffect(Effect.try({
-		try: () => run(input),
-		catch: (cause) => cause
-	})).pipe(Stream.flatMap(streamFromAgentLoopCallbackResult)) };
-}
-function createTextAgentLoop(options) {
-	return { run: (input) => Stream.fromEffect(options.generate(input)).pipe(Stream.map((delta) => createAgentLoopTextDelta(delta))) };
-}
-function createTextAgentLoopFromCallback(generate) {
-	return createTextAgentLoop({ generate: (input) => Effect.tryPromise({
-		try: async () => generate(input),
-		catch: (cause) => cause
-	}) });
-}
-function isPromiseLike(value) {
-	return typeof value === "object" && value !== null && "then" in value && typeof value.then === "function";
-}
-function streamFromAgentLoopCallbackResult(result) {
-	if (Effect.isEffect(result)) return Stream.fromEffect(result).pipe(Stream.flatMap(streamFromAgentLoopCallbackOutput));
-	if (isPromiseLike(result)) return Stream.fromEffect(Effect.tryPromise({
-		try: () => Promise.resolve(result),
-		catch: (cause) => cause
-	})).pipe(Stream.flatMap(streamFromAgentLoopCallbackOutput));
-	return streamFromAgentLoopCallbackOutput(result);
-}
-function streamFromAgentLoopCallbackOutput(output) {
-	if (isEffectStream(output)) return output.pipe(Stream.map(normalizeAgentLoopEvent));
-	return (isAsyncIterable(output) ? Stream.fromAsyncIterable(output, (error) => error) : Stream.fromIterable(output)).pipe(Stream.map(normalizeAgentLoopEvent));
-}
-function isAsyncIterable(value) {
-	return Symbol.asyncIterator in value && typeof value[Symbol.asyncIterator] === "function";
-}
-function isEffectStream(value) {
-	return typeof value === "object" && value !== null && Stream.StreamTypeId in value;
-}
-//#endregion
-export { createAgentLoopSkillExecutionStart as a, createAgentLoopToolExecutionEnd as c, createAgentLoopTurnStart as d, createAsyncIterableAgentLoop as f, createTextAgentLoopFromCallback as h, createAgentLoopSkillExecutionEnd as i, createAgentLoopToolExecutionStart as l, createTextAgentLoop as m, createAgentLoopModelExecutionEnd as n, createAgentLoopTextDelta as o, createEventAgentLoop as p, createAgentLoopModelExecutionStart as r, createAgentLoopThinkingDelta as s, createAgentLoopFromCallback as t, createAgentLoopToolExecutionUpdate as u };

package/dist/agent-memory.d.ts

@@ -1,100 +0,0 @@
-//#region src/domain/agent-memory.d.ts
-declare const MEMORY_SCOPES: readonly ["conversation", "agent-private", "project", "shared-user-profile"];
-declare const RIVUS_MEMORY_TOOL_ID = "memory";
-declare const RIVUS_MEMORY_TOOL_PLUGIN_ID = "rivus-core";
-declare const RIVUS_MEMORY_TOOL_VERSION = "1.0.0";
-type MemoryScope = (typeof MEMORY_SCOPES)[number];
-type MemoryState = "proposed" | "confirmed" | "superseded" | "tombstoned";
-type MemoryInvocationAudience = "group" | "private";
-interface AgentMemoryIdentity {
-  readonly audience: MemoryInvocationAudience;
-  readonly conversationId?: string;
-  readonly projectId?: string;
-  readonly subjectId: string;
-  readonly tenantId: string;
-}
-interface AgentMemoryAuthority extends AgentMemoryIdentity {
-  readonly scopes: ReadonlyArray<MemoryScope>;
-}
-interface MemoryBinding {
-  readonly agentId: string;
-  readonly conversationId?: string;
-  readonly projectId?: string;
-  readonly scope: MemoryScope;
-  readonly subjectId: string;
-  readonly tenantId: string;
-}
-interface MemoryRecord {
-  readonly content: string;
-  readonly conversationSafe: boolean;
-  readonly id: string;
-  readonly revision: number;
-  readonly scope: MemoryScope;
-  readonly state: MemoryState;
-  readonly tombstoneReason?: string;
-}
-interface AgentMemorySnapshot {
-  readonly binding: MemoryBinding;
-  readonly record: MemoryRecord;
-}
-declare function createMemoryNamespace(binding: MemoryBinding): string;
-declare function restrictMemoryScopesForAudience(scopes: ReadonlyArray<MemoryScope>, audience: MemoryInvocationAudience): ReadonlyArray<MemoryScope>;
-declare function createRivusMemoryToolContract(scopes: ReadonlyArray<MemoryScope>): Readonly<{
-  description: "Search and read Memory inside Host-bound scopes; propose or request forgetting only in writable private scopes.";
-  digest: "sha256:rivus-memory-v3";
-  id: "memory";
-  idempotency: "required";
-  inputSchema: Readonly<{
-    additionalProperties: false;
-    properties: {
-      scope?: {
-        description: string;
-        enum: ("conversation" | "agent-private" | "project" | "shared-user-profile")[];
-        type: string;
-      };
-      command: {
-        description: string;
-        enum: string[];
-        type: string;
-      };
-      id: {
-        description: string;
-        minLength: number;
-        type: string;
-      };
-      input: {
-        additionalProperties: boolean;
-        description: string;
-        properties: {
-          content: {
-            minLength: number;
-            type: string;
-          };
-        };
-        required: string[];
-        type: string;
-      };
-      query: {
-        additionalProperties: boolean;
-        description: string;
-        properties: {
-          query: {
-            type: string;
-          };
-        };
-        required: string[];
-        type: string;
-      };
-      reason: {
-        description: string;
-        type: string;
-      };
-    };
-    required: string[];
-    type: "object";
-  }>;
-  risk: "mutate";
-  version: "1.0.0";
-}>;
-//#endregion
-export { MemoryBinding as a, MemoryScope as c, RIVUS_MEMORY_TOOL_PLUGIN_ID as d, RIVUS_MEMORY_TOOL_VERSION as f, restrictMemoryScopesForAudience as h, MEMORY_SCOPES as i, MemoryState as l, createRivusMemoryToolContract as m, AgentMemoryIdentity as n, MemoryInvocationAudience as o, createMemoryNamespace as p, AgentMemorySnapshot as r, MemoryRecord as s, AgentMemoryAuthority as t, RIVUS_MEMORY_TOOL_ID as u };

package/dist/agent-memory.js

@@ -1,114 +0,0 @@
-//#region src/domain/rivus-plugin.ts
-const RIVUS_PLUGIN_API_VERSION = "1";
-function requiresToolApproval(risk) {
-	return risk === "irreversible" || risk === "host-control";
-}
-var RivusToolInputRejected = class extends Error {
-	name = "RivusToolInputRejected";
-};
-var InvalidRivusPlugin = class extends Error {
-	name = "InvalidRivusPlugin";
-};
-//#endregion
-//#region src/domain/agent-memory.ts
-const MEMORY_SCOPES = [
-	"conversation",
-	"agent-private",
-	"project",
-	"shared-user-profile"
-];
-const RIVUS_MEMORY_TOOL_ID = "memory";
-const RIVUS_MEMORY_TOOL_PLUGIN_ID = "rivus-core";
-const RIVUS_MEMORY_TOOL_VERSION = "1.0.0";
-function createMemoryNamespace(binding) {
-	const encode = (value) => encodeURIComponent(value);
-	switch (binding.scope) {
-		case "conversation": return [
-			binding.tenantId,
-			binding.agentId,
-			binding.subjectId,
-			binding.conversationId ?? "",
-			binding.scope
-		].map(encode).join("/");
-		case "agent-private": return [
-			binding.tenantId,
-			binding.agentId,
-			binding.subjectId,
-			binding.scope
-		].map(encode).join("/");
-		case "project": return [
-			binding.tenantId,
-			binding.agentId,
-			binding.projectId ?? "",
-			binding.scope
-		].map(encode).join("/");
-		case "shared-user-profile": return [
-			binding.tenantId,
-			binding.subjectId,
-			binding.scope
-		].map(encode).join("/");
-	}
-}
-function restrictMemoryScopesForAudience(scopes, audience) {
-	return audience === "group" ? scopes.filter((scope) => scope === "conversation" || scope === "project") : [...scopes];
-}
-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
-export { createMemoryNamespace as a, InvalidRivusPlugin as c, requiresToolApproval as d, RIVUS_MEMORY_TOOL_VERSION as i, RIVUS_PLUGIN_API_VERSION as l, RIVUS_MEMORY_TOOL_ID as n, createRivusMemoryToolContract as o, RIVUS_MEMORY_TOOL_PLUGIN_ID as r, restrictMemoryScopesForAudience as s, MEMORY_SCOPES as t, RivusToolInputRejected as u };