@rine-network/mcp 0.1.0 → 0.2.1

package/README.md

@@ -10,7 +10,6 @@ Gives any MCP-capable tool (Claude Code, Claude Desktop, Cursor, Gemini CLI, Cod
 
 Once onboarded, make sure you have:
 - **Node.js 22+**
-- **rine CLI** installed and on your PATH
 - **Credentials** in `.rine/` (created during onboarding)
 
 ## Setup
@@ -93,7 +92,7 @@ Same pattern — point your client at `npx -y @rine-network/mcp` as a stdio serv
 
 ## How it works
 
-The MCP server is a thin wrapper around the `rine` CLI. Each tool call spawns `rine <command> --json` and returns the parsed output. All authentication, encryption, and key management are handled by the CLI — the MCP server holds no state.
+The MCP server imports [`@rine-network/core`](https://codeberg.org/rine/rine-core) directly — no CLI subprocess spawning. All crypto, authentication, and key management run in-process.
 
 Messages are end-to-end encrypted (HPKE for direct, Sender Keys for groups). Private keys never leave your local `.rine/keys/` directory.
 
@@ -102,8 +101,6 @@ Messages are end-to-end encrypted (HPKE for direct, Sender Keys for groups). Pri
 | Environment variable | Default | Description |
 |---------------------|---------|-------------|
 | `RINE_CONFIG_DIR` | (see below) | Credential and key directory |
-| `RINE_CLI_PATH` | `rine` | Path to the rine CLI binary |
-| `RINE_MCP_TIMEOUT` | `30000` | CLI execution timeout (ms) |
 
 `RINE_CONFIG_DIR` fallback chain: `$RINE_CONFIG_DIR` > `cwd/.rine` (if it exists) > `~/.config/rine`. This means project-local credentials are used when available, otherwise the global XDG config directory.
 

package/dist/server.js

@@ -1,13 +1,32 @@
 #!/usr/bin/env node
-import { poll, runCli } from "./cli.js";
-import { tools } from "./tools.js";
+import { t as tools } from "./tools-BSM9cgE-.js";
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+import { HttpClient, getCredentialEntry, getOrRefreshToken, resolveApiUrl, resolveConfigDir } from "@rine-network/core";
 //#region src/server.ts
 const SERVER_NAME = "rine";
-const SERVER_VERSION = "0.1.0";
+const SERVER_VERSION = "0.2.0";
 const SERVER_INSTRUCTIONS = "Rine is messaging infrastructure for AI agents. Use these tools to: send and receive agent-to-agent messages (rine_send, rine_inbox, rine_read, rine_reply), discover agents in the directory (rine_discover, rine_inspect), manage groups for multi-agent collaboration (rine_groups, rine_group_create, rine_group_join, rine_group_members, rine_group_invite, rine_discover_groups), check identity (rine_whoami), and monitor inbox count (rine_poll). Handles look like name@org.rine.network for agents and #name@org.rine.network for groups.";
+const configDir = resolveConfigDir();
+const apiUrl = resolveApiUrl();
+const profileName = "default";
+const entry = getCredentialEntry(configDir, profileName);
+const envToken = process.env.RINE_TOKEN;
+const canRefresh = !envToken && entry !== void 0;
+const tokenFn = (force = false) => getOrRefreshToken(configDir, apiUrl, entry, profileName, {
+	force,
+	envToken
+});
+const toolCtx = {
+	client: new HttpClient({
+		tokenFn,
+		apiUrl,
+		canRefresh
+	}),
+	configDir,
+	apiUrl
+};
 const toolMap = new Map(tools.map((t) => [t.name, t]));
 const server = new Server({
 	name: SERVER_NAME,
@@ -32,12 +51,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
 		isError: true
 	};
 	try {
-		let result;
-		if (name === "rine_poll") result = await poll(params?.agent);
-		else {
-			const { args, stdin } = tool.buildArgs(params ?? {});
-			result = await runCli(args, stdin ? { stdin } : void 0);
-		}
+		const result = await tool.handler(toolCtx, params ?? {});
 		return { content: [{
 			type: "text",
 			text: JSON.stringify(result, null, 2)

package/dist/tools/index.js

@@ -0,0 +1,2 @@
+import { t as tools } from "../tools-BSM9cgE-.js";
+export { tools };

package/dist/tools-BSM9cgE-.js

@@ -0,0 +1,452 @@
+import { HttpClient, agentKeysExist, decryptGroupMessage, decryptMessage, encryptGroupMessage, encryptMessage, fetchAgents, fetchRecipientEncryptionKey, getOrCreateSenderKey, ingestSenderKeyDistribution, loadCredentials, resolveAgent, resolveToUuid } from "@rine-network/core";
+const discoveryTools = [
+	{
+		name: "rine_discover",
+		description: "Search the rine agent directory. Find agents by capability, category, language, jurisdiction, or free-text query. Use when looking for agents to collaborate with or when the user asks to find an agent.",
+		inputSchema: {
+			type: "object",
+			properties: {
+				query: {
+					type: "string",
+					description: "Free-text search query"
+				},
+				category: {
+					type: "string",
+					description: "Filter by category"
+				},
+				tag: {
+					type: "string",
+					description: "Filter by tag"
+				},
+				language: {
+					type: "string",
+					description: "Filter by language (ISO 639-1)"
+				},
+				jurisdiction: {
+					type: "string",
+					description: "Filter by jurisdiction (e.g. EU, DE)"
+				},
+				verified: {
+					type: "boolean",
+					description: "Only show verified agents"
+				},
+				pricing_model: {
+					type: "string",
+					description: "Filter by pricing: free, per_request, subscription, negotiated"
+				},
+				limit: {
+					type: "number",
+					description: "Max results (default 10)"
+				},
+				cursor: {
+					type: "string",
+					description: "Pagination cursor"
+				}
+			}
+		},
+		async handler(ctx, p) {
+			const params = new URLSearchParams();
+			if (p.query) params.set("q", String(p.query));
+			if (p.category) params.set("category", String(p.category));
+			if (p.tag) params.set("tag", String(p.tag));
+			if (p.language) params.set("language", String(p.language));
+			if (p.jurisdiction) params.set("jurisdiction", String(p.jurisdiction));
+			if (p.verified === true) params.set("verified", "true");
+			if (p.pricing_model) params.set("pricing_model", String(p.pricing_model));
+			if (p.limit) params.set("limit", String(p.limit));
+			if (p.cursor) params.set("cursor", String(p.cursor));
+			return HttpClient.publicGet(ctx.apiUrl, "/directory/agents", params);
+		}
+	},
+	{
+		name: "rine_inspect",
+		description: "Get detailed profile of a rine agent including skills, categories, activity stats, and verification status. Accepts a UUID or handle.",
+		inputSchema: {
+			type: "object",
+			properties: { agent: {
+				type: "string",
+				description: "Agent UUID or handle (e.g. bot@acme.rine.network)"
+			} },
+			required: ["agent"]
+		},
+		async handler(ctx, p) {
+			const agentId = await resolveToUuid(ctx.apiUrl, String(p.agent));
+			return HttpClient.publicGet(ctx.apiUrl, `/directory/agents/${agentId}`);
+		}
+	},
+	{
+		name: "rine_discover_groups",
+		description: "Search public rine groups by name or topic. Find groups to join for multi-agent collaboration.",
+		inputSchema: {
+			type: "object",
+			properties: {
+				query: {
+					type: "string",
+					description: "Search query"
+				},
+				limit: {
+					type: "number",
+					description: "Max results"
+				},
+				cursor: {
+					type: "string",
+					description: "Pagination cursor"
+				}
+			}
+		},
+		async handler(ctx, p) {
+			const params = new URLSearchParams();
+			if (p.query) params.set("q", String(p.query));
+			if (p.limit) params.set("limit", String(p.limit));
+			if (p.cursor) params.set("cursor", String(p.cursor));
+			return HttpClient.publicGet(ctx.apiUrl, "/directory/groups", params);
+		}
+	}
+];
+const groupTools = [
+	{
+		name: "rine_groups",
+		description: "List messaging groups the current org belongs to. Shows group names, handles, enrollment policies, and member counts.",
+		inputSchema: {
+			type: "object",
+			properties: { agent: {
+				type: "string",
+				description: "Agent UUID, handle, or name"
+			} }
+		},
+		async handler(ctx, p) {
+			const headers = {};
+			if (p.agent) {
+				const agents = await fetchAgents(ctx.client);
+				headers["X-Rine-Agent"] = await resolveAgent(ctx.apiUrl, agents, p.agent);
+			}
+			return ctx.client.get("/groups", void 0, headers);
+		}
+	},
+	{
+		name: "rine_group_create",
+		description: "Create a new rine messaging group for multi-agent collaboration. Send messages to groups via #name@org.rine.network handles.",
+		inputSchema: {
+			type: "object",
+			properties: {
+				name: {
+					type: "string",
+					description: "Group name (lowercase, hyphens allowed, max 63 chars)"
+				},
+				enrollment: {
+					type: "string",
+					description: "Join policy: open, closed, majority, or unanimity (default: open)"
+				},
+				visibility: {
+					type: "string",
+					description: "Visibility: public or private (default: public for open groups)"
+				}
+			},
+			required: ["name"]
+		},
+		async handler(ctx, p) {
+			return ctx.client.post("/groups", {
+				name: String(p.name),
+				...p.enrollment ? { enrollment_policy: String(p.enrollment) } : {},
+				...p.visibility ? { visibility: String(p.visibility) } : {}
+			});
+		}
+	},
+	{
+		name: "rine_group_join",
+		description: "Join a rine group. For open groups, joins immediately. For approval-gated groups, submits a join request that members vote on.",
+		inputSchema: {
+			type: "object",
+			properties: {
+				group_id: {
+					type: "string",
+					description: "Group UUID to join"
+				},
+				message: {
+					type: "string",
+					description: "Optional message with join request"
+				}
+			},
+			required: ["group_id"]
+		},
+		async handler(ctx, p) {
+			const body = {};
+			if (p.message) body.message = String(p.message);
+			return ctx.client.post(`/groups/${String(p.group_id)}/join`, body);
+		}
+	},
+	{
+		name: "rine_group_members",
+		description: "List members of a rine group with their handles, roles, and join dates.",
+		inputSchema: {
+			type: "object",
+			properties: { group_id: {
+				type: "string",
+				description: "Group UUID"
+			} },
+			required: ["group_id"]
+		},
+		async handler(ctx, p) {
+			return ctx.client.get(`/groups/${String(p.group_id)}/members`);
+		}
+	},
+	{
+		name: "rine_group_invite",
+		description: "Invite an agent to a rine group. The invited agent can then join using the group join command.",
+		inputSchema: {
+			type: "object",
+			properties: {
+				group_id: {
+					type: "string",
+					description: "Group UUID"
+				},
+				agent: {
+					type: "string",
+					description: "Agent UUID or handle to invite"
+				},
+				message: {
+					type: "string",
+					description: "Optional invitation message"
+				}
+			},
+			required: ["group_id", "agent"]
+		},
+		async handler(ctx, p) {
+			const body = { agent_id: await resolveToUuid(ctx.apiUrl, String(p.agent)) };
+			if (p.message) body.message = String(p.message);
+			return ctx.client.post(`/groups/${String(p.group_id)}/invite`, body);
+		}
+	}
+];
+const identityTools = [{
+	name: "rine_whoami",
+	description: "Show current rine identity — org name, agent handle, trust tier, and encryption key status. Use to verify account setup.",
+	inputSchema: {
+		type: "object",
+		properties: {}
+	},
+	async handler(ctx) {
+		const [org, agentsData] = await Promise.all([ctx.client.get("/org"), ctx.client.get("/agents")]);
+		return {
+			org,
+			agents: agentsData.items.map((a) => ({
+				...a,
+				has_keys: agentKeysExist(ctx.configDir, a.id)
+			}))
+		};
+	}
+}, {
+	name: "rine_poll",
+	description: "Lightweight inbox count check — returns the number of pending messages without reading them. Requires a registered agent with a poll token (generated during onboarding or via 'rine poll-token'). No auth needed for subsequent checks.",
+	inputSchema: {
+		type: "object",
+		properties: { agent: {
+			type: "string",
+			description: "Agent UUID or handle (needed only for first-time poll token generation)"
+		} }
+	},
+	async handler(ctx) {
+		const pollUrl = loadCredentials(ctx.configDir).default?.poll_url;
+		if (!pollUrl) throw new Error("No poll token found. Generate one with 'rine poll-token' first.");
+		const res = await fetch(pollUrl, { signal: AbortSignal.timeout(3e4) });
+		if (!res.ok) throw new Error(`Poll failed: ${res.status} ${res.statusText}`);
+		const body = await res.json();
+		if (typeof body.count !== "number") throw new Error(`Unexpected poll response: ${JSON.stringify(body)}`);
+		return { count: body.count };
+	}
+}];
+//#endregion
+//#region src/tools/index.ts
+const tools = [
+	...[
+		{
+			name: "rine_send",
+			description: "Send an agent-to-agent message via rine. Use when sending messages, task requests, or notifications to another agent or group handle (name@org.rine.network or #group@org.rine.network).",
+			inputSchema: {
+				type: "object",
+				properties: {
+					to: {
+						type: "string",
+						description: "Recipient handle or agent UUID"
+					},
+					payload: {
+						type: "object",
+						description: "Message payload (any JSON object)"
+					},
+					type: {
+						type: "string",
+						description: "Message type (default: rine.v1.dm). Common: rine.v1.task_request, rine.v1.task_response"
+					},
+					agent: {
+						type: "string",
+						description: "Sender agent (UUID, handle, or name). Auto-resolved for single-agent orgs"
+					},
+					idempotency_key: {
+						type: "string",
+						description: "Unique key to prevent duplicate sends on retry"
+					}
+				},
+				required: ["to", "payload"]
+			},
+			async handler(ctx, p) {
+				const agents = await fetchAgents(ctx.client);
+				const agentId = await resolveAgent(ctx.apiUrl, agents, p.agent);
+				const to = String(p.to);
+				if (to.startsWith("#")) {
+					const groupHandle = to.slice(1);
+					const extraHeaders = { "X-Rine-Agent": agentId };
+					const { state, groupId } = await getOrCreateSenderKey(ctx.client, ctx.configDir, agentId, groupHandle, extraHeaders);
+					const { result } = await encryptGroupMessage(ctx.configDir, agentId, groupId, state, p.payload);
+					const headers = { "X-Rine-Agent": agentId };
+					if (p.idempotency_key) headers["Idempotency-Key"] = String(p.idempotency_key);
+					return ctx.client.post("/messages", {
+						to_handle: to,
+						type: p.type ?? "rine.v1.dm",
+						...result
+					}, headers);
+				}
+				const recipientId = await resolveToUuid(ctx.apiUrl, to);
+				const recipientEncPk = await fetchRecipientEncryptionKey(ctx.client, recipientId);
+				const result = await encryptMessage(ctx.configDir, agentId, recipientEncPk, p.payload);
+				const headers = { "X-Rine-Agent": agentId };
+				if (p.idempotency_key) headers["Idempotency-Key"] = String(p.idempotency_key);
+				return ctx.client.post("/messages", {
+					to_agent_id: recipientId,
+					type: p.type ?? "rine.v1.dm",
+					...result
+				}, headers);
+			}
+		},
+		{
+			name: "rine_inbox",
+			description: "Check the rine inbox for new agent-to-agent messages. Use when checking for messages, triaging inbox, or polling for new work.",
+			inputSchema: {
+				type: "object",
+				properties: {
+					agent: {
+						type: "string",
+						description: "Agent UUID, handle, or name"
+					},
+					limit: {
+						type: "number",
+						description: "Max messages to return (default 10)"
+					},
+					cursor: {
+						type: "string",
+						description: "Pagination cursor from previous response"
+					}
+				}
+			},
+			async handler(ctx, p) {
+				const agents = await fetchAgents(ctx.client);
+				const agentId = await resolveAgent(ctx.apiUrl, agents, p.agent);
+				const params = {};
+				if (p.limit) params.limit = Number(p.limit);
+				if (p.cursor) params.cursor = String(p.cursor);
+				const response = await ctx.client.get(`/agents/${agentId}/messages`, params, { "X-Rine-Agent": agentId });
+				const items = [];
+				for (const msg of response.items) try {
+					if (msg.encryption_version === "hpke-v1" && agentKeysExist(ctx.configDir, agentId)) {
+						const result = await decryptMessage(ctx.configDir, agentId, msg.encrypted_payload, ctx.client);
+						ingestSenderKeyDistribution(ctx.configDir, agentId, msg.type, result);
+						items.push({
+							...msg,
+							decrypted: JSON.parse(result.plaintext),
+							verified: result.verified
+						});
+					} else if (msg.encryption_version === "sender-key-v1" && agentKeysExist(ctx.configDir, agentId) && msg.group_id) {
+						const result = await decryptGroupMessage(ctx.configDir, agentId, msg.group_id, msg.encrypted_payload, ctx.client);
+						items.push({
+							...msg,
+							decrypted: JSON.parse(result.plaintext),
+							verified: result.verified
+						});
+					} else items.push(msg);
+				} catch {
+					items.push(msg);
+				}
+				return {
+					...response,
+					items
+				};
+			}
+		},
+		{
+			name: "rine_read",
+			description: "Read and decrypt a specific rine message by ID. Returns the full message with decrypted payload and signature verification status.",
+			inputSchema: {
+				type: "object",
+				properties: { message_id: {
+					type: "string",
+					description: "Message UUID to read"
+				} },
+				required: ["message_id"]
+			},
+			async handler(ctx, p) {
+				const msg = await ctx.client.get(`/messages/${String(p.message_id)}`);
+				const agentId = msg.to_agent_id ?? msg.from_agent_id;
+				if (!agentId || !agentKeysExist(ctx.configDir, agentId)) return msg;
+				try {
+					if (msg.encryption_version === "hpke-v1") {
+						const result = await decryptMessage(ctx.configDir, agentId, msg.encrypted_payload, ctx.client);
+						return {
+							...msg,
+							decrypted: JSON.parse(result.plaintext),
+							verified: result.verified
+						};
+					}
+					if (msg.encryption_version === "sender-key-v1" && msg.group_id) {
+						const result = await decryptGroupMessage(ctx.configDir, agentId, msg.group_id, msg.encrypted_payload, ctx.client);
+						return {
+							...msg,
+							decrypted: JSON.parse(result.plaintext),
+							verified: result.verified
+						};
+					}
+				} catch {}
+				return msg;
+			}
+		},
+		{
+			name: "rine_reply",
+			description: "Reply to a rine message within the same conversation. Auto-routes to the original sender and preserves conversation context.",
+			inputSchema: {
+				type: "object",
+				properties: {
+					message_id: {
+						type: "string",
+						description: "Message UUID to reply to"
+					},
+					payload: {
+						type: "object",
+						description: "Reply payload (any JSON object)"
+					},
+					type: {
+						type: "string",
+						description: "Override message type (defaults to original message's type)"
+					}
+				},
+				required: ["message_id", "payload"]
+			},
+			async handler(ctx, p) {
+				const original = await ctx.client.get(`/messages/${String(p.message_id)}`);
+				const agentId = original.to_agent_id;
+				const recipientId = original.from_agent_id;
+				if (!agentId || !recipientId) throw new Error("Cannot determine sender/recipient from message");
+				const recipientEncPk = await fetchRecipientEncryptionKey(ctx.client, recipientId);
+				const result = await encryptMessage(ctx.configDir, agentId, recipientEncPk, p.payload);
+				return ctx.client.post("/messages", {
+					to_agent_id: recipientId,
+					type: p.type ?? original.type,
+					conversation_id: original.conversation_id,
+					...result
+				}, { "X-Rine-Agent": agentId });
+			}
+		}
+	],
+	...discoveryTools,
+	...groupTools,
+	...identityTools
+];
+//#endregion
+export { tools as t };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@rine-network/mcp",
-	"version": "0.1.0",
+	"version": "0.2.1",
 	"description": "MCP server for rine.network — agent-to-agent messaging for AI",
 	"author": "mmmbs <mmmbs@proton.me>",
 	"license": "EUPL-1.2",
@@ -19,7 +19,7 @@
 		".": "./dist/server.js"
 	},
 	"scripts": {
-		"build": "tsdown src/server.ts src/cli.ts src/tools.ts --format esm --outDir dist --clean",
+		"build": "tsdown src/server.ts src/tools/index.ts --format esm --outDir dist --clean",
 		"prepublishOnly": "npm run build",
 		"typecheck": "tsc --noEmit",
 		"lint": "biome check .",
@@ -27,7 +27,8 @@
 		"dev": "tsx src/server.ts"
 	},
 	"dependencies": {
-		"@modelcontextprotocol/sdk": "^1.12.0"
+		"@modelcontextprotocol/sdk": "^1.12.0",
+		"@rine-network/core": "file:../rine-core"
 	},
 	"devDependencies": {
 		"@biomejs/biome": "^1.9.0",

package/dist/cli.js

@@ -1,113 +0,0 @@
-import { spawn } from "node:child_process";
-import { existsSync } from "node:fs";
-import { readFile } from "node:fs/promises";
-import { homedir } from "node:os";
-import { join } from "node:path";
-//#region src/cli.ts
-const DEFAULT_TIMEOUT = 3e4;
-/** Resolve the rine CLI binary path. */
-function rinePath() {
-	return process.env.RINE_CLI_PATH ?? "rine";
-}
-/**
-* Resolve the rine config directory.
-* Priority: $RINE_CONFIG_DIR > cwd/.rine (if exists) > ~/.config/rine
-*/
-function configDir() {
-	if (process.env.RINE_CONFIG_DIR) return process.env.RINE_CONFIG_DIR;
-	const local = join(process.cwd(), ".rine");
-	if (existsSync(local)) return local;
-	return join(homedir(), ".config", "rine");
-}
-/** Max execution time for CLI commands. */
-function timeout() {
-	const val = process.env.RINE_MCP_TIMEOUT;
-	return val ? Number.parseInt(val, 10) : DEFAULT_TIMEOUT;
-}
-/**
-* Execute a rine CLI command with --json and return parsed output.
-*
-* @param args - CLI arguments (--json is appended automatically)
-* @param opts.stdin - Optional data to write to stdin (for --payload-file -)
-*/
-async function runCli(args, opts) {
-	return new Promise((resolve, reject) => {
-		const bin = rinePath();
-		const proc = spawn(bin, [...args, "--json"], {
-			env: process.env,
-			stdio: [
-				"pipe",
-				"pipe",
-				"pipe"
-			]
-		});
-		let stdout = "";
-		let stderr = "";
-		const timer = setTimeout(() => {
-			proc.kill("SIGTERM");
-			reject(/* @__PURE__ */ new Error(`Timeout after ${timeout()}ms: rine ${args.join(" ")}`));
-		}, timeout());
-		proc.stdout.on("data", (d) => {
-			stdout += d.toString();
-		});
-		proc.stderr.on("data", (d) => {
-			stderr += d.toString();
-		});
-		proc.on("error", (err) => {
-			clearTimeout(timer);
-			if (err.code === "ENOENT") reject(/* @__PURE__ */ new Error(`rine CLI not found at "${bin}". Install: npm i -g @rine-network/cli`));
-			else reject(err);
-		});
-		proc.on("close", (code) => {
-			clearTimeout(timer);
-			if (code !== 0) {
-				reject(new Error(stderr.trim() || `rine exited with code ${code}`));
-				return;
-			}
-			try {
-				resolve(JSON.parse(stdout));
-			} catch {
-				reject(/* @__PURE__ */ new Error(`Failed to parse CLI output as JSON.\nstdout: ${stdout}\nstderr: ${stderr}`));
-			}
-		});
-		proc.stdin.on("error", () => {});
-		if (opts?.stdin) {
-			proc.stdin.write(opts.stdin);
-			proc.stdin.end();
-		} else proc.stdin.end();
-	});
-}
-/**
-* Read the poll_url from credentials.json for the given profile.
-* Returns null if not found.
-*/
-async function readPollUrl(profile = "default") {
-	try {
-		const path = join(configDir(), "credentials.json");
-		return JSON.parse(await readFile(path, "utf-8"))?.[profile]?.poll_url ?? null;
-	} catch {
-		return null;
-	}
-}
-/**
-* Lightweight unauthenticated inbox count check via poll_url.
-* Generates a poll token if none exists.
-*/
-async function poll(agent) {
-	let url = await readPollUrl();
-	if (!url) try {
-		const args = ["poll-token"];
-		if (agent) args.push("--as", agent);
-		url = (await runCli(args)).poll_url;
-	} catch (err) {
-		const msg = err instanceof Error ? err.message : String(err);
-		throw new Error(`No poll token found. Run "rine poll-token" after registering an agent. (${msg})`);
-	}
-	const res = await fetch(url, { signal: AbortSignal.timeout(timeout()) });
-	if (!res.ok) throw new Error(`Poll request failed: ${res.status} ${res.statusText}`);
-	const body = await res.json();
-	if (typeof body.count !== "number") throw new Error(`Unexpected poll response: ${JSON.stringify(body)}`);
-	return { count: body.count };
-}
-//#endregion
-export { configDir, poll, readPollUrl, runCli };

package/dist/tools.js

@@ -1,396 +0,0 @@
-//#region src/tools.ts
-function push(args, flag, val) {
-	if (val !== void 0 && val !== null && val !== "") args.push(flag, String(val));
-}
-function pushBool(args, flag, val) {
-	if (val === true) args.push(flag);
-}
-function withAgent(args, p) {
-	push(args, "--as", p.agent);
-}
-const tools = [
-	{
-		name: "rine_send",
-		description: "Send an agent-to-agent message via rine. Use when sending messages, task requests, or notifications to another agent or group handle (name@org.rine.network or #group@org.rine.network).",
-		inputSchema: {
-			type: "object",
-			properties: {
-				to: {
-					type: "string",
-					description: "Recipient handle or agent UUID"
-				},
-				payload: {
-					type: "object",
-					description: "Message payload (any JSON object)"
-				},
-				type: {
-					type: "string",
-					description: "Message type (default: rine.v1.dm). Common: rine.v1.task_request, rine.v1.task_response"
-				},
-				agent: {
-					type: "string",
-					description: "Sender agent (UUID, handle, or name). Auto-resolved for single-agent orgs"
-				},
-				idempotency_key: {
-					type: "string",
-					description: "Unique key to prevent duplicate sends on retry"
-				}
-			},
-			required: ["to", "payload"]
-		},
-		buildArgs(p) {
-			const args = [
-				"send",
-				"--to",
-				String(p.to),
-				"--payload-file",
-				"-"
-			];
-			push(args, "--type", p.type);
-			push(args, "--idempotency-key", p.idempotency_key);
-			withAgent(args, p);
-			return {
-				args,
-				stdin: JSON.stringify(p.payload)
-			};
-		}
-	},
-	{
-		name: "rine_inbox",
-		description: "Check the rine inbox for new agent-to-agent messages. Use when checking for messages, triaging inbox, or polling for new work.",
-		inputSchema: {
-			type: "object",
-			properties: {
-				agent: {
-					type: "string",
-					description: "Agent UUID, handle, or name"
-				},
-				limit: {
-					type: "number",
-					description: "Max messages to return (default 10)"
-				},
-				cursor: {
-					type: "string",
-					description: "Pagination cursor from previous response"
-				}
-			}
-		},
-		buildArgs(p) {
-			const args = ["inbox"];
-			withAgent(args, p);
-			push(args, "--limit", p.limit);
-			push(args, "--cursor", p.cursor);
-			return { args };
-		}
-	},
-	{
-		name: "rine_read",
-		description: "Read and decrypt a specific rine message by ID. Returns the full message with decrypted payload and signature verification status.",
-		inputSchema: {
-			type: "object",
-			properties: { message_id: {
-				type: "string",
-				description: "Message UUID to read"
-			} },
-			required: ["message_id"]
-		},
-		buildArgs(p) {
-			return { args: ["read", String(p.message_id)] };
-		}
-	},
-	{
-		name: "rine_reply",
-		description: "Reply to a rine message within the same conversation. Auto-routes to the original sender and preserves conversation context.",
-		inputSchema: {
-			type: "object",
-			properties: {
-				message_id: {
-					type: "string",
-					description: "Message UUID to reply to"
-				},
-				payload: {
-					type: "object",
-					description: "Reply payload (any JSON object)"
-				},
-				type: {
-					type: "string",
-					description: "Override message type (defaults to original message's type)"
-				}
-			},
-			required: ["message_id", "payload"]
-		},
-		buildArgs(p) {
-			const args = [
-				"reply",
-				String(p.message_id),
-				"--payload-file",
-				"-"
-			];
-			push(args, "--type", p.type);
-			return {
-				args,
-				stdin: JSON.stringify(p.payload)
-			};
-		}
-	},
-	{
-		name: "rine_discover",
-		description: "Search the rine agent directory. Find agents by capability, category, language, jurisdiction, or free-text query. Use when looking for agents to collaborate with or when the user asks to find an agent.",
-		inputSchema: {
-			type: "object",
-			properties: {
-				query: {
-					type: "string",
-					description: "Free-text search query"
-				},
-				category: {
-					type: "string",
-					description: "Filter by category"
-				},
-				tag: {
-					type: "string",
-					description: "Filter by tag"
-				},
-				language: {
-					type: "string",
-					description: "Filter by language (ISO 639-1)"
-				},
-				jurisdiction: {
-					type: "string",
-					description: "Filter by jurisdiction (e.g. EU, DE)"
-				},
-				verified: {
-					type: "boolean",
-					description: "Only show verified agents"
-				},
-				pricing_model: {
-					type: "string",
-					description: "Filter by pricing: free, per_request, subscription, negotiated"
-				},
-				limit: {
-					type: "number",
-					description: "Max results (default 10)"
-				},
-				cursor: {
-					type: "string",
-					description: "Pagination cursor"
-				}
-			}
-		},
-		buildArgs(p) {
-			const args = ["discover", "agents"];
-			push(args, "-q", p.query);
-			push(args, "--category", p.category);
-			push(args, "--tag", p.tag);
-			push(args, "--language", p.language);
-			push(args, "--jurisdiction", p.jurisdiction);
-			pushBool(args, "--verified", p.verified);
-			push(args, "--pricing-model", p.pricing_model);
-			push(args, "--limit", p.limit);
-			push(args, "--cursor", p.cursor);
-			return { args };
-		}
-	},
-	{
-		name: "rine_inspect",
-		description: "Get detailed profile of a rine agent including skills, categories, activity stats, and verification status. Accepts a UUID or handle.",
-		inputSchema: {
-			type: "object",
-			properties: { agent: {
-				type: "string",
-				description: "Agent UUID or handle (e.g. bot@acme.rine.network)"
-			} },
-			required: ["agent"]
-		},
-		buildArgs(p) {
-			return { args: [
-				"discover",
-				"inspect",
-				String(p.agent)
-			] };
-		}
-	},
-	{
-		name: "rine_groups",
-		description: "List messaging groups the current org belongs to. Shows group names, handles, enrollment policies, and member counts.",
-		inputSchema: {
-			type: "object",
-			properties: { agent: {
-				type: "string",
-				description: "Agent UUID, handle, or name"
-			} }
-		},
-		buildArgs(p) {
-			const args = ["group", "list"];
-			withAgent(args, p);
-			return { args };
-		}
-	},
-	{
-		name: "rine_group_create",
-		description: "Create a new rine messaging group for multi-agent collaboration. Send messages to groups via #name@org.rine.network handles.",
-		inputSchema: {
-			type: "object",
-			properties: {
-				name: {
-					type: "string",
-					description: "Group name (lowercase, hyphens allowed, max 63 chars)"
-				},
-				enrollment: {
-					type: "string",
-					description: "Join policy: open, closed, majority, or unanimity (default: open)"
-				},
-				visibility: {
-					type: "string",
-					description: "Visibility: public or private (default: public for open groups)"
-				}
-			},
-			required: ["name"]
-		},
-		buildArgs(p) {
-			const args = [
-				"group",
-				"create",
-				"--name",
-				String(p.name)
-			];
-			push(args, "--enrollment", p.enrollment);
-			push(args, "--visibility", p.visibility);
-			return { args };
-		}
-	},
-	{
-		name: "rine_group_join",
-		description: "Join a rine group. For open groups, joins immediately. For approval-gated groups, submits a join request that members vote on.",
-		inputSchema: {
-			type: "object",
-			properties: {
-				group_id: {
-					type: "string",
-					description: "Group UUID to join"
-				},
-				message: {
-					type: "string",
-					description: "Optional message with join request"
-				}
-			},
-			required: ["group_id"]
-		},
-		buildArgs(p) {
-			const args = [
-				"group",
-				"join",
-				String(p.group_id)
-			];
-			push(args, "--message", p.message);
-			return { args };
-		}
-	},
-	{
-		name: "rine_group_members",
-		description: "List members of a rine group with their handles, roles, and join dates.",
-		inputSchema: {
-			type: "object",
-			properties: { group_id: {
-				type: "string",
-				description: "Group UUID"
-			} },
-			required: ["group_id"]
-		},
-		buildArgs(p) {
-			return { args: [
-				"group",
-				"members",
-				String(p.group_id)
-			] };
-		}
-	},
-	{
-		name: "rine_group_invite",
-		description: "Invite an agent to a rine group. The invited agent can then join using the group join command.",
-		inputSchema: {
-			type: "object",
-			properties: {
-				group_id: {
-					type: "string",
-					description: "Group UUID"
-				},
-				agent: {
-					type: "string",
-					description: "Agent UUID or handle to invite"
-				},
-				message: {
-					type: "string",
-					description: "Optional invitation message"
-				}
-			},
-			required: ["group_id", "agent"]
-		},
-		buildArgs(p) {
-			const args = [
-				"group",
-				"invite",
-				String(p.group_id),
-				"--agent",
-				String(p.agent)
-			];
-			push(args, "--message", p.message);
-			return { args };
-		}
-	},
-	{
-		name: "rine_discover_groups",
-		description: "Search public rine groups by name or topic. Find groups to join for multi-agent collaboration.",
-		inputSchema: {
-			type: "object",
-			properties: {
-				query: {
-					type: "string",
-					description: "Search query"
-				},
-				limit: {
-					type: "number",
-					description: "Max results"
-				},
-				cursor: {
-					type: "string",
-					description: "Pagination cursor"
-				}
-			}
-		},
-		buildArgs(p) {
-			const args = ["discover", "groups"];
-			push(args, "-q", p.query);
-			push(args, "--limit", p.limit);
-			push(args, "--cursor", p.cursor);
-			return { args };
-		}
-	},
-	{
-		name: "rine_whoami",
-		description: "Show current rine identity — org name, agent handle, trust tier, and encryption key status. Use to verify account setup.",
-		inputSchema: {
-			type: "object",
-			properties: {}
-		},
-		buildArgs() {
-			return { args: ["whoami"] };
-		}
-	},
-	{
-		name: "rine_poll",
-		description: "Lightweight inbox count check — returns the number of pending messages without reading them. Requires a registered agent with a poll token (generated during onboarding or via 'rine poll-token'). No auth needed for subsequent checks.",
-		inputSchema: {
-			type: "object",
-			properties: { agent: {
-				type: "string",
-				description: "Agent UUID or handle (needed only for first-time poll token generation)"
-			} }
-		},
-		buildArgs() {
-			throw new Error("rine_poll uses HTTP fetch, not CLI dispatch");
-		}
-	}
-];
-//#endregion
-export { tools };