@rivus/agent 0.8.6 → 0.9.0

package/dist/mcp.d.ts

@@ -40,7 +40,7 @@ declare function toControlContext(input: {
 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 capability: string;
   readonly controlUrl: string;
   readonly controlToken: string;
   readonly enabledTools?: ReadonlyArray<BackgroundSessionControlCommand>;
@@ -74,6 +74,7 @@ interface BackgroundSessionControlHttpServerOptions {
 }
 interface BackgroundSessionControlHttpServer {
   port(): number;
+  issueCapability(context: BackgroundSessionControlContext): string;
   close(): Promise<void>;
   start(): Promise<void>;
 }

package/dist/mcp.js

@@ -24,15 +24,14 @@ function createBackgroundSessionMcpServer(options) {
 	const tools = createBackgroundSessionToolContracts().filter(({ id }) => enabledTools.has(id.slice(11))).map((contract) => ({
 		description: contract.description,
 		inputSchema: contract.inputSchema,
-		name: contract.id,
-		outputSchema: { type: "object" }
+		name: contract.id
 	}));
 	const serverInfo = {
 		name: options.serverName ?? "rivus-background-sessions",
 		version: options.serverVersion ?? "1.0.0"
 	};
 	return { run: () => runMcpServer({
-		controlContext: options.controlContext,
+		capability: options.capability,
 		controlToken: options.controlToken,
 		controlUrl: options.controlUrl,
 		fetchImplementation,
@@ -45,10 +44,10 @@ function createBackgroundSessionMcpServer(options) {
 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 capability = requireEnv("RIVUS_MCP_CAPABILITY");
 	const enabledTools = optionalEnv("RIVUS_MCP_TOOLS")?.split(",").map((tool) => tool.trim()).filter(Boolean);
 	await createBackgroundSessionMcpServer({
-		controlContext: context,
+		capability,
 		controlToken,
 		controlUrl,
 		...enabledTools ? { enabledTools } : {},
@@ -60,16 +59,17 @@ async function runBackgroundSessionMcpServer(options = {}) {
 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}`);
+		options.output.write(`${body}\n`);
 	};
 	for await (const message of readMcpMessages(options.input)) {
-		if (!isRecord(message) || typeof message.id !== "number") continue;
+		if (!isRecord(message) || !isJsonRpcRequestId(message.id)) continue;
 		const method = typeof message.method === "string" ? message.method : void 0;
 		if (!method) continue;
 		try {
 			switch (method) {
 				case "initialize":
 					send({
+						jsonrpc: "2.0",
 						id: message.id,
 						result: {
 							capabilities: { tools: { listChanged: false } },
@@ -80,12 +80,14 @@ async function runMcpServer(options) {
 					break;
 				case "ping":
 					send({
+						jsonrpc: "2.0",
 						id: message.id,
 						result: {}
 					});
 					break;
 				case "tools/list":
 					send({
+						jsonrpc: "2.0",
 						id: message.id,
 						result: { tools: options.tools }
 					});
@@ -96,6 +98,7 @@ async function runMcpServer(options) {
 					const command = name.startsWith("background.") ? name.slice(11) : void 0;
 					if (!command || !options.tools.some((tool) => tool.name === name)) {
 						send({
+							jsonrpc: "2.0",
 							id: message.id,
 							error: {
 								code: -32602,
@@ -106,8 +109,8 @@ async function runMcpServer(options) {
 					}
 					const response = await options.fetchImplementation(options.controlUrl, {
 						body: JSON.stringify({
+							capability: options.capability,
 							command,
-							context: options.controlContext,
 							input: params.arguments ?? {}
 						}),
 						headers: {
@@ -120,6 +123,7 @@ async function runMcpServer(options) {
 					if (!response.ok || envelope.error) {
 						const messageText = envelope.error?.message ?? `background session control failed with ${response.status}`;
 						send({
+							jsonrpc: "2.0",
 							id: message.id,
 							error: {
 								code: -32e3,
@@ -129,6 +133,7 @@ async function runMcpServer(options) {
 						break;
 					}
 					send({
+						jsonrpc: "2.0",
 						id: message.id,
 						result: {
 							content: [{
@@ -141,6 +146,7 @@ async function runMcpServer(options) {
 					break;
 				}
 				default: send({
+					jsonrpc: "2.0",
 					id: message.id,
 					error: {
 						code: -32601,
@@ -150,6 +156,7 @@ async function runMcpServer(options) {
 			}
 		} catch (error) {
 			send({
+				jsonrpc: "2.0",
 				id: message.id,
 				error: {
 					code: -32e3,
@@ -163,36 +170,25 @@ 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);
+		let newlineIndex = buffer.indexOf("\n");
+		while (newlineIndex >= 0) {
+			const line = buffer.slice(0, newlineIndex).replace(/\r$/, "");
+			buffer = buffer.slice(newlineIndex + 1);
+			if (line.trim() !== "") yield parseMcpMessage(line);
+			newlineIndex = buffer.indexOf("\n");
 		}
 	}
+	if (buffer.trim() !== "") yield parseMcpMessage(buffer.trim());
 }
-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");
+function parseMcpMessage(payload) {
 	try {
-		return {
-			byteLength: headerBytes + byteLength,
-			message: JSON.parse(payload)
-		};
+		return 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 isJsonRpcRequestId(value) {
+	return value === null || typeof value === "string" || typeof value === "number";
 }
 function requireEnv(name) {
 	const value = process.env[name]?.trim();
@@ -335,6 +331,8 @@ const COMMANDS = [
 function createBackgroundSessionControlHttpServer(options) {
 	let server;
 	let boundPort = options.port;
+	const capabilities = /* @__PURE__ */ new Map();
+	const capabilitiesBySessionKey = /* @__PURE__ */ new Map();
 	const serverHandle = createServer((request, response) => {
 		(async () => {
 			try {
@@ -349,11 +347,13 @@ function createBackgroundSessionControlHttpServer(options) {
 				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 context = capabilities.get(envelope.capability);
+				if (!context) throw new BackgroundSessionControlHttpError(401, "unknown or expired capability");
 				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)
+					result: await options.control.handle(command, context, envelope.input)
 				});
 			} catch (error) {
 				respond(response, error instanceof BackgroundSessionControlHttpError ? error.statusCode : 500, {
@@ -372,8 +372,18 @@ function createBackgroundSessionControlHttpServer(options) {
 		close: async () => {
 			const active = server;
 			server = void 0;
+			capabilities.clear();
+			capabilitiesBySessionKey.clear();
 			if (active) await new Promise((resolve) => active.close(() => resolve()));
 		},
+		issueCapability: (context) => {
+			const existing = capabilitiesBySessionKey.get(context.sessionKey);
+			if (existing) return existing;
+			const capability = randomUUID();
+			capabilities.set(capability, context);
+			capabilitiesBySessionKey.set(context.sessionKey, capability);
+			return capability;
+		},
 		start: async () => {
 			if (server) return;
 			await new Promise((resolve, reject) => {
@@ -399,10 +409,10 @@ 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");
+	if (typeof record.command !== "string" || typeof record.capability !== "string") throw new BackgroundSessionControlHttpError(400, "background session control envelope requires command and capability");
 	return {
+		capability: record.capability,
 		command: record.command,
-		context: record.context,
 		input: record.input
 	};
 }

package/package.json

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