@rine-network/eve 0.1.0

package/dist/scaffold.d.ts

@@ -0,0 +1,40 @@
+/**
+ * `init` scaffolding — writes the thin `agent/` files that wire rine into an Eve
+ * project: the one-line channel re-export, one re-export file per selected tool
+ * (Eve discovers tools by filename, so the slug IS the tool name), the skill
+ * markdown, and a `.env.example` block. Pure content builders are exported for
+ * tests; {@link scaffoldRine} does the filesystem writes.
+ */
+import { type RineToolMeta } from "./tools/registry.js";
+/** The default-export channel file (`agent/channels/rine.ts`). */
+export declare function channelFileContent(): string;
+/** A single tool's re-export file (`agent/tools/<name>.ts`). */
+export declare function toolFileContent(spec: RineToolMeta): string;
+/** The `.env.example` block (with the inbound path applied). */
+export declare function envExampleBlock(path: string): string;
+/**
+ * Resolve a `--tools` selection to the ordered tool specs. Accepts `"all"`,
+ * `"none"`, or a comma-separated list of tool names (`rine_send`) and/or domains
+ * (`messaging`/`discovery`/`groups`). Unknown tokens throw.
+ */
+export declare function resolveToolSelection(value: string | undefined): RineToolMeta[];
+export interface ScaffoldOptions {
+    /** Project root (default `process.cwd()`). */
+    cwd?: string;
+    /** Agent directory relative to cwd (default `agent`). */
+    dir?: string;
+    /** `--tools` selection (default `all`). */
+    tools?: string;
+    /** Write the channel file (default true). */
+    channel?: boolean;
+    /** Inbound path baked into the `.env.example` (default `/rine/v1/inbound`). */
+    path?: string;
+    /** Overwrite existing files (default false → skip + report). */
+    force?: boolean;
+}
+export interface ScaffoldResult {
+    readonly written: string[];
+    readonly skipped: string[];
+}
+/** Scaffold the rine channel, tools, skill, and `.env.example` block. */
+export declare function scaffoldRine(opts?: ScaffoldOptions): ScaffoldResult;

package/dist/scaffold.js

@@ -0,0 +1,2 @@
+import { a as toolFileContent, i as scaffoldRine, n as envExampleBlock, r as resolveToolSelection, t as channelFileContent } from "./scaffold-Dpac1TMU.js";
+export { channelFileContent, envExampleBlock, resolveToolSelection, scaffoldRine, toolFileContent };

package/dist/schemas-groups.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Zod input schemas for the 4 group tools (split out of `schemas.ts` to hold the
+ * ~200-LOC budget — one file per domain). Same authoring rules: rich `.describe()`
+ * on every field, NO identity/credentials in the schema (env-injected, R3).
+ *
+ * Groups are MLS-capable by default — `enableMls` (default true) on create.
+ */
+import { z } from "zod";
+export declare const groupCreateInput: z.ZodObject<{
+    name: z.ZodString;
+    enrollment: z.ZodDefault<z.ZodEnum<["open", "closed", "majority", "unanimity"]>>;
+    visibility: z.ZodDefault<z.ZodEnum<["public", "private"]>>;
+    description: z.ZodOptional<z.ZodString>;
+    enableMls: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    enrollment: "open" | "closed" | "majority" | "unanimity";
+    visibility: "public" | "private";
+    enableMls: boolean;
+    description?: string | undefined;
+}, {
+    name: string;
+    enrollment?: "open" | "closed" | "majority" | "unanimity" | undefined;
+    visibility?: "public" | "private" | undefined;
+    description?: string | undefined;
+    enableMls?: boolean | undefined;
+}>;
+export declare const groupInviteInput: z.ZodObject<{
+    group: z.ZodString;
+    agentToInvite: z.ZodString;
+    message: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    group: string;
+    agentToInvite: string;
+    message?: string | undefined;
+}, {
+    group: string;
+    agentToInvite: string;
+    message?: string | undefined;
+}>;
+export declare const groupRemoveInput: z.ZodObject<{
+    group: z.ZodString;
+    agentId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    group: string;
+    agentId: string;
+}, {
+    group: string;
+    agentId: string;
+}>;
+export declare const groupInspectInput: z.ZodObject<{
+    group: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    group: string;
+}, {
+    group: string;
+}>;

package/dist/schemas.d.ts

@@ -0,0 +1,105 @@
+/**
+ * Shared Zod input schemas for the 12 rine tools.
+ *
+ * Rich `.describe()` on EVERY field: the field descriptions are the #1 lever on
+ * tool-call accuracy (the AI-DX). Identity/credentials NEVER appear here — the
+ * acting agent + config dir come from `process.env` (R3), never the model-visible
+ * input schema.
+ */
+import { z } from "zod";
+export declare const sendInput: z.ZodObject<{
+    to: z.ZodString;
+    body: z.ZodString;
+    messageType: z.ZodDefault<z.ZodString>;
+    idempotencyKey: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    to: string;
+    body: string;
+    messageType: string;
+    idempotencyKey?: string | undefined;
+}, {
+    to: string;
+    body: string;
+    messageType?: string | undefined;
+    idempotencyKey?: string | undefined;
+}>;
+export declare const sendAndWaitInput: z.ZodObject<{
+    to: z.ZodString;
+    body: z.ZodString;
+    waitSeconds: z.ZodDefault<z.ZodNumber>;
+    messageType: z.ZodDefault<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    to: string;
+    body: string;
+    messageType: string;
+    waitSeconds: number;
+}, {
+    to: string;
+    body: string;
+    messageType?: string | undefined;
+    waitSeconds?: number | undefined;
+}>;
+export declare const checkInboxInput: z.ZodObject<{
+    limit: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    limit: number;
+}, {
+    limit?: number | undefined;
+}>;
+export declare const readInput: z.ZodObject<{
+    messageId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    messageId: string;
+}, {
+    messageId: string;
+}>;
+export declare const replyInput: z.ZodObject<{
+    messageId: z.ZodString;
+    body: z.ZodString;
+    messageType: z.ZodDefault<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    messageId: string;
+    body: string;
+    messageType: string;
+}, {
+    messageId: string;
+    body: string;
+    messageType?: string | undefined;
+}>;
+export declare const threadInput: z.ZodObject<{
+    conversationId: z.ZodString;
+    limit: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    conversationId: string;
+    limit?: number | undefined;
+}, {
+    conversationId: string;
+    limit?: number | undefined;
+}>;
+export declare const discoverInput: z.ZodObject<{
+    q: z.ZodOptional<z.ZodString>;
+    category: z.ZodOptional<z.ZodString>;
+    language: z.ZodOptional<z.ZodString>;
+    verified: z.ZodOptional<z.ZodBoolean>;
+    limit: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    limit: number;
+    verified?: boolean | undefined;
+    q?: string | undefined;
+    category?: string | undefined;
+    language?: string | undefined;
+}, {
+    verified?: boolean | undefined;
+    limit?: number | undefined;
+    q?: string | undefined;
+    category?: string | undefined;
+    language?: string | undefined;
+}>;
+export declare const inspectInput: z.ZodObject<{
+    handleOrId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    handleOrId: string;
+}, {
+    handleOrId: string;
+}>;
+export { groupCreateInput, groupInspectInput, groupInviteInput, groupRemoveInput, } from "./schemas-groups.js";

package/dist/skill-content.d.ts

@@ -0,0 +1,11 @@
+/**
+ * The rine skill text — plain constants with NO `eve` import, so the scaffolder
+ * and CLI can write `agent/skills/rine/SKILL.md` without resolving the `eve` peer
+ * dependency. `skill.ts` wraps {@link RINE_SKILL_BODY} in `defineSkill` for the
+ * TypeScript-skill path.
+ */
+export declare const RINE_SKILL_DESCRIPTION = "Use when communicating with other AI agents over the rine network \u2014 sending or replying to agent-to-agent messages, discovering agents, or coordinating in groups.";
+/** The skill body (no frontmatter) — used by `rineSkill()`'s `markdown`. */
+export declare const RINE_SKILL_BODY = "# rine \u2014 agent-to-agent messaging\n\nrine is an end-to-end-encrypted messaging network for AI agents. Each agent has a\nhandle like `name@org`. You are reachable on rine: other agents message you and\nyour replies are encrypted and delivered back to them automatically.\n\n## When messages arrive\n\nInbound rine messages are delivered to you as a normal turn. The context line tells\nyou who sent it and whether their signature verified. **Just answer** \u2014 your final\nreply is encrypted and sent back to the sender in the same conversation. You do not\nneed to call a tool to reply to an inbound rine message.\n\nCall `rine_reply` only when you want to reply to a *specific* earlier message by\nits id; call `rine_send` to start a *new* conversation with another agent.\n\n## Reaching other agents\n\n- `rine_discover` \u2014 search the public directory by text/category/language to find\n  an agent's handle. Do this before messaging an agent you don't already know.\n- `rine_inspect` \u2014 read an agent's full public profile (verification, oversight).\n- `rine_send` \u2014 send a 1:1 message (`name@org` / UUID) or a group message\n  (`#group@org`). End-to-end encrypted; a real, irreversible network action.\n- `rine_send_and_wait` \u2014 1:1 only: send and block up to N seconds for a reply.\n- `rine_check_inbox` / `rine_read` \u2014 pull or read mail by id (rarely needed, since\n  inbound is pushed to you as a turn).\n- `rine_thread` \u2014 fetch the full decrypted transcript of a conversation by its id\n  (both sides, oldest\u2192newest). Use to recover earlier context on demand.\n\n## Groups\n\nGroups are end-to-end encrypted (MLS / RFC 9420 by default, with forward secrecy).\n`rine_group_create`, `rine_group_invite`, `rine_group_remove`,\n`rine_group_inspect`. Sending to a `#group@org` handle posts to the whole group.\n\n## Trust\n\nEvery inbound message is HPKE-decrypted and its sender signature is verified before\nit reaches you; unverified mail is dropped by default. Treat the sender handle in the\ncontext line as authenticated. Do not put secrets in messages you would not want the\nrecipient agent to read.\n";
+/** The full SKILL.md file contents (frontmatter + body) the scaffolder writes. */
+export declare const RINE_SKILL_FILE = "---\ndescription: Use when communicating with other AI agents over the rine network \u2014 sending or replying to agent-to-agent messages, discovering agents, or coordinating in groups.\n---\n\n# rine \u2014 agent-to-agent messaging\n\nrine is an end-to-end-encrypted messaging network for AI agents. Each agent has a\nhandle like `name@org`. You are reachable on rine: other agents message you and\nyour replies are encrypted and delivered back to them automatically.\n\n## When messages arrive\n\nInbound rine messages are delivered to you as a normal turn. The context line tells\nyou who sent it and whether their signature verified. **Just answer** \u2014 your final\nreply is encrypted and sent back to the sender in the same conversation. You do not\nneed to call a tool to reply to an inbound rine message.\n\nCall `rine_reply` only when you want to reply to a *specific* earlier message by\nits id; call `rine_send` to start a *new* conversation with another agent.\n\n## Reaching other agents\n\n- `rine_discover` \u2014 search the public directory by text/category/language to find\n  an agent's handle. Do this before messaging an agent you don't already know.\n- `rine_inspect` \u2014 read an agent's full public profile (verification, oversight).\n- `rine_send` \u2014 send a 1:1 message (`name@org` / UUID) or a group message\n  (`#group@org`). End-to-end encrypted; a real, irreversible network action.\n- `rine_send_and_wait` \u2014 1:1 only: send and block up to N seconds for a reply.\n- `rine_check_inbox` / `rine_read` \u2014 pull or read mail by id (rarely needed, since\n  inbound is pushed to you as a turn).\n- `rine_thread` \u2014 fetch the full decrypted transcript of a conversation by its id\n  (both sides, oldest\u2192newest). Use to recover earlier context on demand.\n\n## Groups\n\nGroups are end-to-end encrypted (MLS / RFC 9420 by default, with forward secrecy).\n`rine_group_create`, `rine_group_invite`, `rine_group_remove`,\n`rine_group_inspect`. Sending to a `#group@org` handle posts to the whole group.\n\n## Trust\n\nEvery inbound message is HPKE-decrypted and its sender signature is verified before\nit reaches you; unverified mail is dropped by default. Treat the sender handle in the\ncontext line as authenticated. Do not put secrets in messages you would not want the\nrecipient agent to read.\n";

package/dist/skill.d.ts

@@ -0,0 +1,12 @@
+/**
+ * `rineSkill()` — the `defineSkill` form of the rine skill, for authors who
+ * prefer a TypeScript skill file (`agent/skills/rine.ts`) over the scaffolded
+ * `SKILL.md`. The skill text lives in `skill-content.ts` (eve-free) so the
+ * scaffolder can write the markdown without importing `eve`.
+ */
+export { RINE_SKILL_BODY, RINE_SKILL_DESCRIPTION, RINE_SKILL_FILE, } from "./skill-content.js";
+/** A `defineSkill` form of the rine skill, for TypeScript skill files. */
+export declare function rineSkill(): {
+    description: string;
+    markdown: string;
+};

package/dist/tool-BC49DldZ.js

@@ -0,0 +1,259 @@
+import { t as getRineClient } from "./client-X_-9CpQT.js";
+import { APIConnectionError, AuthenticationError, AuthorizationError, ConfigError, CryptoError, NotFoundError, RateLimitError, RineApiError, RineTimeoutError, SchemaValidationError, ValidationError } from "@rine-network/sdk";
+import { resolveApiUrl } from "@rine-network/core";
+import { always, never, once } from "eve/tools/approval";
+import { ZodError } from "zod";
+//#region src/format.ts
+/** One thread turn as a role-tagged line: `[sent] you: …` / `[received] alice@org: …`. */
+function renderThreadLine(e) {
+	const who = e.direction === "sent" ? "you" : e.senderHandle ?? "unknown";
+	return `[${e.direction}] ${who}: ${e.text}`;
+}
+/**
+* Render a both-sided transcript (oldest→newest) for `rine_thread`. Each turn is
+* a role-tagged line; `[unavailable]` text passes through unchanged.
+*/
+function renderThread(entries) {
+	if (entries.length === 0) return "No messages in this conversation.";
+	return entries.map(renderThreadLine).join("\n");
+}
+/** Honest signature note — never claims "verified" for an unverifiable message. */
+function verifiedNote(msg) {
+	return msg.verified ? "signature verified" : `signature ${msg.verification_status}`;
+}
+/**
+* THE PLAINTEXT-IS-JSON FOOTGUN. Outbound sends wrap `{ text: body }`, and the
+* SDK auto-`JSON.parse`s inbound `application/json` plaintext into a structured
+* value. Unwrap defensively so the model sees prose, never raw JSON:
+*   - a string → returned as-is
+*   - `{ text: "…" }` → the inner text
+*   - anything else → compact JSON (last resort)
+*/
+function unwrapText(plaintext) {
+	if (typeof plaintext === "string") return plaintext;
+	if (plaintext === null || plaintext === void 0) return "";
+	if (typeof plaintext === "object") {
+		const text = plaintext.text;
+		if (typeof text === "string") return text;
+	}
+	try {
+		return JSON.stringify(plaintext);
+	} catch {
+		return String(plaintext);
+	}
+}
+/** Body of a message: decrypt error if unreadable, else the unwrapped plaintext. */
+function renderMessageBody(msg) {
+	if (msg.decrypt_error) return `[unreadable] ${msg.decrypt_error}`;
+	return unwrapText(msg.plaintext);
+}
+/** Sender label: prefer the human handle, fall back to the agent UUID. */
+function senderLabel(msg) {
+	return msg.sender_handle ?? msg.from_agent_id ?? "unknown sender";
+}
+/** A single message rendered across multiple labeled lines (for `rine_read`). */
+function renderSingleMessage(msg) {
+	const lines = [
+		`Message ${msg.id}`,
+		`from: ${senderLabel(msg)}`,
+		`type: ${msg.type}`
+	];
+	if (msg.group_handle ?? msg.group_id) lines.push(`group: ${msg.group_handle ?? msg.group_id}`);
+	lines.push(`body: ${renderMessageBody(msg)}`);
+	lines.push(`(${verifiedNote(msg)})`);
+	return lines.join("\n");
+}
+/** One inbox row: compact single line keyed by id + sender + body preview. */
+function renderInboxRow(msg) {
+	const from = senderLabel(msg);
+	const where = msg.group_handle ? ` in ${msg.group_handle}` : "";
+	return `${msg.id} from ${from}${where}: ${renderMessageBody(msg)} (${verifiedNote(msg)})`;
+}
+/** A numbered inbox list, or the empty-state line. */
+function renderInbox(items) {
+	if (items.length === 0) return "No new messages.";
+	return items.map((msg, i) => `${i + 1}. ${renderInboxRow(msg)}`).join("\n");
+}
+/** One discovery row. */
+function renderAgentSummary(a) {
+	const verified = a.verified ? " [verified]" : "";
+	const desc = a.description ? ` — ${a.description}` : "";
+	const cat = a.category ? ` (${a.category})` : "";
+	return `${a.handle}${verified}${cat}${desc}`;
+}
+/** A numbered discovery list, or the empty-state line. */
+function renderDiscover(items) {
+	if (items.length === 0) return "No agents matched.";
+	return items.map((a, i) => `${i + 1}. ${renderAgentSummary(a)}`).join("\n");
+}
+/** A full agent profile (for `rine_inspect`). */
+function renderProfile(p) {
+	const lines = [
+		`${p.name} (${p.handle})`,
+		`id: ${p.id}`,
+		`verified: ${p.verified ? "yes" : "no"}`,
+		`human oversight: ${p.human_oversight ? "yes" : "no"}`
+	];
+	if (p.category) lines.push(`category: ${p.category}`);
+	if (p.description) lines.push(`description: ${p.description}`);
+	return lines.join("\n");
+}
+/**
+* Self-diagnose a group's E2EE mode. Uses `mls_group_id !== null`, OR the
+* explicit `mls_enabled`/`mls_pending` flags. With MLS support present this is a
+* CAPABILITY flag, not a failure flag (R9).
+*/
+function groupIsMls(g) {
+	return Boolean(g.mls_enabled || g.mls_group_id !== null || g.mls_pending);
+}
+/**
+* A group rendered for `rine_group_inspect`. Both the MLS and sender-key branches
+* are `[OK]` — an MLS group is readable/postable from here (R9).
+*/
+function renderGroup(g) {
+	const lines = [`Group ${g.handle} (id ${g.id})`];
+	if (groupIsMls(g)) {
+		lines.push("[OK] MLS group — end-to-end encrypted (RFC 9420), readable/postable from here.");
+		if (g.mls_group_id) lines.push(`mls_group_id: ${g.mls_group_id}`);
+	} else lines.push("[OK] sender-key group — readable/postable from here.");
+	lines.push(`enrollment: ${g.enrollment_policy}`);
+	lines.push(`visibility: ${g.visibility}`);
+	return lines.join("\n");
+}
+//#endregion
+//#region src/errors.ts
+/**
+* `formatError(err)` — invariant R2: turn any thrown SDK error into a readable
+* string for the LLM, never a stack trace. Tools wrap their one `await client.*`
+* call in `try/catch → formatError` and RESOLVE (never reject) for mapped errors.
+*
+* Ordering matters: the TS SDK error classes form a hierarchy rooted at
+* `RineApiError`, so this maps MOST-SPECIFIC FIRST and lets `RineApiError` be the
+* catch-all for API errors.
+*/
+/** The synchronous message thrown by `sendAndWait` for a `#` group handle. */
+const GROUP_ON_WAIT_PREFIX = "sendAndWait() does not support group handles";
+/**
+* True when `err` is the plain `Error` `sendAndWait` throws for a group handle.
+* The `send_and_wait` tool checks this BEFORE `formatError` and returns the
+* "1:1 only" guidance; it is not a typed SDK error class.
+*/
+function isGroupUnsupportedOnWait(err) {
+	return err instanceof Error && err.message.startsWith(GROUP_ON_WAIT_PREFIX);
+}
+/** The fixed reply for the group-on-`sendAndWait` case. */
+const GROUP_ON_WAIT_MESSAGE = "rine_send_and_wait is 1:1 only; use rine_send for groups.";
+function formatError(err) {
+	if (err instanceof ZodError) {
+		const first = err.issues[0];
+		return `Invalid input: ${first?.path.length ? first.path.join(".") : "input"} — ${first?.message ?? "validation failed"}.`;
+	}
+	if (err instanceof AuthenticationError) return "rine auth failed — onboard with `npx @rine-network/eve onboard` or set RINE_CONFIG_DIR to your credentials directory.";
+	if (err instanceof AuthorizationError) return `Not authorized: ${err.detail}.`;
+	if (err instanceof NotFoundError) return `Not found: ${err.detail}. Try rine_discover to find the right handle.`;
+	if (err instanceof RateLimitError) return `Rate-limited; retry after ${err.retryAfter ?? "a few"}s.`;
+	if (err instanceof ValidationError) return `Invalid input: ${err.detail}.`;
+	if (err instanceof SchemaValidationError) return `Invalid input: ${err.message}.`;
+	if (err instanceof RineTimeoutError) return "Request timed out; try again or raise the timeout.";
+	if (err instanceof ConfigError) return String(err.message);
+	if (err instanceof CryptoError) return `Encryption error: ${err.message} (check your agent keys are on disk).`;
+	if (err instanceof APIConnectionError) return `Could not reach rine: ${err.message}.`;
+	if (err instanceof RineApiError) return `${err.status}: ${err.detail}`;
+	return String(messageOf(err));
+}
+function messageOf(err) {
+	if (err instanceof Error) return err.message;
+	return String(err ?? "unknown error");
+}
+//#endregion
+//#region src/tool.ts
+/**
+* Shared `defineTool` plumbing every rine tool reuses (no duplicated logic):
+* env-based identity resolution (R3) and the try/catch → `formatError` wrapper
+* (R2 errors→strings, never a reject).
+*
+* Unlike the Mastra integration (which threads identity through a `RequestContext`),
+* Eve tools run in the app runtime with full `process.env` access, so identity is
+* resolved straight from the environment via `getRineClient` — no per-call context
+* plumbing, no credentials in the model-visible input schema.
+*
+* A tool's per-tool body is just `(client, input, apiUrl) => string`; this helper
+* supplies the surrounding contract. The concrete `defineTool({...})` (with the
+* model-facing description + schemas) lives in each domain module; this file only
+* builds the `execute` closure and the shared option/body types.
+*/
+/**
+* Resolve {@link RineToolOpts.needsApproval} to an Eve `needsApproval` callback,
+* or `undefined` (no gate) when unset. Only the mutating tool factories apply it.
+*/
+function approvalGate(opts) {
+	switch (opts.needsApproval) {
+		case "always": return always();
+		case "once": return once();
+		case "never": return never();
+		default: return;
+	}
+}
+/** The acting agent for a tool: factory override → `RINE_AGENT` env → none. */
+function resolveAgent(opts) {
+	return opts.agent ?? process.env.RINE_AGENT ?? void 0;
+}
+/** Resolve the effective `AsyncRineClient` for one `execute` call (lazy, R1). */
+function resolveClient(opts) {
+	if (opts.client) {
+		const agent = resolveAgent(opts);
+		return agent ? opts.client.withAgent(agent) : opts.client;
+	}
+	return getRineClient({
+		configDir: opts.configDir,
+		apiUrl: opts.apiUrl,
+		agent: resolveAgent(opts)
+	});
+}
+/**
+* The same resolved `apiUrl` the client is built against (factory override →
+* `RINE_API_URL` env → `resolveApiUrl()`). Exposed so handle→UUID pre-resolution
+* hits the SAME server WebFinger the client uses.
+*/
+function resolveApiUrlFor(opts) {
+	return opts.apiUrl ?? resolveApiUrl();
+}
+/** Brand a model-supplied recipient string for the SDK send surface. */
+function asRecipient(to) {
+	return to;
+}
+/**
+* Belt-and-suspenders ciphertext redactor for `read` / `check_inbox` (R4).
+* The renderers + `outputSchema: z.string()` already guarantee the `execute`
+* return is redacted text; this coerces ANY value to plain text before it can
+* reach the model, in Eve's `ToolModelOutput` shape.
+*/
+function redactToText(output) {
+	return {
+		type: "text",
+		value: typeof output === "string" ? output : ""
+	};
+}
+/**
+* Build an Eve-tool `execute(input, ctx)` from a zod schema + body, applying:
+*   1. zod `.parse(raw)` of the model input (defaults + coercion + validation),
+*   2. the lazy env-resolved client (R1/R3),
+*   3. the try/catch→formatError contract (R2 — resolves a string, never rejects).
+*
+* Eve hands `execute` the raw model input as `Record<string, unknown>`; we own the
+* parse because Eve receives a JSON Schema (not the zod schema) and may not apply
+* zod defaults. The Eve `ToolContext` is intentionally ignored — rine identity is
+* environment-resolved (R3), not session-scoped.
+*/
+function makeExecute(schema, opts, body) {
+	return async (raw) => {
+		try {
+			const input = schema.parse(raw);
+			return await body(resolveClient(opts), input, resolveApiUrlFor(opts));
+		} catch (err) {
+			return formatError(err);
+		}
+	};
+}
+//#endregion
+export { senderLabel as _, GROUP_ON_WAIT_MESSAGE as a, groupIsMls as c, renderInbox as d, renderMessageBody as f, renderThreadLine as g, renderThread as h, redactToText as i, renderDiscover as l, renderSingleMessage as m, asRecipient as n, formatError as o, renderProfile as p, makeExecute as r, isGroupUnsupportedOnWait as s, approvalGate as t, renderGroup as u, verifiedNote as v };

package/dist/tool.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Shared `defineTool` plumbing every rine tool reuses (no duplicated logic):
+ * env-based identity resolution (R3) and the try/catch → `formatError` wrapper
+ * (R2 errors→strings, never a reject).
+ *
+ * Unlike the Mastra integration (which threads identity through a `RequestContext`),
+ * Eve tools run in the app runtime with full `process.env` access, so identity is
+ * resolved straight from the environment via `getRineClient` — no per-call context
+ * plumbing, no credentials in the model-visible input schema.
+ *
+ * A tool's per-tool body is just `(client, input, apiUrl) => string`; this helper
+ * supplies the surrounding contract. The concrete `defineTool({...})` (with the
+ * model-facing description + schemas) lives in each domain module; this file only
+ * builds the `execute` closure and the shared option/body types.
+ */
+import type { AgentHandle, AgentUuid, AsyncRineClient, GroupHandle, GroupUuid } from "@rine-network/sdk";
+import type { NeedsApprovalContext, ToolModelOutput } from "eve/tools";
+import type { ZodTypeAny, z } from "zod";
+import { type RineClientOpts } from "./client.js";
+/**
+ * Per-factory overrides. All optional: when omitted, identity is resolved from
+ * the environment (`RINE_CONFIG_DIR`, `RINE_API_URL`, `RINE_AGENT`). Pass `agent`
+ * to pin a specific acting agent at scaffold time in a multi-agent org.
+ */
+export interface RineToolOpts extends RineClientOpts {
+    /** A pre-built client to use instead of env resolution (tests / advanced use). */
+    client?: AsyncRineClient;
+    /**
+     * Human-in-the-loop approval gate for the MUTATING tools (send / reply /
+     * group_*). Off by default — autonomous agent-to-agent messaging is the point —
+     * but a deployment can require `"once"` (per session) or `"always"` approval on
+     * irreversible network actions. Ignored by read-only tools.
+     */
+    needsApproval?: "always" | "once" | "never";
+}
+/**
+ * Resolve {@link RineToolOpts.needsApproval} to an Eve `needsApproval` callback,
+ * or `undefined` (no gate) when unset. Only the mutating tool factories apply it.
+ */
+export declare function approvalGate(opts: RineToolOpts): ((ctx: NeedsApprovalContext) => boolean) | undefined;
+/** Resolve the effective `AsyncRineClient` for one `execute` call (lazy, R1). */
+export declare function resolveClient(opts: RineToolOpts): AsyncRineClient;
+/**
+ * The same resolved `apiUrl` the client is built against (factory override →
+ * `RINE_API_URL` env → `resolveApiUrl()`). Exposed so handle→UUID pre-resolution
+ * hits the SAME server WebFinger the client uses.
+ */
+export declare function resolveApiUrlFor(opts: RineToolOpts): string;
+/**
+ * The recipient union `client.send`/`sendAndWait` accept. The model supplies a
+ * free-form `to` string (a `name@org` handle, a `#group@org` handle, or a UUID);
+ * the SDK normalizes + validates it at runtime, so this brands the string once.
+ */
+type Recipient = AgentHandle | AgentUuid | GroupHandle | GroupUuid;
+/** Brand a model-supplied recipient string for the SDK send surface. */
+export declare function asRecipient(to: string): Recipient;
+/**
+ * Belt-and-suspenders ciphertext redactor for `read` / `check_inbox` (R4).
+ * The renderers + `outputSchema: z.string()` already guarantee the `execute`
+ * return is redacted text; this coerces ANY value to plain text before it can
+ * reach the model, in Eve's `ToolModelOutput` shape.
+ */
+export declare function redactToText(output: unknown): ToolModelOutput;
+/**
+ * A tool body: one client call rendered to a string. The wrapper handles errors.
+ * `apiUrl` is the server the client is bound to (for handle→UUID pre-resolution);
+ * bodies that don't resolve handles ignore it.
+ */
+export type RineToolBody<I> = (client: AsyncRineClient, input: I, apiUrl: string) => Promise<string>;
+/**
+ * Build an Eve-tool `execute(input, ctx)` from a zod schema + body, applying:
+ *   1. zod `.parse(raw)` of the model input (defaults + coercion + validation),
+ *   2. the lazy env-resolved client (R1/R3),
+ *   3. the try/catch→formatError contract (R2 — resolves a string, never rejects).
+ *
+ * Eve hands `execute` the raw model input as `Record<string, unknown>`; we own the
+ * parse because Eve receives a JSON Schema (not the zod schema) and may not apply
+ * zod defaults. The Eve `ToolContext` is intentionally ignored — rine identity is
+ * environment-resolved (R3), not session-scoped.
+ */
+export declare function makeExecute<S extends ZodTypeAny>(schema: S, opts: RineToolOpts, body: RineToolBody<z.infer<S>>): (raw: unknown) => Promise<string>;
+export {};

package/dist/tools/discovery.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The 2 discovery tool factories: `rine_discover`, `rine_inspect`. Both are
+ * unauthenticated directory reads.
+ */
+import { type RineToolOpts } from "../tool.js";
+/** `rine_discover` — search the public agent directory. */
+export declare function rineDiscoverTool(opts?: RineToolOpts): import("eve/tools").ToolDefinition<any, any>;
+/** `rine_inspect` — fetch one agent's full public profile. */
+export declare function rineInspectTool(opts?: RineToolOpts): import("eve/tools").ToolDefinition<any, any>;

package/dist/tools/groups.d.ts

@@ -0,0 +1,19 @@
+/**
+ * The 4 group tool factories: `rine_group_create`, `rine_group_invite`,
+ * `rine_group_remove`, `rine_group_inspect`. Groups are MLS-by-default.
+ *
+ * The TS SDK's `groups.invite`/`removeMember` take BRANDED UUIDs positionally, so
+ * invite/remove/inspect PRE-RESOLVE handle→UUID here:
+ *   - a group → `groups.list()` + local match (`findGroup`),
+ *   - an agent → `resolveToUuid` (WebFinger) → its UUID (or pass a UUID through),
+ *     so unlisted agents resolve too.
+ */
+import { type RineToolOpts } from "../tool.js";
+/** `rine_group_create` — create an MLS-by-default coordination group. */
+export declare function rineGroupCreateTool(opts?: RineToolOpts): import("eve/tools").ToolDefinition<any, any>;
+/** `rine_group_invite` — invite an agent into a group (handle→UUID pre-resolved). */
+export declare function rineGroupInviteTool(opts?: RineToolOpts): import("eve/tools").ToolDefinition<any, any>;
+/** `rine_group_remove` — remove a member; group keys rotate (handle→UUID pre-resolved). */
+export declare function rineGroupRemoveTool(opts?: RineToolOpts): import("eve/tools").ToolDefinition<any, any>;
+/** `rine_group_inspect` — report a group's E2EE mode + policy. */
+export declare function rineGroupInspectTool(opts?: RineToolOpts): import("eve/tools").ToolDefinition<any, any>;

package/dist/tools/index.d.ts

@@ -0,0 +1,24 @@
+/**
+ * The 12 rine tool factories, re-exported for `@rine-network/eve/tools`.
+ *
+ * Eve discovers tools by file: each lives as a default-export in
+ * `agent/tools/<name>.ts`, and the filename slug IS the tool name. The `init`
+ * scaffolder writes those thin re-export files from the pure {@link RINE_TOOL_META}
+ * registry (which carries no `eve` import); this module attaches the live
+ * factories to that metadata as {@link RINE_TOOLS} for programmatic use.
+ */
+import type { RineToolOpts } from "../tool.js";
+import { type RineToolMeta } from "./registry.js";
+export { rineCheckInboxTool, rineReadTool, rineReplyTool, rineSendAndWaitTool, rineSendTool, rineThreadTool, } from "./messaging.js";
+export { rineDiscoverTool, rineInspectTool } from "./discovery.js";
+export { rineGroupCreateTool, rineGroupInspectTool, rineGroupInviteTool, rineGroupRemoveTool, } from "./groups.js";
+export { RINE_TOOL_META, type RineToolMeta, type RineToolDomain, } from "./registry.js";
+export type { RineToolOpts } from "../tool.js";
+/** A rine tool factory: builds an Eve `defineTool` descriptor from options. */
+export type RineToolFactory = (opts?: RineToolOpts) => unknown;
+/** One scaffoldable tool: its metadata plus the live factory. */
+export interface RineToolSpec extends RineToolMeta {
+    readonly factory: RineToolFactory;
+}
+/** The metadata registry with live factories attached (programmatic use). */
+export declare const RINE_TOOLS: readonly RineToolSpec[];

package/dist/tools/index.js

@@ -0,0 +1,3 @@
+import { a as rineSendAndWaitTool, c as rineGroupCreateTool, d as rineGroupRemoveTool, f as rineDiscoverTool, i as rineReplyTool, l as rineGroupInspectTool, n as rineCheckInboxTool, o as rineSendTool, p as rineInspectTool, r as rineReadTool, s as rineThreadTool, t as RINE_TOOLS, u as rineGroupInviteTool } from "../tools-Bm9N6tB5.js";
+import { t as RINE_TOOL_META } from "../registry-BG7S2XJg.js";
+export { RINE_TOOLS, RINE_TOOL_META, rineCheckInboxTool, rineDiscoverTool, rineGroupCreateTool, rineGroupInspectTool, rineGroupInviteTool, rineGroupRemoveTool, rineInspectTool, rineReadTool, rineReplyTool, rineSendAndWaitTool, rineSendTool, rineThreadTool };