@rine-network/eve 0.3.0 → 0.5.0

package/dist/tools-CQDZG-qN.js

@@ -0,0 +1,1149 @@
+import { C as renderRoster, S as renderGroups, a as GROUP_ON_WAIT_MESSAGE, b as verifiedNote, c as renderDiscover, d as renderInvites, f as renderJoinResult, g as renderThread, h as renderSingleMessage, i as redactToText, l as renderGroup, m as renderProfile, n as asRecipient, p as renderMessageBody, r as makeExecute, s as isGroupUnsupportedOnWait, t as approvalGate, u as renderInbox, v as renderWhoAmI, x as renderGroupSummaries } from "./tool-DeOeMNlK.js";
+import { t as RINE_TOOL_META } from "./registry-DsU13KY3.js";
+import { FACILITATOR_PRESET, RineApiError, SchemaValidationError, VoteEligibility, X402Error, X402FacilitatorError, X402_ERROR, X402_MESSAGE_TYPE, asAgentUuid, asMessageUuid, rineErrorCode } from "@rine-network/sdk";
+import { JOIN_REFERENCE_RULE, THREAD_REF_SURFACES, UUID_RE, VOTE_DURATION_MAX_HOURS, VOTE_DURATION_MIN_HOURS, VOTE_DURATION_RULE, VOTE_ELECTORATE_RULE, admissionHeadline, createdGroupMls, describeMlsReclamation, describeMlsRecovery, groupAdmissionSkipSentence, handleCompletionNotes, mlsAdmissionSkipSentence, resolveThreadRef, resolveToUuid, threadRefRequiredRefusal } from "@rine-network/core";
+import { z } from "zod";
+import { defineTool } from "eve/tools";
+import { zodToJsonSchema } from "zod-to-json-schema";
+//#region src/_zod.ts
+/**
+* Convert a zod schema to a plain JSON Schema for `defineTool`'s `inputSchema`.
+* Returns `any` deliberately: it bridges into Eve's internal `JsonObject` type,
+* which is not exported for us to name.
+*/
+function jsonSchema(schema) {
+	return zodToJsonSchema(schema, { $refStrategy: "none" });
+}
+/** The shared `outputSchema` for every rine tool: a JSON-Schema string. */
+const STRING_OUTPUT = { type: "string" };
+//#endregion
+//#region src/schemas-groups-list.ts
+/**
+* Zod input schemas for the three group READ verbs (`tools/groups-list.ts`):
+* `rine_groups`, `rine_discover_groups`, `rine_group_roster`.
+*
+* Their own module because `schemas-groups.ts` already carries the ten write
+* and admission verbs at its ~200-LOC budget. Same authoring rules as every
+* other schema file here: rich `.describe()` on every field, and NO identity or
+* credentials in a model-visible schema (both are env-injected).
+*/
+/** No input: lists the groups this agent's ORG belongs to, never one agent's own. */
+const groupsInput = z.object({});
+const discoverGroupsInput = z.object({
+	q: z.string().optional().describe("Free-text search matched against public group names, handles, and descriptions. Omit to browse the newest public groups."),
+	limit: z.number().int().min(1).max(100).default(10).describe("Maximum number of groups to return (1–100, default 10).")
+});
+const groupRosterInput = z.object({ group: z.string().describe("The group whose members to list: a handle (`#logistics@acme.rine.network`), its name (`logistics`), or a UUID. Resolved against the groups your org's agents are seated in — which includes a group the acting agent itself is not seated in. The roster marks your org's own rows `(yours)`, so it also answers which agent could act there.") });
+const groupCreateInput = z.object({
+	name: z.string().describe("Human-readable group name. A group handle is derived from it."),
+	enrollment: z.enum([
+		"open",
+		"closed",
+		"majority",
+		"unanimity"
+	]).default("closed").describe("Who may join and how: `open` (anyone), `closed` (invite-only, default), `majority` (member vote), `unanimity` (all must approve)."),
+	visibility: z.enum(["public", "private"], { message: "visibility is required and has no default. Choose \"public\" — the group is listed at dir.rine.network for anyone to find, and the member-joined signal is off — or \"private\" — it is not listed, and members are signalled when someone joins." }).describe("Required, no default. `public` lists the group at dir.rine.network for anyone to find, and turns the member-joined signal off. `private` does not list it, and members are signalled when someone joins."),
+	description: z.string().optional().describe("Optional durable house rules, readable by every member and every later arrival. NOT end-to-end encrypted — unlike a message body it is a plain column on the group row, readable by the rine server and by any agent the group is visible to. Put the rules here; send the secret."),
+	voteDurationHours: z.number().int().min(VOTE_DURATION_MIN_HOURS).max(VOTE_DURATION_MAX_HOURS).optional().describe(VOTE_DURATION_RULE),
+	members: z.array(z.string()).optional().describe("Agents to invite as the group is created: handles (`kofi@acme.rine.network`) or UUIDs, reported one outcome per entry. A roster INVITES, it never seats — the new group has one member until each invitee joins — and an unaccepted invitation holds a ratchet-tree seat against the group's seat ceiling until it expires. It mints real invitations under every enrollment policy, `majority` and `unanimity` included, because at founding the creator is the only member and therefore the whole electorate, so a vote here would decide nothing; an invite sent later into one of those two policies nominates instead. On an MLS group a roster is what lets the founding mint every leaf in a handful of commits instead of one commit per member."),
+	enableMls: z.boolean().default(true).describe("Create the group with post-quantum MLS (RFC 9420) end-to-end encryption (default true). MLS gives forward secrecy and post-compromise security across epochs. Set false for a sender-key broadcast group, whose bodies are classical AES-256-GCM. Open-enrollment groups are sender-key either way.")
+});
+const groupInviteInput = z.object({
+	group: z.string().describe("The target group: a handle (`#logistics@acme.rine.network`), its name (`logistics`), or a UUID. Resolved to a UUID before inviting."),
+	agentToInvite: z.string().optional().describe("One agent to invite: a handle (`kofi@acme.rine.network`) or a UUID. Resolved to a UUID before inviting. On a `majority` or `unanimity` group this nominates rather than invites — it files a join request the group's electorate decides — so the reply names the nomination, not a seat. Name exactly one of `agentToInvite` or `agentsToInvite`."),
+	agentsToInvite: z.array(z.string()).optional().describe("Several agents to invite in one call: handles or UUIDs, reported one outcome per entry in the order given. A batch drops what it cannot admit — a revoked agent, one already a member — instead of refusing everyone, and on an MLS group it mints every new leaf in one commit rather than one commit each. On a `majority` or `unanimity` group each entry comes back `nominated` rather than `invited` and no leaf is minted for it, because the vote is what seats a member there. Name exactly one of `agentToInvite` or `agentsToInvite`."),
+	message: z.string().optional().describe("Optional message included with the invite.")
+});
+const groupRemoveInput = z.object({
+	group: z.string().describe("The target group: a handle (`#logistics@acme.rine.network`), its name (`logistics`), or a UUID. Resolved to a UUID before removal."),
+	agentId: z.string().describe("The member to remove: a handle (`kofi@acme.rine.network`) or a UUID. On an MLS group this posts a real Remove commit that takes their ratchet-tree leaf with it, so it is an O(members) operation that can fail; an open group has no cryptographic eviction, and what bounds a departed member's reach there is each remaining member rotating their sender key on the next send. Naming this agent's own id is a leave, and a leave also retires this machine's local key material for the group.")
+});
+const groupInspectInput = z.object({ group: z.string().describe("The group to inspect: a handle (`#logistics@acme.rine.network`), its name (`logistics`), or a UUID. Reports its E2EE mode and policy.") });
+const groupJoinInput = z.object({
+	group: z.string().describe(`The group to join. ${JOIN_REFERENCE_RULE} An id is what a rine_discover_groups row prints beside a handle.`),
+	message: z.string().optional().describe("Optional message included with the join request (approval-gated groups only).")
+});
+/** No input: lists the caller's own pending group invites. */
+const groupInvitesInput = z.object({});
+const groupRequestsInput = z.object({
+	group: z.string().describe("The group whose outstanding admissions to list: a handle (`#logistics@acme.rine.network`), its name (`logistics`), or a UUID."),
+	outstanding: z.enum([
+		"pending",
+		"invited",
+		"live"
+	]).default("pending").describe("Which population to list. `pending` (the default) is the vote queue — agents that applied or were nominated by a member and are awaiting a decision, and the only rows `rine_group_vote` can act on. `invited` is the group's unaccepted invitations. `live` is both, and members plus live is the whole ratchet tree the group's seat ceiling counts, which is why a group can be full while its member count reads less.")
+});
+const groupVoteInput = z.object({
+	group: z.string().describe("The group the request was filed against: a handle (`#logistics@acme.rine.network`), its name (`logistics`), or a UUID."),
+	requestId: z.string().describe("The join request to decide, as reported by `rine_group_requests` under the `pending` filter."),
+	vote: z.enum(["approve", "deny"]).describe("`approve` or `deny`. An approve that crosses the group's threshold hands a stranger the group's keys and cannot be taken back — on an MLS group their ratchet-tree leaf and Welcome are minted as part of this vote. A request another member nominated is carried the same way, and if the nominee has not yet asked to join it resolves to an invitation for it to accept rather than to a seat.")
+});
+const groupLeaveInput = z.object({ group: z.string().describe("The group to leave: a handle (`#logistics@acme.rine.network`), its name (`logistics`), or a UUID. A leave posts no Remove commit — MLS gives nobody a way to commit their own removal — so the leaf stays in the ratchet tree until a member runs the reclamation pass, which any member may run. It does retire this host's key material for the group: the group's messages stop opening here, including ones that arrived before the leave and were never read, and nothing is taken back from anyone still in the group.") });
+const groupSyncInput = z.object({ group: z.string().describe("The group to catch this host's local state up with: a handle (`#logistics@acme.rine.network`), its name (`logistics`), or a UUID. On an MLS group the cheap rung replays the commits the server still holds and posts nothing; the expensive one posts a single external commit that re-seats this agent's leaf at the current epoch, which is O(members) and billed to every member. An open group runs sender keys and has no epoch chain, so there this installs the sender keys this host is missing — the ones waiting in its own inbox — and posts nothing. A group created to run MLS whose ratchet tree was never founded gets that same install and a warning that it has not got the MLS it was created for: a member has to found the group's MLS state.") });
+const groupReclaimInput = z.object({ group: z.string().describe("The MLS group whose ratchet tree to seat and then tidy: a handle (`#logistics@acme.rine.network`), its name (`logistics`), or a UUID. Every invitee still without a leaf is seated first, then the leaves that belong to no member and no live invitation are retired — one Remove commit each, every one O(members) and billed to every member. An open group runs sender keys, has no ratchet tree, and is refused.") });
+//#endregion
+//#region src/schemas-payments.ts
+/**
+* Zod input schemas for the 2 x402 payment 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). The facilitator is infra config, resolved from the tool factory / env —
+* never a model-visible input.
+*/
+const payInput = z.object({
+	messageId: z.string().describe("The UUID of the received `rine.v1.x402_payment_required` quote to pay. The signed payment is sent back in the same conversation."),
+	autoPay: z.boolean().default(false).describe("If true, pay ONLY when the quote is at/below your policy's autoPayThreshold; otherwise return `above-auto-pay-threshold` without paying. Default false — calling this tool is itself the authorization, still bounded by the spend caps."),
+	emitMarker: z.boolean().default(true).describe("Attach the cleartext status marker (coarse lifecycle state only — never amounts/assets/addresses). Default true; set false for a fully-sealed payment."),
+	allowRepay: z.boolean().default(false).describe("If true, re-pay a quote already paid today (a deliberate second, permanent debit). Default false — a repeat pay of the same messageId returns `already-paid` without spending.")
+});
+const fulfillInput = z.object({
+	messageId: z.string().describe("The UUID of the received `rine.v1.x402_payment` (signed authorization) to fulfill. Verifies and settles it via your configured facilitator, then sends the receipt back in-thread."),
+	emitMarker: z.boolean().default(true).describe("Attach the cleartext status marker on the receipt (coarse lifecycle state only). Default true.")
+});
+//#endregion
+//#region src/schemas.ts
+/**
+* Shared Zod input schemas for the 25 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`, never the model-visible
+* input schema.
+*/
+const DEFAULT_MESSAGE_TYPE = "rine.v1.task_request";
+const DEFAULT_REPLY_TYPE = "rine.v1.task_response";
+/**
+* The exactly-one-of rule for `rine_thread`'s two references, in the words the
+* refusal will use if it is broken.
+*
+* One string teaches the schema and answers the mistake, so the model can never
+* be told a rule the product does not enforce. Its spellings come from
+* `rine-core` — these tools name the two references exactly as the TypeScript
+* SDK does (`group` / `conversationId`), which is what `THREAD_REF_SURFACES.sdk`
+* holds.
+*/
+const THREAD_REF_RULE = threadRefRequiredRefusal(THREAD_REF_SURFACES.sdk);
+const sendInput = z.object({
+	to: z.string().describe("Recipient handle/UUID, or a group. Examples: `kofi@acme.rine.network` for one agent; `#logistics@acme.rine.network`, or just `logistics`, for a group. A group target sends to the whole group over its E2EE channel (MLS or sender-key, chosen automatically). A bare name that is one of your own agents' is refused rather than posted, and the refusal prints the handle that would have sent the 1:1."),
+	body: z.string().describe("The plaintext message text to send. It is end-to-end encrypted before transmission."),
+	messageType: z.string().default(DEFAULT_MESSAGE_TYPE).describe("The rine message type, e.g. `rine.v1.task_request` (default) or `rine.v1.text`. Leave as the default unless you know the recipient expects a specific type."),
+	idempotencyKey: z.string().optional().describe("Optional idempotency key. Reusing the same key for a retry prevents a duplicate send if the first attempt's response was lost.")
+});
+const sendAndWaitInput = z.object({
+	to: z.string().describe("Recipient agent address (1:1 ONLY): a handle `kofi@acme.rine.network` or a UUID. Group handles (`#…`) are NOT supported here — use rine_send for groups."),
+	body: z.string().describe("The plaintext message text to send. End-to-end encrypted before transmission."),
+	waitSeconds: z.number().int().min(1).max(300).default(30).describe("How long to block waiting for a reply, in SECONDS (1–300, default 30). Returns the reply if one arrives in time, otherwise a 'no reply' note."),
+	messageType: z.string().default(DEFAULT_MESSAGE_TYPE).describe(`The rine message type (default \`${DEFAULT_MESSAGE_TYPE}\`).`)
+});
+const inboxInput = z.object({
+	status: z.enum([
+		"new",
+		"delivered",
+		"read",
+		"all"
+	]).default("new").describe("Which messages to fetch (default `new`). `new` is the mail this agent has not acknowledged yet, and it is the ONLY value that marks what it returns delivered. `delivered` and `read` re-read mail already acknowledged, and `all` drops the filter entirely; none of the three marks anything."),
+	limit: z.number().int().min(1).max(100).default(20).describe("Maximum number of messages to fetch and decrypt (1–100, default 20). On the default `new` status the fetched messages are marked delivered, so a later check returns only newer mail.")
+});
+const readInput = z.object({ messageId: z.string().describe("The UUID of the message to fetch and decrypt. Returns the decrypted body and signature status.") });
+const replyInput = z.object({
+	messageId: z.string().describe("The UUID of the message you are replying to. The reply threads into the same conversation."),
+	body: z.string().describe("The plaintext reply text. End-to-end encrypted before transmission."),
+	messageType: z.string().default(DEFAULT_REPLY_TYPE).describe(`The rine message type for the reply (default \`${DEFAULT_REPLY_TYPE}\`).`)
+});
+const threadInput = z.object({
+	group: z.string().optional().describe(`The group whose transcript to read: its handle (#logistics@acme.rine.network), its name, or its UUID. Returns every turn since this agent was seated, decrypted and role-tagged, oldest→newest. ${THREAD_REF_RULE}`),
+	conversationId: z.string().optional().describe(`The UUID of the conversation to fetch the transcript of. Returns every turn (yours and the peer's) decrypted and role-tagged, oldest→newest. ${THREAD_REF_RULE}`),
+	limit: z.number().int().min(1).max(100).optional().describe("Optional max number of most-recent turns to return (1–100). Omit for the server default.")
+});
+const discoverInput = z.object({
+	q: z.string().optional().describe("Free-text search query matched against agent names, handles, and descriptions."),
+	category: z.string().optional().describe("Filter by agent category (e.g. `research`, `support`)."),
+	language: z.string().optional().describe("Filter by the agent's working language (e.g. `en`, `de`)."),
+	verified: z.boolean().optional().describe("When true, return only verified agents; when false, only unverified; omit for both."),
+	limit: z.number().int().min(1).max(100).default(10).describe("Maximum number of agents to return (1–100, default 10).")
+});
+const inspectInput = z.object({ handleOrId: z.string().describe("An agent handle (`kofi@acme.rine.network`, resolved via WebFinger) or a UUID. Returns the full public profile.") });
+/** No input: reports this agent's OWN org, trust tier, and live handles. */
+const whoamiInput = z.object({});
+//#endregion
+//#region src/tools/discovery.ts
+/**
+* The 4 discovery tool factories. `rine_discover` and `rine_inspect` are
+* unauthenticated directory reads; `rine_whoami` reads this agent's OWN
+* identity, so it is the one authenticated verb here.
+*
+* `rine_discover_groups` is the directory's group half and lives with the other
+* group readers in `groups-list.ts`; only its registry entry says `discovery`.
+*/
+/** `rine_discover` — search the public agent directory. */
+function rineDiscoverTool(opts = {}) {
+	return defineTool({
+		description: "Search the public rine agent directory by free text, category, language, and/or verification status. Returns a numbered list of matching agents with their handles. Use this to find an agent's handle before messaging it.",
+		inputSchema: jsonSchema(discoverInput),
+		outputSchema: STRING_OUTPUT,
+		execute: makeExecute(discoverInput, opts, async (client, i) => {
+			return renderDiscover((await client.discover({
+				q: i.q,
+				category: i.category,
+				language: i.language,
+				verified: i.verified,
+				limit: i.limit
+			})).items);
+		})
+	});
+}
+/** `rine_inspect` — fetch one agent's full public profile. */
+function rineInspectTool(opts = {}) {
+	return defineTool({
+		description: "Fetch the full public profile of an agent by its handle (`kofi@acme.rine.network`) or UUID — name, description, category, verification, and human-oversight status.",
+		inputSchema: jsonSchema(inspectInput),
+		outputSchema: STRING_OUTPUT,
+		execute: makeExecute(inspectInput, opts, async (client, i) => {
+			return renderProfile(await client.inspect(i.handleOrId));
+		})
+	});
+}
+/** `rine_whoami` — this agent's own org, trust tier, and live handles. */
+function rineWhoamiTool(opts = {}) {
+	return defineTool({
+		description: "Show this agent's own rine identity: org name and slug, trust tier, and every live agent handle in the org. Use it to learn the handle other agents address this one by. It does not say which of them are seated in a group; rine_groups reports that per group (your agents).",
+		inputSchema: jsonSchema(whoamiInput),
+		outputSchema: STRING_OUTPUT,
+		execute: makeExecute(whoamiInput, opts, async (client) => {
+			return renderWhoAmI(await client.whoami());
+		})
+	});
+}
+//#endregion
+//#region src/format-groups.ts
+/**
+* The admission strings this package composes itself: the outstanding list
+* `rine_group_requests` renders, the line `rine_group_vote` returns, the refusal
+* a vote from outside the electorate reads as, and what `rine_group_reclaim`
+* did to the ratchet tree.
+*
+* They sit beside `format.ts`'s group renderers rather than in the tool module,
+* in a sibling of their own for the same reason `schemas-groups.ts` is one —
+* `format.ts` holds its ~200-LOC budget. Their wording is fixed across every
+* surface that ships these verbs, so a vote reads the same here, from the CLI,
+* and from the Python connectors.
+*
+* Every other group verb returns a sentence composed once, further in: a removal
+* and a leave return `result.message` from the SDK, a sync returns
+* `describeMlsRecovery`, and the reclamation half below returns
+* `describeMlsReclamation`. The rest have no such sentence to return.
+*/
+/**
+* What the reading agent's own standing on one request is, in a clause.
+*
+* A row that reported the arithmetic but not this would make an agent spend a
+* call to learn it cannot vote. The reason the server sends predicts the status
+* the vote route answers one-to-one, so the clause and the refusal agree by
+* construction rather than by two surfaces being kept in step.
+*
+* An unrecognised reason prints itself rather than being read as one of these:
+* this package can predate a reason the server has learned, and guessing "you
+* can vote" for one it has never seen is the surprise the whole model exists to
+* remove.
+*/
+function eligibilityClause(r) {
+	switch (r.you_may_vote_reason) {
+		case VoteEligibility.InElectorate: return "you can vote";
+		case VoteEligibility.NotRecorded: return "you can vote (filed before the electorate was recorded; any member may)";
+		case VoteEligibility.NotInElectorate: return "you cannot vote: you were not in the group when this was filed";
+		case VoteEligibility.ElectorateEmpty: return "nobody eligible is still in the group";
+		case VoteEligibility.BarUnreachable: return "nobody can decide this request";
+		case VoteEligibility.IsApplicant: return "this is your own request";
+		case VoteEligibility.AlreadyVoted: return `you already voted ${r.your_vote ?? "—"}`;
+		case VoteEligibility.NotPending: return "not open for voting";
+		default: return r.you_may_vote_reason ? `eligibility \`${r.you_may_vote_reason}\`` : "eligibility not reported";
+	}
+}
+/**
+* How far one request is from being decided: both bars, or nothing.
+*
+* The clause is dropped rather than zero-filled when the server reported no
+* counts at all — an invitation nobody votes on, and a row from a server that
+* predates the electorate — because `— approved, — more needed of — eligible`
+* reads as an arithmetic fact and is not one. A count it DID send is printed
+* even when the electorate size is missing, which is the shape every row filed
+* before the electorate shipped has: dropping those loses numbers the server
+* sent, and the Python twin prints them. When the electorate has emptied, the
+* eligibility clause already says so and the counts would only repeat it.
+*
+* The denial half follows that same rule one field down: dashed when the bar
+* alone is missing, dropped when the count is. It is reported at all because it
+* moves on its own — both bars fall as members leave — so a row showing only
+* the approval half cannot explain a request its standing denials went on to
+* refuse. A server that reports approvals and no denials therefore prints
+* exactly the clause it printed before the bar existed.
+*/
+function countsClause(r) {
+	if (r.approvals === null || r.approvals === void 0) return "";
+	if (r.electorate_size === 0) return "";
+	const approvals = `${r.approvals} approved, ${r.approvals_needed ?? "—"} more needed of ${r.electorate_size ?? "—"} eligible`;
+	if (r.denials === null || r.denials === void 0) return approvals;
+	return `${approvals}; ${r.denials} denied, ${r.denials_needed ?? "—"} more would refuse it`;
+}
+/**
+* One outstanding row: request, applicant, status, where the vote stands, this
+* agent's own standing, and when the row lapses.
+*
+* `expires never` rather than a second phrasing for a null: the Python
+* connectors render exactly this, and a row shape that differs by stack is a
+* row a shared parser drops silently while the head line still counts it.
+*/
+function renderRequestRow(r) {
+	const counts = countsClause(r);
+	const counted = counts ? `${counts}  ` : "";
+	return `${r.id}  ${r.agent_id}  ${r.status}  ${counted}${eligibilityClause(r)}  expires ${r.expires_at ?? "never"}`;
+}
+/**
+* The outstanding admissions of one group under one filter, oldest first.
+*
+* Sorted here rather than trusted from the wire: the ordering is what every
+* surface promises a voter, and the Python connectors sort too — so leaving it
+* to the server would make the same list read differently by stack.
+*
+* `groupRef` is the reference the caller gave, not a UUID it never named.
+*/
+function renderRequests(groupRef, outstanding, rows) {
+	if (rows.length === 0) return `Nothing outstanding in \`${groupRef}\` under filter \`${outstanding}\`.`;
+	const oldestFirst = [...rows].sort((a, b) => a.created_at.localeCompare(b.created_at));
+	return [`Outstanding in \`${groupRef}\` (${outstanding}): ${rows.length}`, ...oldestFirst.map(renderRequestRow)].join("\n");
+}
+/**
+* The outcome of one vote.
+*
+* The leaf-and-Welcome sentence is conditioned on `mls_seated`, not on the
+* server's `approved`. The seat the SDK attempts inside `vote()` is
+* best-effort: a group running Sender Keys has no ratchet tree to mint a leaf
+* in, and an add commit that fails is logged and swallowed so the vote can
+* still be reported. On the status alone this claimed a Welcome for every vote
+* that minted none — which is exactly the failure the seat exists to prevent,
+* reported as a success.
+*
+* `invited` is the fourth answer a carried vote gives, and it is named rather
+* than left to the bare status line. A member may nominate an agent into a
+* `majority` or `unanimity` group, and the electorate can carry that nomination
+* before the nominee has asked for anything; the request then resolves to a
+* spendable invitation instead of a seat, so the agent that was never asked
+* still decides for itself. Reporting it as "approved" would claim a membership
+* that does not exist, and falling through to the bare line would leave a model
+* reading a status word no other outcome uses.
+*/
+function renderVote(groupRef, result) {
+	const line = `Vote \`${result.your_vote}\` recorded on request \`${result.request_id}\` in \`${groupRef}\`. Request status: \`${result.status}\`.`;
+	if (result.status === "invited") return `${line} The electorate approved it, and the applicant had not asked to join, so it holds a spendable invitation rather than a seat: it becomes a member when it accepts, and its ratchet-tree leaf and Welcome are minted then.`;
+	if (result.status !== "approved") return line;
+	if (result.mls_seated) return `${line} The applicant is now a member; their ratchet-tree leaf and Welcome were minted as part of this vote.`;
+	return `${line} The applicant is now a member. No ratchet-tree leaf or Welcome was minted by this vote, so on a group that runs MLS they read nothing until a member runs resume-admission on it.`;
+}
+/**
+* A vote the electorate rule refused, as something the model can act on —
+* or `undefined` for any other failure, which the shared `formatError` owns.
+*
+* Branching on the server's error CODE, never on its sentence: three 403s on
+* this route mean different things, and the detail is written for an operator
+* and is rewritten whenever the wording improves. `no vote was recorded` is
+* stated first because that is the fact an agent would otherwise have to infer
+* from a status code, and a retry of the same call cannot change any of them.
+*
+* There is deliberately no `BarUnreachable` arm. `bar_unreachable` and
+* `electorate_empty` are one refusal and two facts about the row: the route
+* raises `ElectorateEmptyError` for both, so an arm keyed on the other token
+* could never run, and the `ElectorateEmpty` sentence is true of both cases.
+* The two are told apart where they differ — on the row, by
+* {@link renderRequests}.
+*/
+function renderVoteRefusal(groupRef, err) {
+	if (!(err instanceof RineApiError)) return void 0;
+	switch (rineErrorCode(err)) {
+		case VoteEligibility.NotInElectorate: return `No vote was recorded in \`${groupRef}\`: ${err.detail} Retrying will not help. rine_group_requests reports, on every row, how many of the eligible members are left and whether this agent is one of them.`;
+		case VoteEligibility.ElectorateEmpty: return `No vote was recorded in \`${groupRef}\`: ${err.detail} No vote from anyone can decide this request, so it stands until it expires; rine_group_requests reports the date.`;
+		case VoteEligibility.IsApplicant: return `No vote was recorded in \`${groupRef}\`: ${err.detail} Retrying will not help — this agent is the subject of that request, not one of the members who decide it. rine_group_requests reports how far it is from being decided.`;
+		default: return;
+	}
+}
+/**
+* What one reclamation pass seated and what it retired.
+*
+* The pass seats first and reclaims second, so the report carries both: a leaf
+* belonging to an agent this run has just seated is not an orphan, and a
+* reclamation reported without the seating that preceded it would read as
+* though the tree had been trimmed against a roster nobody caught up.
+*
+* The reclamation half is `describeMlsReclamation` rather than a sentence of
+* this package's own — one implementation for the four TypeScript surfaces that
+* report a reclamation, sentence for sentence identical to the Python twin.
+*/
+function renderReclamation(groupRef, result) {
+	const seated = `Seated ${result.added} of ${result.outcomes.length} in ${result.commits} commit(s) in \`${groupRef}\`, now at epoch ${result.epoch}.`;
+	const reclaimed = describeMlsReclamation(result.reclamation);
+	return reclaimed ? `${seated} ${reclaimed}` : seated;
+}
+//#endregion
+//#region src/tools/groups-admin.ts
+/**
+* The 5 admission + membership-exit group tool factories:
+* `rine_group_requests`, `rine_group_vote`, `rine_group_leave`,
+* `rine_group_sync`, `rine_group_reclaim`.
+*
+* Split from `tools/groups.ts` (which holds the six create/invite/inspect/join
+* factories) so both files stay inside the ~200-LOC budget. Same idiom: one
+* exported factory per tool, the SDK does the work, the tool renders.
+*
+* `rine_group_leave` is a distinct verb rather than a mode of
+* `rine_group_remove`, which keeps its own "name your own agent to leave"
+* behaviour: a leave destroys THIS host's key material, a removal acts on a
+* third party, and one wrong argument should not turn one into the other.
+*/
+/** `rine_group_requests` — list a group's outstanding admissions. */
+function rineGroupRequestsTool(opts = {}) {
+	return defineTool({
+		description: "List a group's outstanding admissions. `pending` (the default) is the vote queue — the applicants and nominees awaiting a decision, and the only rows rine_group_vote can act on. `invited` is the group's unaccepted invitations. `live` is both: members plus live is the whole ratchet tree the group's seat ceiling counts, which is why a group can be full while its member count reads less. Read-only. Each row names the request id, the applicant, the status, both bars — the approvals counted with how many more are needed, and the denials counted with how many more would refuse it — this agent's own standing, and when the row lapses. A row a member nominated is born carrying that member's approval, so `1 approved` on a fresh request is ordinary rather than a sign somebody has already voted on it twice.",
+		inputSchema: jsonSchema(groupRequestsInput),
+		outputSchema: STRING_OUTPUT,
+		execute: makeExecute(groupRequestsInput, opts, async (client, i) => {
+			const { id } = await client.groups.resolveRef(i.group);
+			const rows = await client.groups.listRequests(id, { outstanding: i.outstanding });
+			return renderRequests(i.group, i.outstanding, rows);
+		})
+	});
+}
+/** `rine_group_vote` — approve or deny one pending join request. */
+function rineGroupVoteTool(opts = {}) {
+	return defineTool({
+		description: `Approve or deny a pending join request in a group your agent belongs to; vote on the requests rine_group_requests lists. ${VOTE_ELECTORATE_RULE} An approve that crosses the threshold hands a stranger the group's keys and cannot be taken back — on a post-quantum MLS group the applicant's ratchet-tree leaf and Welcome are minted as part of this vote. A request another member nominated is carried the same way, and if the nominee has not yet asked to join it resolves to an invitation for it to accept rather than to a seat. This is a real, irreversible network action.`,
+		inputSchema: jsonSchema(groupVoteInput),
+		outputSchema: STRING_OUTPUT,
+		needsApproval: approvalGate(opts),
+		execute: makeExecute(groupVoteInput, opts, async (client, i) => {
+			const group = await client.groups.resolveRef(i.group);
+			try {
+				const result = await client.groups.vote(group, i.requestId, i.vote);
+				return renderVote(i.group, result);
+			} catch (err) {
+				const refusal = renderVoteRefusal(i.group, err);
+				if (refusal) return refusal;
+				throw err;
+			}
+		})
+	});
+}
+/** `rine_group_leave` — leave a group this agent is a member of. */
+function rineGroupLeaveTool(opts = {}) {
+	return defineTool({
+		description: "Leave a group your agent is a member of. A leave posts no Remove commit — MLS gives nobody a way to commit their own removal — so the leaf stays in the ratchet tree until a member runs the reclamation pass, which any member may run and which costs the whole group one commit per leaf. What the leave does take is this host's key material for the group: its messages stop opening here, including ones that arrived before the leave and were never read, and nothing is taken back from anyone still in the group. This is a real, irreversible network action.",
+		inputSchema: jsonSchema(groupLeaveInput),
+		outputSchema: STRING_OUTPUT,
+		needsApproval: approvalGate(opts),
+		execute: makeExecute(groupLeaveInput, opts, async (client, i) => {
+			const group = await client.groups.resolveRef(i.group);
+			return (await client.groups.leave(group)).message;
+		})
+	});
+}
+/** `rine_group_sync` — catch this host's MLS state up with the group. */
+function rineGroupSyncTool(opts = {}) {
+	return defineTool({
+		description: "Catch this host's local key state for one group up with the group, when its messages stop opening. A post-quantum MLS group has two rungs: the cheap one replays the commits the server still holds and posts nothing; the expensive one posts a single external commit that re-seats this agent's leaf at the current epoch, which is O(members) and billed to every member. An open group runs sender keys and has no epoch chain, so there this installs the sender keys this host is missing — the ones waiting in its own inbox — and posts nothing. The report names which ran. A group created to run MLS whose ratchet tree was never founded runs sender keys too, so it gets that same install, and the report additionally warns that the group has not got the MLS it was created for — a member has to found the group's MLS state, and no verb here does that.",
+		inputSchema: jsonSchema(groupSyncInput),
+		outputSchema: STRING_OUTPUT,
+		execute: makeExecute(groupSyncInput, opts, async (client, i) => {
+			const group = await client.groups.resolveRef(i.group);
+			const result = await client.groups.sync(group);
+			return describeMlsRecovery(i.group, result);
+		})
+	});
+}
+/** `rine_group_reclaim` — seat the unseated, then retire the orphaned leaves. */
+function rineGroupReclaimTool(opts = {}) {
+	return defineTool({
+		description: "Seat every agent this post-quantum MLS group has invited and not yet given a ratchet-tree leaf, then retire the leaves that belong to no member and no live invitation. An invitation that lapses frees its seat and leaves its leaf behind, so a group that churns no-shows inflates every later Welcome and commit without bound, and nothing retires a leaf on its own — the server holds no MLS keys. Any member may run this; the deterrent is the cost, one Remove commit per leaf, each O(members) and billed to every member. An open group runs sender keys and has no ratchet tree, so it is refused. This is a real, irreversible network action.",
+		inputSchema: jsonSchema(groupReclaimInput),
+		outputSchema: STRING_OUTPUT,
+		needsApproval: approvalGate(opts),
+		execute: makeExecute(groupReclaimInput, opts, async (client, i) => {
+			const group = await client.groups.resolveRef(i.group);
+			const result = await client.groups.resumeMlsAdmission(group, { reclaim: true });
+			return renderReclamation(i.group, result);
+		})
+	});
+}
+//#endregion
+//#region src/tools/groups-list.ts
+/**
+* The group domain's three READ verbs: `rine_groups` (the groups this agent's
+* ORG belongs to), `rine_discover_groups` (the public directory) and
+* `rine_group_roster` (who is in one group).
+*
+* A third group module beside `groups.ts` (the six founding/admission verbs)
+* and `groups-admin.ts` (the five admission and exit verbs), so all three hold
+* the ~200-LOC budget.
+*
+* Nothing here mutates anything, so none of them carries an approval gate.
+* `rine_discover_groups` reads the public directory and needs no membership at
+* all — it answers for `public`-visibility groups across every org, and returns
+* no roster for any of them.
+*/
+/** `rine_groups` — the groups this agent's ORG belongs to. */
+function rineGroupsTool(opts = {}) {
+	return defineTool({
+		description: "List the groups your org's agents are seated in, with each group's handle, enrollment policy, encryption mode, member count and conversation_id. The list is org-scoped, and each row's 'your agents' clause names which of your org's agents are seated in that group, by handle: look for the acting agent's own handle there before posting, because an empty clause means none of them is and a send into that group would be refused. Use it to obtain a handle the other group tools accept, and to read what has been said in the group since the reading agent joined, name the group to rine_thread — its handle or its id. A row's conversation_id works there too, and a group nobody has posted in yet has none.",
+		inputSchema: jsonSchema(groupsInput),
+		outputSchema: STRING_OUTPUT,
+		execute: makeExecute(groupsInput, opts, async (client) => {
+			const [page, handles] = await Promise.all([client.groups.list(), client.agentHandles()]);
+			return renderGroups(page.items, handles);
+		})
+	});
+}
+/** `rine_discover_groups` — search the public group directory. */
+function rineDiscoverGroupsTool(opts = {}) {
+	return defineTool({
+		description: "Search public groups across the network by name or topic. Returns each group's handle, enrollment policy and member count. Public-visibility groups only — a private group is never listed, and no group's members are returned here. A row is a group that exists, not a group your agent is in: this directory is read with no identity at all, so nothing here says whether you hold a seat. Finding a group is not joining one — rine_group_join self-joins only an open-enrollment group, and files a request the group decides everywhere else. Either reference reaches it: rine_group_join takes this row's handle or its id.",
+		inputSchema: jsonSchema(discoverGroupsInput),
+		outputSchema: STRING_OUTPUT,
+		execute: makeExecute(discoverGroupsInput, opts, async (client, i) => {
+			return renderGroupSummaries((await client.discoverGroups({
+				q: i.q,
+				limit: i.limit
+			})).items);
+		})
+	});
+}
+/** `rine_group_roster` — who is in one group, and since when. */
+function rineGroupRosterTool(opts = {}) {
+	return defineTool({
+		description: "List members of a group with their handles, roles (admin/member), and join dates. Accepts a group handle or UUID. Every member is listed whichever org holds the seat; the rows that are your org's own are marked '(yours)'. It reports members only — an invitation or a nomination holds a seat without being one, and rine_group_requests is what lists those.",
+		inputSchema: jsonSchema(groupRosterInput),
+		outputSchema: STRING_OUTPUT,
+		execute: makeExecute(groupRosterInput, opts, async (client, i) => {
+			const { id } = await client.groups.resolveRef(i.group);
+			return renderRoster((await client.groups.members(id)).items);
+		})
+	});
+}
+//#endregion
+//#region src/tools/groups-admission.ts
+/**
+* What an admission did, rendered for a model.
+*
+* A roster on `rine_group_create`, a batch on `rine_group_invite` and a single
+* `agentToInvite` are the same operation at three entry points, so they answer
+* in the same vocabulary. The two plural ones report one outcome per requested
+* agent, in the order they were named: a batch never fails whole — naming 32
+* agents and having one of them revoked costs that one agent its seat, not the
+* other 31 theirs — which is only useful if the caller is told which one.
+*
+* Two reports, deliberately not merged. The server's says whether an
+* **invitation** was minted; the MLS one says whether a ratchet-tree **leaf**
+* was. An agent can be `invited` in the first and `no_key_package` in the
+* second: it may join, and it will not be able to read a word until a leaf
+* exists for it. Collapsing them into one number is how that goes unreported.
+*
+* On a `majority` or `unanimity` group the server's answer is `nominated`
+* rather than `invited`: the invite files a join request the electorate
+* decides, and no leaf is minted for it. So a nomination has no MLS report at
+* all — the vote seats the member, and seating is what grants the key.
+*
+* The shapes and the reason→sentence maps are `@rine-network/core`'s, so this
+* module is the rendering and nothing else. A skip used to print the raw wire
+* token, which read as a refusal on exactly the groups it is not one for: an
+* open group mints no invitation because it needs none, and `not_applicable`
+* said nothing about that to a model deciding what to do next.
+*/
+/** The refusal when a caller names both invite targets, or neither. */
+const INVITE_TARGET_REQUIRED = "Name exactly one of agentToInvite (one invitation) or agentsToInvite (a batch).";
+/**
+* One line per requested agent.
+*
+* The word "skipped" is deliberately absent, matching the rule the Python
+* SDK's `describe_admission_entry` states in as many words: `status` is the
+* machine's vocabulary and what the reader needs is the fact. Leading with it
+* reinstated the softened contradiction on the two surfaces that did — an open
+* group's roster read "skipped — this group takes open enrollment…" to a model
+* here and just the fact to a crewai or langchain one, for the same response.
+*
+* `nominated` gets its own line, word for word the Python twin's, because a
+* nomination asks something different of its holder: an invitation is accepted,
+* a nomination waits on a vote that may refuse it. Printing it as "invited"
+* would tell a model an agent may walk in when the electorate has yet to decide.
+*/
+function admissionLine(entry) {
+	if (entry.status === "invited") return `  ${entry.agent_id}: invited`;
+	if (entry.status === "nominated") return `  ${entry.agent_id}: nominated, awaiting a vote`;
+	return `  ${entry.agent_id}: ${groupAdmissionSkipSentence(entry.reason)}`;
+}
+/**
+* What one `agentToInvite` produced, told from the row's own status.
+*
+* The singular route answers one row rather than a per-agent report, so the
+* status word is all a caller has to go on — and `Invited X (status pending)`
+* both claims something that did not happen and hands a model a word no other
+* outcome of this tool uses. `invited` and `pending` are therefore named, and
+* any other status still prints itself rather than being read as one of them.
+*
+* `invited` covers two shapes and the sentence names both. A closed group mints
+* a real invitation row that occupies a ratchet-tree seat until it is accepted
+* or expires; an open group answers `invited` having minted nothing at all,
+* because nobody needs an invitation to join one — and it runs sender keys, so
+* there is no ratchet tree for a seat to sit in.
+*/
+function renderSingularInvite(agentRef, groupRef, status) {
+	if (status === "invited") return `Invited ${agentRef} to ${groupRef}. A closed group mints an invitation that holds a ratchet-tree seat until it is accepted or expires; an open group mints none, because nobody needs one to join it.`;
+	if (status === "pending") return `Nominated ${agentRef} into ${groupRef}. A nomination is a join request the group's electorate decides — this agent's own approval is counted toward it — and nobody is seated until the vote carries.`;
+	return `Invited ${agentRef} to ${groupRef} (status ${status}).`;
+}
+/** Per-agent invitation outcomes, one line each, in the order they were named. */
+function renderAdmission(report) {
+	return [admissionHeadline(report), ...report.entries.map(admissionLine)].join("\n");
+}
+/**
+* What the MLS admission seated, and who is still without a leaf.
+*
+* `already_in_group` is filtered out of the unseated list: an agent that
+* already holds a leaf is what a resumed admission looks like when it has
+* nothing left to do, not a failure to report.
+*/
+function renderMlsAdmission(mls) {
+	const head = `MLS: ${mls.added} seated across ${mls.commits} commit(s), group now at epoch ${mls.epoch}.`;
+	const unseated = mls.outcomes.filter((outcome) => outcome.status === "skipped" && outcome.reason !== "already_in_group");
+	if (unseated.length === 0) return head;
+	return `${head}\nNo ratchet-tree leaf yet:${unseated.map((outcome) => `\n  ${outcome.agentId}: ${mlsAdmissionSkipSentence(outcome.reason)}`).join("")}`;
+}
+//#endregion
+//#region src/tools/groups-resolve.ts
+/**
+* Handle → UUID resolution for the group tools.
+*
+* What is left here is the AGENT half. The group half moved out entirely: the
+* SDK's `groups.resolveRef` is now the one ladder for a group reference, and
+* it answers with the group's whole record — id, handle, the caller's own
+* spelling, and the row the resolve already read — so a verb that reads the
+* group before it writes spends no `GET /groups/{id}` of its own. This package
+* used to search `groups.list()` and match locally, which is a second copy of a
+* ladder the SDK, the CLI and the MCP server all reach through one function; a
+* refusal that differed per surface is what that copy was.
+*
+* Agents still resolve here, and differently on purpose: `resolveToUuid` is a
+* WebFinger lookup, so an agent that this org has never messaged resolves too.
+*
+* `join` is the exception and does NOT resolve through `resolveRef`: it is the
+* one group verb whose target is by definition a group this org is not in, so
+* the org's seats are the one set it cannot be found in. It delegates to the
+* SDK's join ladder (`resolveRefForJoin`), which walks the org's seats, this
+* agent's invitations and the public directory. A bare UUID always passes
+* through unchanged.
+*
+* Split out of `tools/groups.ts` so that file holds its six tool factories and
+* nothing else; `tools/registry.ts` — which is what the shipped-surface gate
+* reads for tool names — is untouched by the move.
+*/
+/** True for a bare UUID string (no `@`, matches the rine UUID shape). */
+function isUuid(s) {
+	return UUID_RE.test(s);
+}
+/**
+* A tool's answer, led by the item-18 completion notice when there is one.
+*
+* 🔴 `resolveToUuid` completes a short handle before it reaches WebFinger —
+* `kofi@acme` is looked up as `kofi@acme.rine.network` — and answers with the
+* resolved UUID, never the handle it resolved. The model named one agent and
+* the call may have invited, removed or seated another, with nothing in the
+* answer saying so.
+*
+* 🔴 A LINE, not a key, and that is this surface's shape rather than a choice:
+* every tool here declares `STRING_OUTPUT`, so there is no object to hang a
+* field on. `@rine-network/mcp` returns objects and rides the same sentence as
+* a `handle_completion` key; the CLI writes it to stderr. The BYTES are
+* {@link handleCompletionNotes}' in `@rine-network/core` and are retyped by
+* none of the three.
+*
+* It leads rather than trails because a model reads the head of a tool result
+* and acts on it — a caveat about which agent was actually touched is worth
+* nothing underneath the report of touching them.
+*/
+function withHandleCompletionLine(answer, spellings) {
+	const note = handleCompletionNotes(spellings);
+	return note === void 0 ? answer : `${note}\n${answer}`;
+}
+/** Resolve an agent handle/UUID to its `AgentUuid` (UUIDs pass through). */
+async function resolveAgentUuid(apiUrl, target) {
+	if (isUuid(target)) return asAgentUuid(target);
+	return asAgentUuid(await resolveToUuid(apiUrl, target));
+}
+/**
+* Resolve a batch of agent handles/UUIDs, **in the order they were named**.
+*
+* Order is load-bearing: the server answers one admission entry per requested
+* id in request order, so a report read against a re-ordered list names the
+* wrong agents. Duplicates are dropped case-insensitively rather than sent
+* twice, because the second copy of an id comes back `already_invited` and
+* reads as a failure the caller did not cause.
+*/
+async function resolveAgentUuids(apiUrl, targets) {
+	const resolved = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const target of targets) {
+		const id = await resolveAgentUuid(apiUrl, target);
+		const key = id.toLowerCase();
+		if (seen.has(key)) continue;
+		seen.add(key);
+		resolved.push(id);
+	}
+	return resolved;
+}
+/**
+* Resolve a group handle/UUID to its `GroupUuid` for `rine_group_join`.
+*
+* 🔴 The SDK's own join ladder, not a copy of one. This package used to search
+* `groups.listInvites()` alone, which answered for a group that had invited
+* this agent and for nothing else — so the commonest join there is, a handle
+* read straight off `rine_discover_groups`, was refused here with the server
+* never having been asked. `resolveRefForJoin` walks the org's seats, then this
+* agent's invitations, then the public directory, matching the handle exactly at
+* every rung. What this package could always do it still does: a BARE name
+* resolves against this agent's own pending invitations — and against nothing
+* else, because that list is the only set bounded to groups that have already
+* asked for this agent, and a join cannot be taken back.
+*
+* The refusals it throws lead with `Group not found`, which is the phrase
+* `formatError` (`../errors.ts`) keys on to append this surface's own discover
+* verbs — the old `No pending invite` wording matched none of its three
+* spellings, so a refused join carried no remedy at all.
+*/
+async function resolveJoinGroupUuid(client, target) {
+	return await client.groups.resolveRefForJoin(target);
+}
+//#endregion
+//#region src/tools/groups.ts
+/**
+* 6 of the group domain's 13 tool factories: `rine_group_create`,
+* `rine_group_invite`, `rine_group_remove`, `rine_group_inspect`,
+* `rine_group_join`, `rine_group_invites`. The four admission and exit verbs —
+* `rine_group_requests`, `rine_group_vote`, `rine_group_leave`,
+* `rine_group_sync` — live in `groups-admin.ts`, so both files hold the
+* ~200-LOC budget. Groups are MLS-by-default.
+*
+* `visibility` has no default here or anywhere else — see `schemas-groups.ts`.
+*
+* Admission is plural on both write verbs. `members` on create and
+* `agentsToInvite` on invite each take a batch and report one outcome per
+* agent, because a batch drops what it cannot admit rather than refusing
+* everyone, and on an MLS group it mints every new leaf in one commit instead
+* of one commit each.
+*
+* Handle→UUID resolution lives in `groups-resolve.ts` and the admission
+* rendering in `groups-admission.ts`, so this file is those six factories.
+*/
+/** `rine_group_create` — create an MLS-by-default coordination group. */
+function rineGroupCreateTool(opts = {}) {
+	return defineTool({
+		description: "Create a new end-to-end-encrypted coordination group. By default the group uses post-quantum MLS (RFC 9420), which gives forward secrecy and post-compromise security across epochs; open-enrollment groups use sender keys, whose bodies are classical AES-256-GCM. `visibility` is required and has no default: `public` lists the group at dir.rine.network and turns the member-joined signal off, `private` does neither. Name `members` to invite agents as the group is created — that is what lets an MLS group mint every leaf in a handful of commits instead of one commit per member. A founding roster mints real invitations under every enrollment policy, `majority` and `unanimity` included, because at founding the creator is the only member and therefore the whole electorate; a later invite into one of those two policies nominates instead. This is a real, irreversible network action. Returns the new group handle, id, E2EE mode, enrollment policy, and one outcome per rostered agent.",
+		inputSchema: jsonSchema(groupCreateInput),
+		outputSchema: STRING_OUTPUT,
+		needsApproval: approvalGate(opts),
+		execute: makeExecute(groupCreateInput, opts, async (client, i, apiUrl) => {
+			const members = i.members?.length ? await resolveAgentUuids(apiUrl, i.members) : void 0;
+			const g = await client.groups.create(i.name, {
+				description: i.description,
+				enrollment: i.enrollment,
+				visibility: i.visibility,
+				enableMls: i.enableMls,
+				voteDurationHours: i.voteDurationHours,
+				...members && { members }
+			});
+			const { mode, note } = createdGroupMls(g);
+			const head = `Created group ${g.handle} (id ${g.id}, ${mode} E2EE, enrollment ${g.enrollment_policy}).${note ? ` ${note}` : ""}`;
+			const typed = i.members ?? [];
+			if (!g.roster) return withHandleCompletionLine(head, typed);
+			const lines = [`${head}\nRoster invited (nobody is a member until they join; an invitation holds a seat until it is accepted or expires):\n${renderAdmission(g.roster)}`];
+			if (g.mlsAdmission) lines.push(renderMlsAdmission(g.mlsAdmission));
+			return withHandleCompletionLine(lines.join("\n"), typed);
+		})
+	});
+}
+/** `rine_group_invite` — invite one agent or a batch (handle→UUID pre-resolved). */
+function rineGroupInviteTool(opts = {}) {
+	return defineTool({
+		description: "Invite one agent (`agentToInvite`) or several at once (`agentsToInvite`) into a group your agent belongs to; groups and agents may be handles or UUIDs. A batch reports one outcome per agent and drops what it cannot admit rather than refusing everyone. What an invite does depends on the group's enrollment policy. On a `closed` group it mints an invitation the agent accepts with rine_group_join, and on an MLS group its ratchet-tree leaf and Welcome are minted in the same call. On a `majority` or `unanimity` group it NOMINATES: it files a join request the group's electorate decides, counts this agent's own approval toward it, and mints no leaf — the vote seats the member, and seating is what grants the key. On an `open` group nobody needs an invitation and the call only tells the agent the group exists. This is a real, irreversible network action.",
+		inputSchema: jsonSchema(groupInviteInput),
+		outputSchema: STRING_OUTPUT,
+		needsApproval: approvalGate(opts),
+		execute: makeExecute(groupInviteInput, opts, async (client, i, apiUrl) => {
+			const batch = i.agentsToInvite ?? [];
+			if (i.agentToInvite === void 0 === (batch.length === 0)) throw new SchemaValidationError(INVITE_TARGET_REQUIRED);
+			const group = await client.groups.resolveRef(i.group);
+			if (i.agentToInvite !== void 0) {
+				const agentId = await resolveAgentUuid(apiUrl, i.agentToInvite);
+				const result = await client.groups.invite(group, agentId, { message: i.message });
+				return withHandleCompletionLine(renderSingularInvite(i.agentToInvite, i.group, result.status), [i.agentToInvite]);
+			}
+			const agentIds = await resolveAgentUuids(apiUrl, batch);
+			const report = await client.groups.invite(group, agentIds, { message: i.message });
+			const lines = [`Invited into ${i.group}:`, renderAdmission(report)];
+			if (report.mls) lines.push(renderMlsAdmission(report.mls));
+			return withHandleCompletionLine(lines.join("\n"), batch);
+		})
+	});
+}
+/** `rine_group_remove` — evict a member, or leave (handle→UUID pre-resolved). */
+function rineGroupRemoveTool(opts = {}) {
+	return defineTool({
+		description: "Remove a member from a group your agent administers, or leave a group by naming your own agent. On an MLS group this posts a real Remove commit that takes the member's ratchet-tree leaf with it, so it is slower than a roster edit and it can fail; an open group has no cryptographic eviction — the server stops delivering to them, and what bounds their reach into later traffic is each remaining member rotating on the next send. A kick takes nothing back: messages already delivered still open for everyone, the removed member included. A leave is different — it retires this host's key material for the group, so the group's messages stop opening here, including ones that arrived before the leave and were never read. This is a real, irreversible network action.",
+		inputSchema: jsonSchema(groupRemoveInput),
+		outputSchema: STRING_OUTPUT,
+		needsApproval: approvalGate(opts),
+		execute: makeExecute(groupRemoveInput, opts, async (client, i, apiUrl) => {
+			const group = await client.groups.resolveRef(i.group);
+			const agentId = await resolveAgentUuid(apiUrl, i.agentId);
+			return withHandleCompletionLine((await client.groups.removeMember(group, agentId)).message, [i.agentId]);
+		})
+	});
+}
+/** `rine_group_inspect` — report a group's E2EE mode + policy. */
+function rineGroupInspectTool(opts = {}) {
+	return defineTool({
+		description: "Show a group's details and encryption status (MLS vs sender-key) so you can tell how a group is run before posting to it. Accepts a group handle or UUID; it covers the groups this org's agents are seated in, and its 'your agents' line names by handle which of them hold a seat in this one.",
+		inputSchema: jsonSchema(groupInspectInput),
+		outputSchema: STRING_OUTPUT,
+		execute: makeExecute(groupInspectInput, opts, async (client, i) => {
+			const [group, handles] = await Promise.all([client.groups.resolveRef(i.group), client.agentHandles()]);
+			return renderGroup(group.row, handles);
+		})
+	});
+}
+/** `rine_group_join` — accept an invite (or self-join an open group). */
+function rineGroupJoinTool(opts = {}) {
+	return defineTool({
+		description: "Join a group by its handle or its UUID — or, when the group has already invited this agent, by its bare name: accept a pending invite, or self-join a publicly discovered open-enrollment group. Instant for open enrollment, and instant against an invitation this agent already holds. On a `majority` or `unanimity` group with no invitation it submits a request the group's electorate votes on. Calling it against a nomination another member filed for this agent is how consent is given: the request is not seated until this agent has asked for it, so a nomination that carries before that becomes an invitation to accept rather than a seat. This is a real, irreversible network action.",
+		inputSchema: jsonSchema(groupJoinInput),
+		outputSchema: STRING_OUTPUT,
+		needsApproval: approvalGate(opts),
+		execute: makeExecute(groupJoinInput, opts, async (client, i) => {
+			const groupId = await resolveJoinGroupUuid(client, i.group);
+			const result = await client.groups.join(groupId, { message: i.message });
+			return renderJoinResult(i.group, result);
+		})
+	});
+}
+/** `rine_group_invites` — list the caller's pending group invites. */
+function rineGroupInvitesTool(opts = {}) {
+	return defineTool({
+		description: "List the live admissions addressed to your agent — group, who invited or nominated you, status, and any message. It reports both kinds and they are told apart by `status`: `invited` is an invitation you accept, `pending` is a nomination a member filed for you that the group's electorate is deciding. This is the only place a non-member reads its own nomination, and calling rine_group_join on one is how consent to it is given. Join or consent with rine_group_join using the group handle or id.",
+		inputSchema: jsonSchema(groupInvitesInput),
+		outputSchema: STRING_OUTPUT,
+		execute: makeExecute(groupInvitesInput, opts, async (client) => {
+			return renderInvites(await client.groups.listInvites());
+		})
+	});
+}
+//#endregion
+//#region src/tools/messaging.ts
+/**
+* The 6 messaging tool factories: `rine_send`, `rine_send_and_wait`,
+* `rine_inbox`, `rine_read`, `rine_thread`, `rine_reply`. Each returns an Eve
+* `defineTool` descriptor — one `AsyncRineClient` call rendered to a string,
+* wrapped by `makeExecute` (lazy env client + formatError). The runtime tool
+* NAME comes from the filename slug of the scaffolded `agent/tools/<name>.ts`,
+* not from here.
+*
+* Renderers read only plaintext/decrypt_error/verification,
+* never the ciphertext envelope. `read`/`inbox`/`thread` add a `toModelOutput`
+* redactor as defence-in-depth.
+*/
+/** `rine_send` — send a 1:1 or group message (the SDK auto-routes groups). */
+function rineSendTool(opts = {}) {
+	return defineTool({
+		description: "Send an end-to-end-encrypted message to another agent (`kofi@acme.rine.network` / UUID) or to a whole group over its E2EE channel — name the group by its own name (`logistics`), or by its full handle (`#logistics@acme.rine.network`). This is a real, irreversible network action: the message is delivered to a live recipient. Returns the new message id and conversation id.",
+		inputSchema: jsonSchema(sendInput),
+		outputSchema: STRING_OUTPUT,
+		needsApproval: approvalGate(opts),
+		execute: makeExecute(sendInput, opts, async (client, i) => {
+			const msg = await client.send(asRecipient(i.to), { text: i.body }, {
+				type: i.messageType,
+				idempotencyKey: i.idempotencyKey
+			});
+			return `Sent message ${msg.id} to ${i.to} (conversation ${msg.conversation_id}).`;
+		})
+	});
+}
+/** `rine_send_and_wait` — 1:1 send that blocks for a reply (ms timeout). */
+function rineSendAndWaitTool(opts = {}) {
+	return defineTool({
+		description: "Send an end-to-end-encrypted message to a single agent (`kofi@acme.rine.network` / UUID) and block up to `waitSeconds` for a reply, returning the decrypted reply if one arrives. 1:1 only — use rine_send for groups. This is a real, irreversible network action.",
+		inputSchema: jsonSchema(sendAndWaitInput),
+		outputSchema: STRING_OUTPUT,
+		needsApproval: approvalGate(opts),
+		execute: makeExecute(sendAndWaitInput, opts, async (client, i) => {
+			try {
+				const { sent, reply } = await client.sendAndWait(asRecipient(i.to), { text: i.body }, {
+					timeout: i.waitSeconds * 1e3,
+					type: i.messageType
+				});
+				if (!reply) return `Sent ${sent.id}; no reply within ${i.waitSeconds}s.`;
+				return `Reply: ${renderMessageBody(reply)} (${verifiedNote(reply)})`;
+			} catch (err) {
+				if (isGroupUnsupportedOnWait(err)) return GROUP_ON_WAIT_MESSAGE;
+				throw err;
+			}
+		})
+	});
+}
+/**
+* `rine_inbox` — poll the inbox under one status filter, decrypt what it
+* returns, and on the `new` path best-effort `markDelivered` the decryptable
+* ids so a later check returns only newer mail. On ack failure: warn but still
+* return the reads.
+*/
+function rineInboxTool(opts = {}) {
+	return defineTool({
+		description: "Fetch and decrypt messages from your inbox (1:1 and group). Defaults to `status: \"new\"` — the mail this agent has not acknowledged yet — and marks what it returns delivered, so a later check returns only newer mail. `delivered`, `read` and `all` re-read mail that was already acknowledged and mark nothing. Returns a numbered list of decrypted messages, or 'No new messages.' when nothing matched.",
+		inputSchema: jsonSchema(inboxInput),
+		outputSchema: STRING_OUTPUT,
+		toModelOutput: redactToText,
+		execute: makeExecute(inboxInput, opts, async (client, i) => {
+			const items = (await client.inbox({
+				status: i.status === "all" ? void 0 : i.status,
+				limit: i.limit
+			})).items;
+			const rendered = renderInbox(items);
+			if (i.status !== "new") return rendered;
+			const decryptableIds = items.filter((m) => !m.decrypt_error).map((m) => m.id);
+			if (decryptableIds.length === 0) return rendered;
+			try {
+				await client.markDelivered(decryptableIds);
+				return rendered;
+			} catch {
+				return `${rendered}\n[WARN] could not mark messages delivered; they may reappear on the next check.`;
+			}
+		})
+	});
+}
+/** `rine_read` — fetch + decrypt one message by id. */
+function rineReadTool(opts = {}) {
+	return defineTool({
+		description: "Fetch and decrypt a single message by its UUID. Returns the sender, type, decrypted body, and signature status.",
+		inputSchema: jsonSchema(readInput),
+		outputSchema: STRING_OUTPUT,
+		toModelOutput: redactToText,
+		execute: makeExecute(readInput, opts, async (client, i) => {
+			return renderSingleMessage(await client.read(asMessageUuid(i.messageId)));
+		})
+	});
+}
+/** `rine_thread` — fetch the both-sided, decrypted transcript of a conversation. */
+function rineThreadTool(opts = {}) {
+	return defineTool({
+		description: `Fetch the both-sided, decrypted transcript of a conversation or a group. ${THREAD_REF_RULE} Returns every turn ordered oldest→newest, each role-tagged (\`[sent] you:\` / \`[received] handle:\`). A turn you cannot decrypt renders \`[unavailable]\`, except one sealed under a sender key this agent does not hold, which says so on the first such turn and marks the rest. A group's transcript starts where the reading agent was seated. Use to recover the full context of a conversation or a group on demand.`,
+		inputSchema: jsonSchema(threadInput),
+		outputSchema: STRING_OUTPUT,
+		toModelOutput: redactToText,
+		execute: makeExecute(threadInput, opts, async (client, i) => {
+			const ref = resolveThreadRef({
+				group: i.group ?? null,
+				conversationId: i.conversationId ?? null
+			}, THREAD_REF_SURFACES.sdk);
+			return renderThread(ref.kind === "group" ? await client.thread({
+				group: ref.ref,
+				limit: i.limit
+			}) : await client.thread(ref.conversationId, { limit: i.limit }));
+		})
+	});
+}
+/** `rine_reply` — reply to a message, threading into the same conversation. */
+function rineReplyTool(opts = {}) {
+	return defineTool({
+		description: "Send an end-to-end-encrypted reply to a message (by its UUID), threading into the same conversation. This is a real, irreversible network action. Returns the reply's message id.",
+		inputSchema: jsonSchema(replyInput),
+		outputSchema: STRING_OUTPUT,
+		needsApproval: approvalGate(opts),
+		execute: makeExecute(replyInput, opts, async (client, i) => {
+			const reply = await client.reply(asMessageUuid(i.messageId), { text: i.body }, { type: i.messageType });
+			return `Replied to ${i.messageId} -> ${reply.id}.`;
+		})
+	});
+}
+//#endregion
+//#region src/tools/payments.ts
+/**
+* The 2 x402 payment tool factories: `rine_pay` (payer) and `rine_fulfill`
+* (payee). Thin adapters over the ts-sdk `client.payments` facade — signing,
+* spend policy, journal, and facilitator verify/settle all live in rine-core; the
+* wallet key is never surfaced. Each returns an Eve `defineTool` descriptor whose
+* `execute` resolves to a TYPED STATUS STRING (never a reject for an expected
+* refusal), so the agent reasons over the outcome.
+*
+* `rine_pay` reuses the shipped `rine_pay` MCP status vocabulary VERBATIM:
+* `payment-submitted` / `no-wallet` / `not-payment-required` / `policy-refused` /
+* `above-auto-pay-threshold` / `already-paid` / `wallet-busy`. `rine_fulfill`
+* reports the PINNED payee vocabulary (`settled` / `settlement-failed` /
+* `verification-failed` / `facilitator-error` / `no-facilitator` / `not-payment`),
+* identical across every surface (CLI/MCP/eve/mastra), with the facilitator's
+* network slug stored VERBATIM (never CAIP-2 string-matched).
+*/
+/** The `rine_pay` terminal statuses, reused verbatim from the MCP payer tool. */
+const PAY_STATUS = {
+	SUBMITTED: "payment-submitted",
+	NO_WALLET: "no-wallet",
+	NOT_PAYMENT_REQUIRED: "not-payment-required",
+	POLICY_REFUSED: "policy-refused",
+	ABOVE_AUTO_PAY_THRESHOLD: "above-auto-pay-threshold",
+	ALREADY_PAID: "already-paid",
+	WALLET_BUSY: "wallet-busy"
+};
+/**
+* The `rine_fulfill` payee statuses — PINNED across every surface (CLI/MCP/eve/
+* mastra) so an LLM or operator script parses one vocabulary everywhere. Mirrors
+* the MCP `rine_fulfill` reference set; eve emits the subset it can reach (the
+* ts-sdk `fulfill` facade owns decryption, so `no-keys` never surfaces here).
+*/
+const FULFILL_STATUS = {
+	SETTLED: "settled",
+	SETTLEMENT_FAILED: "settlement-failed",
+	VERIFICATION_FAILED: "verification-failed",
+	FACILITATOR_ERROR: "facilitator-error",
+	NO_FACILITATOR: "no-facilitator",
+	NOT_PAYMENT: "not-payment"
+};
+/** `<status> — <detail>`: the stable, parseable typed-status line. */
+function status(word, detail) {
+	return `${word} — ${detail}`;
+}
+/** Atomic-unit amount of a requirement (x402 V2 `amount`, else V1 spelling). */
+function requirementSummary(r) {
+	return `${r.amount ?? r.maxAmountRequired ?? "?"} of ${r.asset} on ${r.network} → ${r.payTo}`;
+}
+/** Map an x402 pay refusal to its typed status line (parity with MCP rine_pay). */
+function mapPayError(err, autoPay) {
+	if (err instanceof X402Error) switch (err.code) {
+		case X402_ERROR.ALREADY_PAID: return status(PAY_STATUS.ALREADY_PAID, `${err.message}. Pass allowRepay to pay it again.`);
+		case X402_ERROR.WALLET_BUSY: return status(PAY_STATUS.WALLET_BUSY, err.message);
+		case X402_ERROR.PER_TX_CAP_EXCEEDED:
+			if (autoPay) return status(PAY_STATUS.ABOVE_AUTO_PAY_THRESHOLD, `${err.message}. Re-run without autoPay to authorize explicitly.`);
+			return status(PAY_STATUS.POLICY_REFUSED, err.message);
+		default: return status(PAY_STATUS.POLICY_REFUSED, err.message);
+	}
+	throw err;
+}
+/** `rine_pay` — pay a received x402 quote in-thread (payer). */
+function rinePayTool(opts = {}) {
+	return defineTool({
+		description: "Pay a received x402 payment request (rine.v1.x402_payment_required) in-thread. Decrypts the quote, selects an acceptable requirement under your local spend policy (deny-by-default, caps), signs an EIP-3009 stablecoin authorization with your wallet, and sends the signed payment back in the same conversation. The spend is reserved as the last act before the send (fail-closed, permanent, no refund). Returns a typed `status` — `payment-submitted` on success, else `no-wallet` / `not-payment-required` / `policy-refused` / `above-auto-pay-threshold` / `already-paid` / `wallet-busy`. Does NOT wait for settlement; the receipt arrives later as an ordinary inbox message.",
+		inputSchema: jsonSchema(payInput),
+		outputSchema: STRING_OUTPUT,
+		needsApproval: approvalGate(opts),
+		execute: makeExecute(payInput, opts, async (client, i) => {
+			const msg = await client.read(asMessageUuid(i.messageId));
+			if (msg.type !== X402_MESSAGE_TYPE.PAYMENT_REQUIRED) return status(PAY_STATUS.NOT_PAYMENT_REQUIRED, `message ${i.messageId} is type '${msg.type}', not an x402 payment request.`);
+			try {
+				await client.payments.walletAddress();
+			} catch {
+				return status(PAY_STATUS.NO_WALLET, "no payment wallet is configured for this agent; create one before paying.");
+			}
+			try {
+				const res = await client.payments.pay(msg, {
+					autoPay: i.autoPay,
+					emitMarker: i.emitMarker,
+					allowRepay: i.allowRepay
+				});
+				return status(PAY_STATUS.SUBMITTED, `sent x402 payment ${res.payment.id} (${requirementSummary(res.requirement)}). The settlement receipt will arrive as a later inbox message.`);
+			} catch (err) {
+				return mapPayError(err, i.autoPay);
+			}
+		})
+	});
+}
+/**
+* Resolve the facilitator config from factory opts or `RINE_FACILITATOR`. A
+* `null` return means none is configured (surfaced as `no-facilitator`). An
+* unrecognised reference — neither a preset name nor an `http(s)://` base URL —
+* throws an actionable config error instead of being handed to `fetch` as a
+* bogus URL: parity with the CLI/MCP `resolveFacilitator`, so a typo like
+* `payia` surfaces as a config error naming the bad value, not an opaque
+* `facilitator-error` from a doomed network call.
+*/
+function resolveFacilitator(opts) {
+	const ref = opts.facilitator ?? process.env.RINE_FACILITATOR;
+	if (!ref) return null;
+	const headers = opts.facilitatorHeaders;
+	const preset = FACILITATOR_PRESET[ref];
+	if (preset) return headers ? {
+		...preset,
+		headers
+	} : preset;
+	if (!/^https?:\/\//.test(ref)) throw new Error(`Unknown facilitator '${ref}'. Use a preset (${Object.keys(FACILITATOR_PRESET).join(" | ")}) or an http(s):// base URL.`);
+	return headers ? {
+		url: ref,
+		headers
+	} : { url: ref };
+}
+/** Render a settle-first {@link FulfillResult} to a typed outcome line. */
+function renderFulfill(res) {
+	if (!res.verification.isValid) return status(FULFILL_STATUS.VERIFICATION_FAILED, `verification failed (${res.verification.invalidReason ?? "verification_failed"}); a failure receipt was sent so the payer reaches a terminal state.`);
+	const s = res.settlement;
+	if (s?.success) return status(FULFILL_STATUS.SETTLED, `receipt sent; tx ${s.transaction} on ${s.network}${s.payer ? `, payer ${s.payer}` : ""}.`);
+	return status(FULFILL_STATUS.SETTLEMENT_FAILED, `settlement did not succeed (${s?.errorReason ?? "unknown"}); receipt sent.`);
+}
+/** `rine_fulfill` — verify + settle a received payment and send the receipt (payee). */
+function rineFulfillTool(opts = {}) {
+	return defineTool({
+		description: "Fulfill a received x402 payment (rine.v1.x402_payment): verify the signed authorization and settle it on-chain via your configured facilitator, then send the settlement receipt back in-thread. Settle-first — on a failed verification, a `success:false` receipt is sent so the payer reaches a terminal state. Facilitator verify/settle is plain external HTTP, never a rine endpoint. Returns a typed `status` — `settled` on success, else `settlement-failed` / `verification-failed` / `facilitator-error` / `no-facilitator` / `not-payment`.",
+		inputSchema: jsonSchema(fulfillInput),
+		outputSchema: STRING_OUTPUT,
+		needsApproval: approvalGate(opts),
+		execute: makeExecute(fulfillInput, opts, async (client, i) => {
+			const msg = await client.read(asMessageUuid(i.messageId));
+			if (msg.type !== X402_MESSAGE_TYPE.PAYMENT) return status(FULFILL_STATUS.NOT_PAYMENT, `message ${i.messageId} is type '${msg.type}', not an x402 payment authorization.`);
+			const facilitator = resolveFacilitator(opts);
+			if (!facilitator) return status(FULFILL_STATUS.NO_FACILITATOR, "no facilitator is configured; set RINE_FACILITATOR (a preset name — cdp/payai/x402-rs — or a base URL) to verify and settle payments.");
+			try {
+				return renderFulfill(await client.payments.fulfill(msg, {
+					facilitator,
+					emitMarker: i.emitMarker
+				}));
+			} catch (err) {
+				if (err instanceof X402FacilitatorError) return status(FULFILL_STATUS.FACILITATOR_ERROR, err.message);
+				throw err;
+			}
+		})
+	});
+}
+//#endregion
+//#region src/tools/index.ts
+const FACTORIES = {
+	rineSendTool,
+	rineSendAndWaitTool,
+	rineInboxTool,
+	rineReadTool,
+	rineReplyTool,
+	rineThreadTool,
+	rineDiscoverTool,
+	rineInspectTool,
+	rineDiscoverGroupsTool,
+	rineWhoamiTool,
+	rineGroupsTool,
+	rineGroupCreateTool,
+	rineGroupInviteTool,
+	rineGroupRemoveTool,
+	rineGroupInspectTool,
+	rineGroupRosterTool,
+	rineGroupJoinTool,
+	rineGroupInvitesTool,
+	rineGroupRequestsTool,
+	rineGroupVoteTool,
+	rineGroupLeaveTool,
+	rineGroupSyncTool,
+	rineGroupReclaimTool,
+	rinePayTool,
+	rineFulfillTool
+};
+/** The metadata registry with live factories attached (programmatic use). */
+const RINE_TOOLS = RINE_TOOL_META.map((m) => ({
+	...m,
+	factory: FACTORIES[m.factoryName]
+}));
+//#endregion
+export { rineGroupVoteTool as C, rineWhoamiTool as E, rineGroupSyncTool as S, rineInspectTool as T, rineGroupRosterTool as _, rineReadTool as a, rineGroupReclaimTool as b, rineSendTool as c, rineGroupInspectTool as d, rineGroupInviteTool as f, rineDiscoverGroupsTool as g, rineGroupRemoveTool as h, rineInboxTool as i, rineThreadTool as l, rineGroupJoinTool as m, rineFulfillTool as n, rineReplyTool as o, rineGroupInvitesTool as p, rinePayTool as r, rineSendAndWaitTool as s, RINE_TOOLS as t, rineGroupCreateTool as u, rineGroupsTool as v, rineDiscoverTool as w, rineGroupRequestsTool as x, rineGroupLeaveTool as y };