@rivus/agent 0.6.2 → 0.8.0

package/dist/mcp.d.ts

@@ -0,0 +1,86 @@
+import { k as BackgroundSessionAuthority, r as BackgroundSessionService } from "./background-session-service.js";
+import { Readable, Writable } from "node:stream";
+
+//#region src/application/background-session/background-session-control.d.ts
+type BackgroundSessionControlCommand = "start" | "wait" | "list" | "status" | "send" | "stop";
+interface BackgroundSessionControlOrigin {
+  readonly allowedActorOpenIds: ReadonlyArray<string>;
+  readonly conversationId?: string;
+  readonly endpointId: string;
+  readonly tenantKey: string;
+}
+interface BackgroundSessionControlContext {
+  readonly agentId: string;
+  readonly authority: BackgroundSessionAuthority;
+  readonly origin: BackgroundSessionControlOrigin;
+  readonly policyEpoch: number;
+  readonly runId: string;
+  readonly sessionKey: string;
+  readonly sourceMessageId: string;
+}
+interface BackgroundSessionControl {
+  handle(command: BackgroundSessionControlCommand, context: BackgroundSessionControlContext, input: unknown): Promise<unknown>;
+}
+declare function createBackgroundSessionControl(options: {
+  readonly service: BackgroundSessionService;
+}): BackgroundSessionControl;
+declare class BackgroundSessionControlError extends Error {
+  readonly name = "BackgroundSessionControlError";
+}
+declare function toControlContext(input: {
+  readonly agentId: string;
+  readonly authority: BackgroundSessionAuthority;
+  readonly origin: BackgroundSessionControlOrigin;
+  readonly policyEpoch: number;
+  readonly sessionKey: string;
+  readonly sourceMessageId?: string;
+}): BackgroundSessionControlContext;
+//#endregion
+//#region src/infrastructure/mcp/background-session-mcp-server.d.ts
+declare const BACKGROUND_SESSION_MCP_SERVER_NAME = "rivus-background-sessions";
+declare const BACKGROUND_SESSION_MCP_SERVER_VERSION = "1.0.0";
+interface BackgroundSessionMcpServerOptions {
+  readonly controlContext: BackgroundSessionControlContext;
+  readonly controlUrl: string;
+  readonly controlToken: string;
+  readonly enabledTools?: ReadonlyArray<BackgroundSessionControlCommand>;
+  readonly fetch?: typeof fetch;
+  readonly input?: Readable;
+  readonly output?: Writable;
+  readonly serverName?: string;
+  readonly serverVersion?: string;
+}
+interface BackgroundSessionMcpServer {
+  run(): Promise<void>;
+}
+declare class BackgroundSessionMcpError extends Error {
+  readonly name = "BackgroundSessionMcpError";
+}
+declare function createBackgroundSessionMcpServer(options: BackgroundSessionMcpServerOptions): BackgroundSessionMcpServer;
+interface RunBackgroundSessionMcpServerEnv {
+  readonly fetch?: typeof fetch;
+  readonly input?: Readable;
+  readonly output?: Writable;
+}
+declare function runBackgroundSessionMcpServer(options?: RunBackgroundSessionMcpServerEnv): Promise<void>;
+//#endregion
+//#region src/infrastructure/http/background-session-control-http-server.d.ts
+interface BackgroundSessionControlHttpServerOptions {
+  readonly control: BackgroundSessionControl;
+  readonly host?: string;
+  readonly port: number;
+  readonly token: string;
+}
+interface BackgroundSessionControlHttpServer {
+  port(): number;
+  close(): Promise<void>;
+  start(): Promise<void>;
+}
+declare class BackgroundSessionControlHttpError extends Error {
+  readonly statusCode: number;
+  readonly name = "BackgroundSessionControlHttpError";
+  constructor(statusCode: number, message: string);
+}
+declare function createBackgroundSessionControlHttpServer(options: BackgroundSessionControlHttpServerOptions): BackgroundSessionControlHttpServer;
+//#endregion
+export { BACKGROUND_SESSION_MCP_SERVER_NAME, BACKGROUND_SESSION_MCP_SERVER_VERSION, type BackgroundSessionControl, type BackgroundSessionControlCommand, type BackgroundSessionControlContext, BackgroundSessionControlError, BackgroundSessionControlHttpError, type BackgroundSessionControlHttpServer, type BackgroundSessionControlHttpServerOptions, type BackgroundSessionControlOrigin, BackgroundSessionMcpError, type BackgroundSessionMcpServer, type BackgroundSessionMcpServerOptions, createBackgroundSessionControl, createBackgroundSessionControlHttpServer, createBackgroundSessionMcpServer, runBackgroundSessionMcpServer, toControlContext };

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/pi-tool-proxy.d.ts

@@ -94,6 +94,9 @@ interface InvocationAuthorityRef {
 }
 interface InvocationAuthority {
   readonly agentId: string;
+  readonly allowedActorOpenIds?: ReadonlyArray<string>;
+  readonly conversationId?: string;
+  readonly endpointId?: string;
   readonly instanceId: string;
   readonly memory?: AgentMemoryAuthority;
   readonly runId: string;

package/dist/pi.js

@@ -88,6 +88,9 @@ function createPiToolProxyDefinitions(options) {
 				const result = await options.broker.execute({
 					authority: createInvocationAuthority({
 						agentId: options.agentId,
+						allowedActorOpenIds: invocation.allowedActorOpenIds,
+						...invocation.memory?.conversationId ? { conversationId: invocation.memory.conversationId } : {},
+						endpointId: invocation.endpointId,
 						instanceId: options.instanceId,
 						...invocation.memory ? { memory: {
 							...invocation.memory,