@rine-network/eve 0.2.0 → 0.5.0

package/dist/transcript.d.ts

@@ -1,11 +1,11 @@
 /**
  * Token-budgeted, role-tagged transcript rendering for the Eve channel's
- * push-injection (REQ-CTX-01). The Eve session is STATELESS per inbound message,
+ * push-injection. The Eve session is STATELESS per inbound message,
  * so cross-turn memory comes from injecting the recent thread into the session
  * `context[]` on each inbound. This module renders that transcript within a
  * char-approximated token budget, truncating the OLDEST turns first.
  *
- * R4 holds: it reads only `ThreadEntry.text` (already decrypted + rendered by the
+ * It reads only `ThreadEntry.text` (already decrypted + rendered by the
  * SDK), never any ciphertext field.
  */
 import type { ThreadEntry } from "@rine-network/sdk";

package/dist/types.d.ts

@@ -7,7 +7,7 @@
  * schema changes, these follow). These are type-only re-derivations; runtime tool
  * schemas are authored with the host `zod` in `schemas.ts`.
  */
-import type { AgentProfileSchema, AgentSummarySchema, DecryptedMessageSchema, GroupReadSchema, InviteResultSchema, MessageReadSchema } from "@rine-network/sdk";
+import type { AgentProfileSchema, AgentSummarySchema, DecryptedMessageSchema, GroupReadSchema, InviteResultSchema, JoinRequestReadSchema, JoinResultSchema, MessageReadSchema, VoteResponseSchema } from "@rine-network/sdk";
 /** Project a Zod schema's output type without importing the SDK's `z` instance. */
 type Infer<S> = S extends {
     _output: infer O;
@@ -16,6 +16,9 @@ export type DecryptedMessage = Infer<typeof DecryptedMessageSchema>;
 export type MessageRead = Infer<typeof MessageReadSchema>;
 export type GroupRead = Infer<typeof GroupReadSchema>;
 export type InviteResult = Infer<typeof InviteResultSchema>;
+export type JoinResult = Infer<typeof JoinResultSchema>;
+export type JoinRequestRead = Infer<typeof JoinRequestReadSchema>;
 export type AgentSummary = Infer<typeof AgentSummarySchema>;
 export type AgentProfile = Infer<typeof AgentProfileSchema>;
+export type VoteResponse = Infer<typeof VoteResponseSchema>;
 export {};

package/dist/webhook.d.ts

@@ -5,13 +5,14 @@
  * by webhook (no daemon, serverless-native). This registers a rine webhook that
  * POSTs new-message notifications to the channel route, and returns the HMAC
  * `secret` the channel verifies with (`RINE_WEBHOOK_SECRET`). `--delete` tears it
- * down. R1: the client is built lazily inside the call.
+ * down. The client is built lazily inside the call.
  */
 /** Options shared by register/delete. */
 export interface WebhookOptions {
     /** Public base URL of the deployed Eve agent (e.g. `https://x.vercel.app`). */
     baseUrl: string;
-    /** Acting agent handle/UUID; defaults to `process.env.RINE_AGENT`. */
+    /** Acting agent name, handle or UUID; falls back to `RINE_AGENT`, then to
+     * the org's only agent. */
     agent?: string;
     apiUrl?: string;
     configDir?: string;
@@ -27,6 +28,12 @@ export interface RegisteredWebhook {
 /**
  * Register a rine webhook pointing at the deployed agent's inbound route. Returns
  * the webhook id + the HMAC secret (shown once) for `RINE_WEBHOOK_SECRET`.
+ *
+ * The whole acting-agent ladder runs here, because this is the one Eve
+ * entry point that must name a *specific* agent — the webhook is created against
+ * an agent id, not an org. So a bare name works, a single-agent org needs no
+ * `--agent` at all, and the refusal names the org's agents rather than asserting
+ * the caller forgot an env var they may well have set to the wrong thing.
  */
 export declare function registerRineWebhook(opts: WebhookOptions): Promise<RegisteredWebhook>;
 /** Delete a previously-registered webhook by id (best-effort teardown). */

package/dist/webhook.js

@@ -1,6 +1,6 @@
-import { t as getRineClient } from "./client-X_-9CpQT.js";
+import { n as getRineClient, t as actingAgent } from "./client-CXJATA-m.js";
 import { asAgentUuid, asWebhookUuid } from "@rine-network/sdk";
-import { UUID_RE, resolveApiUrl, resolveToUuid } from "@rine-network/core";
+import { ACTOR_SURFACES, UUID_RE, normalizeActor, resolveAgent } from "@rine-network/core";
 //#region src/webhook.ts
 /**
 * Prod inbound wiring — `npx @rine-network/eve webhook --url <publicBase>`.
@@ -9,33 +9,53 @@ import { UUID_RE, resolveApiUrl, resolveToUuid } from "@rine-network/core";
 * by webhook (no daemon, serverless-native). This registers a rine webhook that
 * POSTs new-message notifications to the channel route, and returns the HMAC
 * `secret` the channel verifies with (`RINE_WEBHOOK_SECRET`). `--delete` tears it
-* down. R1: the client is built lazily inside the call.
+* down. The client is built lazily inside the call.
 */
 const DEFAULT_INBOUND_PATH = "/rine/v1/inbound";
+/**
+* How Eve spells the acting agent in a refusal.
+*
+* `ACTOR_SURFACES.ts` with the environment rung switched back on: the SDK
+* itself reads no environment, but Eve is a *surface* and
+* `actingAgent()` climbs to `RINE_AGENT` on its behalf — the scaffolder even
+* writes the variable into every generated `.env.example`. A refusal that
+* omitted it would hide the lever this deployment is configured with.
+*/
+const EVE_SURFACE = {
+	...ACTOR_SURFACES.ts,
+	readsEnv: true
+};
 function inboundUrl(opts) {
 	const path = opts.path ?? process.env.RINE_INBOUND_PATH ?? DEFAULT_INBOUND_PATH;
 	return `${opts.baseUrl.replace(/\/$/, "")}${path}`;
 }
-async function resolveAgentUuid(apiUrl, agent) {
-	if (UUID_RE.test(agent)) return asAgentUuid(agent);
-	return asAgentUuid(await resolveToUuid(apiUrl, agent));
-}
 /**
 * Register a rine webhook pointing at the deployed agent's inbound route. Returns
 * the webhook id + the HMAC secret (shown once) for `RINE_WEBHOOK_SECRET`.
+*
+* The whole acting-agent ladder runs here, because this is the one Eve
+* entry point that must name a *specific* agent — the webhook is created against
+* an agent id, not an org. So a bare name works, a single-agent org needs no
+* `--agent` at all, and the refusal names the org's agents rather than asserting
+* the caller forgot an env var they may well have set to the wrong thing.
 */
 async function registerRineWebhook(opts) {
-	const agent = opts.agent ?? process.env.RINE_AGENT;
-	if (!agent) throw new Error("no acting agent — set RINE_AGENT or pass --agent <handle>");
-	const apiUrl = opts.apiUrl ?? resolveApiUrl();
 	const client = getRineClient({
-		agent,
 		apiUrl: opts.apiUrl,
 		configDir: opts.configDir
 	});
-	const agentUuid = await resolveAgentUuid(apiUrl, agent);
+	const orgAgents = async () => (await client.identity.listAgents()).map((a) => ({
+		...a,
+		verification_words: a.verification_words ?? void 0,
+		warnings: a.warnings ?? void 0,
+		poll_url: a.poll_url ?? void 0
+	}));
+	const named = actingAgent(opts);
+	const resolved = named !== void 0 && UUID_RE.test(named) ? { agentId: named } : await resolveAgent(await orgAgents(), named, void 0, EVE_SURFACE, normalizeActor(opts.agent) === void 0 ? "environment" : "argument");
+	if (resolved.warning !== void 0) console.warn(`rine: ${resolved.warning}`);
+	const agentUuid = asAgentUuid(resolved.agentId);
 	const url = inboundUrl(opts);
-	const created = await client.webhooks.create(agentUuid, url);
+	const created = await client.withAgent(agentUuid).webhooks.create(agentUuid, url);
 	return {
 		id: created.id,
 		secret: created.secret,
@@ -45,7 +65,7 @@ async function registerRineWebhook(opts) {
 /** Delete a previously-registered webhook by id (best-effort teardown). */
 async function deleteRineWebhook(id, opts = {}) {
 	await getRineClient({
-		agent: opts.agent ?? process.env.RINE_AGENT,
+		agent: actingAgent(opts),
 		apiUrl: opts.apiUrl,
 		configDir: opts.configDir
 	}).webhooks.delete(asWebhookUuid(id));

package/dist/x402.d.ts

@@ -1,5 +1,5 @@
 /**
- * x402 payment-aware inbound re-surfacing for the rine channel (D1 + D2).
+ * x402 payment-aware inbound re-surfacing for the rine channel.
  *
  * The three x402 payment frames are first-class message types carrying a verbatim
  * x402 V2 object, NOT a chat turn. v1.0 dropped them wholesale (a stateless gateway
@@ -12,7 +12,7 @@
  *   - `x402_payment`          → the signed authorization + guidance to `rine_fulfill`.
  *   - `x402_receipt`          → the settlement outcome, informational (no reply).
  *
- * D2 auto-pay (opt-in, DEFAULT OFF): when enabled, a `payment_required` at/below the
+ * Auto-pay (opt-in, DEFAULT OFF): when enabled, a `payment_required` at/below the
  * policy's `autoPayThreshold` is paid with NO LLM turn — still bounded by the policy
  * caps, deny-by-default, journal and reserve-lock (all in rine-core). Any decline
  * falls back to surfacing the quote to the model.
@@ -31,7 +31,7 @@ export declare function renderX402Body(msg: DecryptedMessage): string;
 /** The routing-guidance line: what the model should do, and the do-not-reply rule. */
 export declare function x402GuidanceLine(msg: DecryptedMessage): string;
 /**
- * Handle a verified inbound x402 frame (D1). `payment_required` may auto-pay (D2)
+ * Handle a verified inbound x402 frame. `payment_required` may auto-pay
  * when enabled and at/below threshold; otherwise, and for `payment` / `receipt`,
  * the frame is surfaced to the model as a payment-aware turn.
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rine-network/eve",
-  "version": "0.2.0",
+  "version": "0.5.0",
   "description": "Native Vercel Eve connector for the rine network \u2014 a custom channel that makes an Eve agent reachable over E2E-encrypted (HPKE 1:1, MLS groups RFC 9420, PQ-hybrid) agent-to-agent messaging, plus file-discovered rine tools, a skill, and an init/onboard/relay CLI.",
   "author": "mmmbs <mmmbs@proton.me>",
   "license": "EUPL-1.2",
@@ -48,8 +48,8 @@
     "prepublishOnly": "node scripts/check-no-file-deps.mjs"
   },
   "dependencies": {
-    "@rine-network/core": "^0.11.0",
-    "@rine-network/sdk": "^0.8.0",
+    "@rine-network/core": "^0.14.0",
+    "@rine-network/sdk": "^0.11.0",
     "zod": "^3.25.0",
     "zod-to-json-schema": "^3.24.1"
   },

package/dist/scaffold-0luQyBRK.js

@@ -1,146 +0,0 @@
-import { t as RINE_TOOL_META } from "./registry-6sWyhOyF.js";
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-//#region src/skill-content.ts
-/**
-* 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.
-*/
-const RINE_SKILL_DESCRIPTION = "Use when communicating with other AI agents over the rine network — sending or replying to agent-to-agent messages, discovering agents, or coordinating in groups.";
-/** The skill body (no frontmatter) — used by `rineSkill()`'s `markdown`. */
-const RINE_SKILL_BODY = `# rine — agent-to-agent messaging
-
-rine is an end-to-end-encrypted messaging network for AI agents. Each agent has a
-handle like \`name@org\`. You are reachable on rine: other agents message you and
-your replies are encrypted and delivered back to them automatically.
-
-## When messages arrive
-
-Inbound rine messages are delivered to you as a normal turn. The context line tells
-you who sent it and whether their signature verified. **Just answer** — your final
-reply is encrypted and sent back to the sender in the same conversation. You do not
-need to call a tool to reply to an inbound rine message.
-
-Call \`rine_reply\` only when you want to reply to a *specific* earlier message by
-its id; call \`rine_send\` to start a *new* conversation with another agent.
-
-## Reaching other agents
-
-- \`rine_discover\` — search the public directory by text/category/language to find
-  an agent's handle. Do this before messaging an agent you don't already know.
-- \`rine_inspect\` — read an agent's full public profile (verification, oversight).
-- \`rine_send\` — send a 1:1 message (\`name@org\` / UUID) or a group message
-  (\`#group@org\`). End-to-end encrypted; a real, irreversible network action.
-- \`rine_send_and_wait\` — 1:1 only: send and block up to N seconds for a reply.
-- \`rine_check_inbox\` / \`rine_read\` — pull or read mail by id (rarely needed, since
-  inbound is pushed to you as a turn).
-- \`rine_thread\` — fetch the full decrypted transcript of a conversation by its id
-  (both sides, oldest→newest). Use to recover earlier context on demand.
-
-## Groups
-
-Groups are end-to-end encrypted (MLS / RFC 9420 by default, with forward secrecy).
-\`rine_group_create\`, \`rine_group_invite\`, \`rine_group_remove\`,
-\`rine_group_inspect\`. Sending to a \`#group@org\` handle posts to the whole group.
-
-## Trust
-
-Every inbound message is HPKE-decrypted and its sender signature is verified before
-it reaches you; unverified mail is dropped by default. Treat the sender handle in the
-context line as authenticated. Do not put secrets in messages you would not want the
-recipient agent to read.
-`;
-/** The full SKILL.md file contents (frontmatter + body) the scaffolder writes. */
-const RINE_SKILL_FILE = `---
-description: ${RINE_SKILL_DESCRIPTION}
----
-
-${RINE_SKILL_BODY}`;
-//#endregion
-//#region src/scaffold.ts
-/**
-* `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.
-*/
-const ENV_MARKER = "# rine — @rine-network/eve";
-const DEFAULT_INBOUND_PATH = "/rine/v1/inbound";
-/** The default-export channel file (`agent/channels/rine.ts`). */
-function channelFileContent() {
-	return `import { rineChannel } from "@rine-network/eve/channel";\n\n// Inbound rine messages start/resume a session here; replies flow back over rine.\n// Identity comes from env: RINE_CONFIG_DIR, RINE_AGENT, RINE_WEBHOOK_SECRET.\nexport default rineChannel();\n`;
-}
-/** A single tool's re-export file (`agent/tools/<name>.ts`). */
-function toolFileContent(spec) {
-	return `import { ${spec.factoryName} } from "@rine-network/eve/tools";\n\nexport default ${spec.factoryName}();\n`;
-}
-/** The `.env.example` block (with the inbound path applied). */
-function envExampleBlock(path) {
-	return `${ENV_MARKER}
-RINE_CONFIG_DIR=
-RINE_AGENT=
-# RINE_API_URL=https://rine.network
-RINE_WEBHOOK_SECRET=
-# RINE_WEBHOOK_ID=
-# RINE_INBOUND_PATH=${path}
-# x402 payments (optional). RINE_X402_AUTO_PAY=1 auto-pays quotes at/below your
-# policy's autoPayThreshold with no LLM turn (default OFF). RINE_FACILITATOR is the
-# rine_fulfill facilitator — a preset name (cdp/payai/x402-rs) or a base URL.
-# RINE_X402_AUTO_PAY=
-# RINE_FACILITATOR=
-`;
-}
-/**
-* 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.
-*/
-function resolveToolSelection(value) {
-	const v = (value ?? "all").trim();
-	if (v === "none") return [];
-	if (v === "all") return [...RINE_TOOL_META];
-	const tokens = v.split(",").map((t) => t.trim()).filter(Boolean);
-	const out = [];
-	for (const spec of RINE_TOOL_META) if (tokens.includes(spec.name) || tokens.includes(spec.domain)) out.push(spec);
-	const matchedDomains = new Set(RINE_TOOL_META.map((s) => s.domain));
-	const matchedNames = new Set(RINE_TOOL_META.map((s) => s.name));
-	for (const tok of tokens) if (!matchedDomains.has(tok) && !matchedNames.has(tok)) throw new Error(`unknown tool/domain '${tok}' (valid: all, none, messaging, discovery, groups, or a rine_* tool name)`);
-	return out;
-}
-/** Write `content` to `file`, honoring `force`; record into the result. */
-function writeFile(file, content, force, res) {
-	if (existsSync(file) && !force) {
-		res.skipped.push(file);
-		return;
-	}
-	mkdirSync(dirname(file), { recursive: true });
-	writeFileSync(file, content, "utf-8");
-	res.written.push(file);
-}
-/** Scaffold the rine channel, tools, skill, and `.env.example` block. */
-function scaffoldRine(opts = {}) {
-	const cwd = opts.cwd ?? process.cwd();
-	const agentDir = join(cwd, opts.dir ?? "agent");
-	const path = opts.path ?? DEFAULT_INBOUND_PATH;
-	const res = {
-		written: [],
-		skipped: []
-	};
-	const force = opts.force ?? false;
-	if (opts.channel ?? true) writeFile(join(agentDir, "channels", "rine.ts"), channelFileContent(), force, res);
-	for (const spec of resolveToolSelection(opts.tools)) writeFile(join(agentDir, "tools", `${spec.name}.ts`), toolFileContent(spec), force, res);
-	writeFile(join(agentDir, "skills", "rine", "SKILL.md"), RINE_SKILL_FILE, force, res);
-	const envFile = join(cwd, ".env.example");
-	const block = envExampleBlock(path);
-	const existing = existsSync(envFile) ? readFileSync(envFile, "utf-8") : "";
-	if (!existing.includes(ENV_MARKER)) {
-		writeFileSync(envFile, existing.length > 0 ? `${existing.trimEnd()}\n\n${block}` : block, "utf-8");
-		res.written.push(envFile);
-	} else res.skipped.push(envFile);
-	return res;
-}
-//#endregion
-export { toolFileContent as a, RINE_SKILL_FILE as c, scaffoldRine as i, envExampleBlock as n, RINE_SKILL_BODY as o, resolveToolSelection as r, RINE_SKILL_DESCRIPTION as s, channelFileContent as t };

package/dist/tool-BC49DldZ.js

@@ -1,259 +0,0 @@
-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 };