@rivus/agent 0.7.0 → 0.8.0

package/dist/mcp.js

@@ -0,0 +1,416 @@
+import { l as createBackgroundSessionToolContracts, s as createBackgroundSessionKey } from "./background-session-authority.js";
+import { a as readBackgroundSessionWaitInput, i as readBackgroundSessionString, n as readBackgroundSessionObject, r as readBackgroundSessionPhase, t as readBackgroundSessionInteger } from "./background-session-input.js";
+import { randomUUID } from "node:crypto";
+import { pathToFileURL } from "node:url";
+import { createServer } from "node:http";
+//#region src/infrastructure/mcp/background-session-mcp-server.ts
+const BACKGROUND_SESSION_MCP_SERVER_NAME = "rivus-background-sessions";
+const BACKGROUND_SESSION_MCP_SERVER_VERSION = "1.0.0";
+var BackgroundSessionMcpError = class extends Error {
+	name = "BackgroundSessionMcpError";
+};
+function createBackgroundSessionMcpServer(options) {
+	const input = options.input ?? process.stdin;
+	const output = options.output ?? process.stdout;
+	const fetchImplementation = options.fetch ?? fetch;
+	const enabledTools = new Set(options.enabledTools ?? [
+		"start",
+		"wait",
+		"list",
+		"status",
+		"send",
+		"stop"
+	]);
+	const tools = createBackgroundSessionToolContracts().filter(({ id }) => enabledTools.has(id.slice(11))).map((contract) => ({
+		description: contract.description,
+		inputSchema: contract.inputSchema,
+		name: contract.id,
+		outputSchema: { type: "object" }
+	}));
+	const serverInfo = {
+		name: options.serverName ?? "rivus-background-sessions",
+		version: options.serverVersion ?? "1.0.0"
+	};
+	return { run: () => runMcpServer({
+		controlContext: options.controlContext,
+		controlToken: options.controlToken,
+		controlUrl: options.controlUrl,
+		fetchImplementation,
+		input,
+		output,
+		serverInfo,
+		tools
+	}) };
+}
+async function runBackgroundSessionMcpServer(options = {}) {
+	const controlUrl = requireEnv("RIVUS_MCP_CONTROL_URL");
+	const controlToken = requireEnv("RIVUS_MCP_CONTROL_TOKEN");
+	const context = parseContext(requireEnv("RIVUS_MCP_CONTEXT"));
+	const enabledTools = optionalEnv("RIVUS_MCP_TOOLS")?.split(",").map((tool) => tool.trim()).filter(Boolean);
+	await createBackgroundSessionMcpServer({
+		controlContext: context,
+		controlToken,
+		controlUrl,
+		...enabledTools ? { enabledTools } : {},
+		...options.fetch ? { fetch: options.fetch } : {},
+		...options.input ? { input: options.input } : {},
+		...options.output ? { output: options.output } : {}
+	}).run();
+}
+async function runMcpServer(options) {
+	const send = (message) => {
+		const body = JSON.stringify(message);
+		options.output.write(`Content-Length: ${Buffer.byteLength(body)}\r\n\r\n${body}`);
+	};
+	for await (const message of readMcpMessages(options.input)) {
+		if (!isRecord(message) || typeof message.id !== "number") continue;
+		const method = typeof message.method === "string" ? message.method : void 0;
+		if (!method) continue;
+		try {
+			switch (method) {
+				case "initialize":
+					send({
+						id: message.id,
+						result: {
+							capabilities: { tools: { listChanged: false } },
+							protocolVersion: "2025-03-26",
+							serverInfo: options.serverInfo
+						}
+					});
+					break;
+				case "ping":
+					send({
+						id: message.id,
+						result: {}
+					});
+					break;
+				case "tools/list":
+					send({
+						id: message.id,
+						result: { tools: options.tools }
+					});
+					break;
+				case "tools/call": {
+					const params = isRecord(message.params) ? message.params : {};
+					const name = typeof params.name === "string" ? params.name : "";
+					const command = name.startsWith("background.") ? name.slice(11) : void 0;
+					if (!command || !options.tools.some((tool) => tool.name === name)) {
+						send({
+							id: message.id,
+							error: {
+								code: -32602,
+								message: `unknown tool: ${name}`
+							}
+						});
+						break;
+					}
+					const response = await options.fetchImplementation(options.controlUrl, {
+						body: JSON.stringify({
+							command,
+							context: options.controlContext,
+							input: params.arguments ?? {}
+						}),
+						headers: {
+							authorization: `Bearer ${options.controlToken}`,
+							"content-type": "application/json"
+						},
+						method: "POST"
+					});
+					const envelope = await response.json();
+					if (!response.ok || envelope.error) {
+						const messageText = envelope.error?.message ?? `background session control failed with ${response.status}`;
+						send({
+							id: message.id,
+							error: {
+								code: -32e3,
+								message: messageText
+							}
+						});
+						break;
+					}
+					send({
+						id: message.id,
+						result: {
+							content: [{
+								text: JSON.stringify(envelope.result ?? null),
+								type: "text"
+							}],
+							isError: false
+						}
+					});
+					break;
+				}
+				default: send({
+					id: message.id,
+					error: {
+						code: -32601,
+						message: `method not found: ${method}`
+					}
+				});
+			}
+		} catch (error) {
+			send({
+				id: message.id,
+				error: {
+					code: -32e3,
+					message: error instanceof Error ? error.message : String(error)
+				}
+			});
+		}
+	}
+}
+async function* readMcpMessages(input) {
+	let buffer = "";
+	for await (const chunk of input) {
+		buffer += chunk.toString("utf8");
+		let parsed = parseNextMessage(buffer);
+		while (parsed) {
+			yield parsed.message;
+			buffer = Buffer.from(buffer).subarray(parsed.byteLength).toString("utf8");
+			parsed = parseNextMessage(buffer);
+		}
+	}
+}
+function parseNextMessage(buffer) {
+	const headerEnd = buffer.indexOf("\r\n\r\n");
+	if (headerEnd < 0) return void 0;
+	const contentLength = buffer.slice(0, headerEnd).split("\r\n").find((header) => /^Content-Length:\s*\d+$/i.test(header));
+	if (!contentLength) throw new BackgroundSessionMcpError("MCP message is missing a Content-Length header");
+	const byteLength = Number(contentLength.slice(15).trim());
+	const headerBytes = Buffer.byteLength(buffer.slice(0, headerEnd + 4));
+	if (Buffer.byteLength(buffer) < headerBytes + byteLength) return void 0;
+	const payload = Buffer.from(buffer).subarray(headerBytes, headerBytes + byteLength).toString("utf8");
+	try {
+		return {
+			byteLength: headerBytes + byteLength,
+			message: JSON.parse(payload)
+		};
+	} catch {
+		throw new BackgroundSessionMcpError("invalid MCP JSON payload");
+	}
+}
+function parseContext(value) {
+	const parsed = JSON.parse(value);
+	if (!isRecord(parsed)) throw new BackgroundSessionMcpError("RIVUS_MCP_CONTEXT must be a JSON object");
+	return parsed;
+}
+function requireEnv(name) {
+	const value = process.env[name]?.trim();
+	if (!value) throw new BackgroundSessionMcpError(`${name} is required`);
+	return value;
+}
+function optionalEnv(name) {
+	return process.env[name]?.trim() || void 0;
+}
+function isRecord(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+//#endregion
+//#region src/application/background-session/background-session-control.ts
+function createBackgroundSessionControl(options) {
+	return { handle: async (command, context, input) => {
+		const executionContext = {
+			agentId: context.agentId,
+			callId: `mcp-call:${randomUUID()}`,
+			instanceId: `mcp:${context.agentId}`,
+			policyEpoch: context.policyEpoch,
+			runId: context.runId,
+			sessionKey: context.sessionKey,
+			sourceMessageId: context.sourceMessageId,
+			toolId: `background.${command}`,
+			toolVersion: "1.0.0",
+			origin: toToolOrigin(context.origin)
+		};
+		switch (command) {
+			case "start": {
+				const { displayName, prompt } = readObject(input, ["displayName", "prompt"]);
+				if (typeof prompt !== "string" || prompt.trim() === "") throw new BackgroundSessionControlError("background.start requires a non-empty prompt");
+				const sessionId = `bg-${randomUUID()}`;
+				return options.service.start({
+					authority: {
+						...context.authority,
+						sessionKey: createBackgroundSessionKey(sessionId)
+					},
+					context: executionContext,
+					...displayName === void 0 ? {} : { displayName: readString(displayName, "displayName") },
+					prompt,
+					sessionId
+				});
+			}
+			case "wait": return options.service.wait({
+				context: executionContext,
+				...readBackgroundSessionWaitInput(input, (message) => new BackgroundSessionControlError(message))
+			});
+			case "list": {
+				const { limit, phase } = readObject(input, ["limit", "phase"]);
+				return options.service.list({
+					context: executionContext,
+					...limit === void 0 ? {} : { limit: readInteger(limit, "limit") },
+					...phase === void 0 ? {} : { phase: readPhase(phase) }
+				});
+			}
+			case "status": {
+				const { sessionId } = readObject(input, ["sessionId"]);
+				return options.service.status({
+					context: executionContext,
+					sessionId: readString(sessionId, "sessionId")
+				});
+			}
+			case "send": {
+				const { message, sessionId } = readObject(input, ["message", "sessionId"]);
+				return options.service.send({
+					context: executionContext,
+					message: readString(message, "message"),
+					sessionId: readString(sessionId, "sessionId")
+				});
+			}
+			case "stop": {
+				const { reason, sessionId } = readObject(input, ["reason", "sessionId"]);
+				return options.service.stop({
+					context: executionContext,
+					...reason === void 0 ? {} : { reason: readString(reason, "reason") },
+					sessionId: readString(sessionId, "sessionId")
+				});
+			}
+		}
+	} };
+}
+var BackgroundSessionControlError = class extends Error {
+	name = "BackgroundSessionControlError";
+};
+function toControlContext(input) {
+	return {
+		agentId: input.agentId,
+		authority: input.authority,
+		origin: {
+			allowedActorOpenIds: input.origin.allowedActorOpenIds,
+			...input.origin.conversationId === void 0 ? {} : { conversationId: input.origin.conversationId },
+			endpointId: input.origin.endpointId,
+			tenantKey: input.origin.tenantKey
+		},
+		policyEpoch: input.policyEpoch,
+		runId: `mcp:${randomUUID()}`,
+		sessionKey: input.sessionKey,
+		sourceMessageId: input.sourceMessageId ?? `mcp:${randomUUID()}`
+	};
+}
+function toToolOrigin(origin) {
+	return {
+		allowedActorOpenIds: origin.allowedActorOpenIds,
+		endpointId: origin.endpointId,
+		tenantKey: origin.tenantKey,
+		...origin.conversationId === void 0 ? {} : { conversationId: origin.conversationId }
+	};
+}
+function readObject(input, allowed) {
+	return readBackgroundSessionObject(input, allowed, (message) => new BackgroundSessionControlError(message));
+}
+function readString(value, name) {
+	return readBackgroundSessionString(value, name, (message) => new BackgroundSessionControlError(message));
+}
+function readInteger(value, name) {
+	return readBackgroundSessionInteger(value, name, (message) => new BackgroundSessionControlError(message));
+}
+function readPhase(value) {
+	return readBackgroundSessionPhase(value, (message) => new BackgroundSessionControlError(message));
+}
+//#endregion
+//#region src/infrastructure/http/background-session-control-http-server.ts
+var BackgroundSessionControlHttpError = class extends Error {
+	statusCode;
+	name = "BackgroundSessionControlHttpError";
+	constructor(statusCode, message) {
+		super(message);
+		this.statusCode = statusCode;
+	}
+};
+const COMMANDS = [
+	"start",
+	"wait",
+	"list",
+	"status",
+	"send",
+	"stop"
+];
+function createBackgroundSessionControlHttpServer(options) {
+	let server;
+	let boundPort = options.port;
+	const serverHandle = createServer((request, response) => {
+		(async () => {
+			try {
+				if (request.method !== "POST" || request.url !== "/background-sessions") throw new BackgroundSessionControlHttpError(404, "not found");
+				if (request.headers.authorization !== `Bearer ${options.token}`) throw new BackgroundSessionControlHttpError(401, "unauthorized");
+				const envelope = parseEnvelope(await readBody(request, 64 * 1024));
+				const command = envelope.command;
+				if (!COMMANDS.includes(command)) throw new BackgroundSessionControlHttpError(400, `unsupported background session command: ${String(command)}`);
+				respond(response, 200, {
+					ok: true,
+					result: await options.control.handle(command, envelope.context, envelope.input)
+				});
+			} catch (error) {
+				respond(response, error instanceof BackgroundSessionControlHttpError ? error.statusCode : 500, {
+					error: {
+						message: error instanceof Error ? error.message : String(error),
+						name: error instanceof Error ? error.name : "Error"
+					},
+					ok: false
+				});
+			}
+		})();
+	});
+	serverHandle.on("error", () => void 0);
+	return {
+		port: () => boundPort,
+		close: async () => {
+			const active = server;
+			server = void 0;
+			if (active) await new Promise((resolve) => active.close(() => resolve()));
+		},
+		start: async () => {
+			if (server) return;
+			await new Promise((resolve) => {
+				server = serverHandle;
+				serverHandle.listen(options.port, options.host ?? "127.0.0.1", () => {
+					const address = serverHandle.address();
+					if (address !== null && typeof address === "object") boundPort = address.port;
+					resolve();
+				});
+			});
+		}
+	};
+}
+function respond(response, statusCode, body) {
+	response.writeHead(statusCode, { "content-type": "application/json" });
+	response.end(JSON.stringify(body));
+}
+function parseEnvelope(body) {
+	const parsed = JSON.parse(body);
+	if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) throw new BackgroundSessionControlHttpError(400, "invalid background session control envelope");
+	const record = parsed;
+	if (typeof record.command !== "string" || record.context === void 0) throw new BackgroundSessionControlHttpError(400, "background session control envelope requires command and context");
+	return {
+		command: record.command,
+		context: record.context,
+		input: record.input
+	};
+}
+function readBody(request, maxBytes) {
+	return new Promise((resolve, reject) => {
+		const chunks = [];
+		let total = 0;
+		request.on("data", (chunk) => {
+			total += chunk.length;
+			if (total > maxBytes) {
+				reject(new BackgroundSessionControlHttpError(413, "background session control request too large"));
+				return;
+			}
+			chunks.push(chunk);
+		});
+		request.on("end", () => resolve(Buffer.concat(chunks).toString("utf8")));
+	});
+}
+//#endregion
+//#region src/mcp.ts
+if (pathToFileURL(process.argv[1] ?? "").href === import.meta.url) await runBackgroundSessionMcpServer();
+//#endregion
+export { BACKGROUND_SESSION_MCP_SERVER_NAME, BACKGROUND_SESSION_MCP_SERVER_VERSION, BackgroundSessionControlError, BackgroundSessionControlHttpError, BackgroundSessionMcpError, createBackgroundSessionControl, createBackgroundSessionControlHttpServer, createBackgroundSessionMcpServer, runBackgroundSessionMcpServer, toControlContext };

package/dist/rivus-daemon-cli.js

@@ -1,5 +1,6 @@
 import { t as MEMORY_SCOPES } from "./agent-memory.js";
-import { h as narrowBackgroundSessionDefinition, n as resolveRivusAgentDefinition, r as deepFreeze, t as createRivusPluginCatalog } from "./rivus-plugin-registry.js";
+import { f as narrowBackgroundSessionDefinition } from "./background-session-authority.js";
+import { n as resolveRivusAgentDefinition, r as deepFreeze, t as createRivusPluginCatalog } from "./rivus-plugin-registry.js";
 import { createRequire } from "node:module";
 import { Effect } from "effect";
 import { createHash, randomUUID } from "node:crypto";

package/dist/rivus-plugin-registry.js

@@ -1,227 +1,6 @@
 import { c as InvalidRivusPlugin, o as createRivusMemoryToolContract, r as RIVUS_MEMORY_TOOL_PLUGIN_ID, t as MEMORY_SCOPES } from "./agent-memory.js";
+import { u as extendBackgroundSessionDefinition } from "./background-session-authority.js";
 import { createHash } from "node:crypto";
-//#region src/application/background-session/background-session-authority.ts
-const BACKGROUND_SESSION_TOOL_IDS = [
-	"background.start",
-	"background.wait",
-	"background.list",
-	"background.status",
-	"background.send",
-	"background.stop"
-];
-const BACKGROUND_SESSION_START_TOOL_ID = "background.start";
-const BACKGROUND_SESSION_TOOL_PLUGIN_ID = "rivus-core";
-const BACKGROUND_SESSION_TOOL_VERSION = "1.0.0";
-const BACKGROUND_SESSION_SESSION_KEY_PREFIX = "background";
-function createBackgroundSessionKey(sessionId) {
-	return `${BACKGROUND_SESSION_SESSION_KEY_PREFIX}:${sessionId}`;
-}
-function createBackgroundSessionStepSourceMessageId(sessionId, stepCount) {
-	return `bg:${sessionId}:step:${stepCount}`;
-}
-function createBackgroundSessionToolContracts() {
-	return [
-		Object.freeze({
-			description: "Start a background agent session. Use when the request must wait for external changes, observe over time, or continue working after the foreground run ends. Returns a stable session id immediately; the foreground response can finish here. The detached session continues with the granted Skills, CLI, Tools, Project Space, and Memory of this agent.",
-			digest: contractDigest("background.start"),
-			id: "background.start",
-			idempotency: "supported",
-			inputSchema: Object.freeze({
-				additionalProperties: false,
-				properties: Object.freeze({
-					displayName: {
-						type: "string",
-						maxLength: 200
-					},
-					prompt: {
-						type: "string",
-						minLength: 1,
-						maxLength: 2e4
-					}
-				}),
-				required: ["prompt"],
-				type: "object"
-			}),
-			pluginId: BACKGROUND_SESSION_TOOL_PLUGIN_ID,
-			risk: "mutate",
-			version: BACKGROUND_SESSION_TOOL_VERSION
-		}),
-		Object.freeze({
-			description: "Pause the current background session durably and end the current step. Call with delayMs to resume after a delay, with until to resume at an absolute ISO time, or with neither to wait for user input. After this call no further tool calls are accepted in this step.",
-			digest: contractDigest("background.wait"),
-			id: "background.wait",
-			idempotency: "supported",
-			inputSchema: Object.freeze({
-				additionalProperties: false,
-				properties: Object.freeze({
-					delayMs: {
-						type: "integer",
-						minimum: 1e3,
-						maximum: 864e5
-					},
-					reason: {
-						type: "string",
-						maxLength: 500
-					},
-					until: {
-						type: "string",
-						maxLength: 64
-					}
-				}),
-				type: "object"
-			}),
-			pluginId: BACKGROUND_SESSION_TOOL_PLUGIN_ID,
-			risk: "mutate",
-			version: BACKGROUND_SESSION_TOOL_VERSION
-		}),
-		Object.freeze({
-			description: "List background sessions owned by this conversation, newest first. Optionally filter by phase and limit the number of results.",
-			digest: contractDigest("background.list"),
-			id: "background.list",
-			idempotency: "supported",
-			inputSchema: Object.freeze({
-				additionalProperties: false,
-				properties: Object.freeze({
-					limit: {
-						type: "integer",
-						minimum: 1,
-						maximum: 50
-					},
-					phase: {
-						enum: [
-							"queued",
-							"running",
-							"waiting",
-							"input-required",
-							"stopping",
-							"stopped",
-							"completed",
-							"failed",
-							"reconciliation-required"
-						],
-						type: "string"
-					}
-				}),
-				type: "object"
-			}),
-			pluginId: BACKGROUND_SESSION_TOOL_PLUGIN_ID,
-			risk: "observe",
-			version: BACKGROUND_SESSION_TOOL_VERSION
-		}),
-		Object.freeze({
-			description: "Return the current phase, step counts, wake time, and result of one background session owned by this conversation.",
-			digest: contractDigest("background.status"),
-			id: "background.status",
-			idempotency: "supported",
-			inputSchema: Object.freeze({
-				additionalProperties: false,
-				properties: Object.freeze({ sessionId: {
-					type: "string",
-					minLength: 1,
-					maxLength: 200
-				} }),
-				required: ["sessionId"],
-				type: "object"
-			}),
-			pluginId: BACKGROUND_SESSION_TOOL_PLUGIN_ID,
-			risk: "observe",
-			version: BACKGROUND_SESSION_TOOL_VERSION
-		}),
-		Object.freeze({
-			description: "Send new user instruction text to a background session owned by this conversation and wake it. The input is delivered exactly once in the next step.",
-			digest: contractDigest("background.send"),
-			id: "background.send",
-			idempotency: "supported",
-			inputSchema: Object.freeze({
-				additionalProperties: false,
-				properties: Object.freeze({
-					message: {
-						type: "string",
-						minLength: 1,
-						maxLength: 2e4
-					},
-					sessionId: {
-						type: "string",
-						minLength: 1,
-						maxLength: 200
-					}
-				}),
-				required: ["message", "sessionId"],
-				type: "object"
-			}),
-			pluginId: BACKGROUND_SESSION_TOOL_PLUGIN_ID,
-			risk: "mutate",
-			version: BACKGROUND_SESSION_TOOL_VERSION
-		}),
-		Object.freeze({
-			description: "Stop a background session owned by this conversation. Persists the cancellation, aborts the active step and its owned process, and delivers a terminal notice.",
-			digest: contractDigest("background.stop"),
-			id: "background.stop",
-			idempotency: "supported",
-			inputSchema: Object.freeze({
-				additionalProperties: false,
-				properties: Object.freeze({
-					reason: {
-						type: "string",
-						maxLength: 500
-					},
-					sessionId: {
-						type: "string",
-						minLength: 1,
-						maxLength: 200
-					}
-				}),
-				required: ["sessionId"],
-				type: "object"
-			}),
-			pluginId: BACKGROUND_SESSION_TOOL_PLUGIN_ID,
-			risk: "mutate",
-			version: BACKGROUND_SESSION_TOOL_VERSION
-		})
-	];
-}
-function backgroundSessionToolIds() {
-	return [...BACKGROUND_SESSION_TOOL_IDS];
-}
-function isBackgroundSessionToolId(toolId) {
-	return BACKGROUND_SESSION_TOOL_IDS.includes(toolId);
-}
-function extendBackgroundSessionDefinition(definition) {
-	const contracts = createBackgroundSessionToolContracts();
-	const existingIds = new Set(definition.tools.map(({ id }) => id));
-	const additions = contracts.filter((contract) => !existingIds.has(contract.id));
-	const toolGrantSet = Object.freeze({
-		revision: grantRevision(definition.toolGrantSet.revision, additions.map(({ id }) => id)),
-		toolIds: Object.freeze([...definition.toolGrantSet.toolIds, ...additions.map(({ id }) => id)].sort())
-	});
-	return Object.freeze({
-		...definition,
-		tools: Object.freeze([...definition.tools, ...additions]),
-		toolGrantSet
-	});
-}
-function narrowBackgroundSessionDefinition(definition) {
-	const childToolIds = definition.toolGrantSet.toolIds.filter((id) => id !== BACKGROUND_SESSION_START_TOOL_ID);
-	const toolGrantSet = Object.freeze({
-		revision: grantRevision(definition.toolGrantSet.revision, childToolIds),
-		toolIds: Object.freeze(childToolIds)
-	});
-	return Object.freeze({
-		...definition,
-		tools: Object.freeze(definition.tools.filter(({ id }) => id !== BACKGROUND_SESSION_START_TOOL_ID)),
-		toolGrantSet
-	});
-}
-function grantRevision(parentRevision, toolIds) {
-	return `sha256:${createHash("sha256").update(JSON.stringify({
-		parentRevision,
-		toolIds: [...toolIds].sort()
-	})).digest("hex")}`;
-}
-function contractDigest(toolId) {
-	return `sha256:${createHash("sha256").update(`background-tool:${toolId}:${BACKGROUND_SESSION_TOOL_VERSION}`).digest("hex")}`;
-}
-//#endregion
 //#region src/application/plugin/deep-freeze.ts
 function deepFreeze(value) {
 	if (value !== null && typeof value === "object" && !Object.isFrozen(value)) {
@@ -433,4 +212,4 @@ function stableJson(value) {
 	return JSON.stringify(value);
 }
 //#endregion
-export { BACKGROUND_SESSION_START_TOOL_ID as a, BACKGROUND_SESSION_TOOL_VERSION as c, createBackgroundSessionStepSourceMessageId as d, createBackgroundSessionToolContracts as f, narrowBackgroundSessionDefinition as h, BACKGROUND_SESSION_SESSION_KEY_PREFIX as i, backgroundSessionToolIds as l, isBackgroundSessionToolId as m, resolveRivusAgentDefinition as n, BACKGROUND_SESSION_TOOL_IDS as o, extendBackgroundSessionDefinition as p, deepFreeze as r, BACKGROUND_SESSION_TOOL_PLUGIN_ID as s, createRivusPluginCatalog as t, createBackgroundSessionKey as u };
+export { resolveRivusAgentDefinition as n, deepFreeze as r, createRivusPluginCatalog as t };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rivus/agent",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "description": "A local agent daemon core built around a usable agent harness and domain events.",
   "type": "module",
   "license": "MIT",
@@ -41,6 +41,10 @@
     "./testing": {
       "types": "./dist/testing/index.d.ts",
       "import": "./dist/testing/index.js"
+    },
+    "./mcp": {
+      "types": "./dist/mcp.d.ts",
+      "import": "./dist/mcp.js"
     }
   },
   "files": [