@rine-network/eve 0.3.0 → 0.5.0

package/dist/tools-BhkhV3Mv.js

@@ -1,595 +0,0 @@
-import { _ as renderThread, a as GROUP_ON_WAIT_MESSAGE, b as verifiedNote, c as groupIsMls, d as renderInbox, f as renderInvites, g as renderSingleMessage, h as renderProfile, i as redactToText, l as renderDiscover, m as renderMessageBody, n as asRecipient, p as renderJoinResult, r as makeExecute, s as isGroupUnsupportedOnWait, t as approvalGate, u as renderGroup } from "./tool-xlLdY8kn.js";
-import { t as RINE_TOOL_META } from "./registry-Bn4EqPcp.js";
-import { FACILITATOR_PRESET, NotFoundError, X402Error, X402FacilitatorError, X402_ERROR, X402_MESSAGE_TYPE, asAgentUuid, asGroupUuid, asMessageUuid } from "@rine-network/sdk";
-import { UUID_RE, normalizeHandle, resolveToUuid } 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.ts
-/**
-* Zod input schemas for the 6 group tools (split out of `schemas.ts` to hold the
-* ~200-LOC budget — one file per domain). Same authoring rules: rich `.describe()`
-* on every field, NO identity/credentials in the schema (env-injected).
-*
-* Groups are MLS-capable by default — `enableMls` (default true) on create.
-*/
-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"]).default("private").describe("`public` (listed in discovery) or `private` (hidden, default)."),
-	description: z.string().optional().describe("Optional group description."),
-	enableMls: z.boolean().default(true).describe("Create the group with MLS (RFC 9420) end-to-end encryption (default true). MLS gives forward secrecy and post-compromise security; disable only to force the legacy sender-key scheme.")
-});
-const groupInviteInput = z.object({
-	group: z.string().describe("The target group: a handle (`#name@org`) or a UUID. Resolved to a UUID before inviting."),
-	agentToInvite: z.string().describe("The agent to invite: a handle (`name@org`) or a UUID. Resolved to a UUID before inviting."),
-	message: z.string().optional().describe("Optional message included with the invite.")
-});
-const groupRemoveInput = z.object({
-	group: z.string().describe("The target group: a handle (`#name@org`) or a UUID. Resolved to a UUID before removal."),
-	agentId: z.string().describe("The member to remove: a handle (`name@org`) or a UUID. Group keys are rotated after removal.")
-});
-const groupInspectInput = z.object({ group: z.string().describe("The group to inspect: a handle (`#name@org`) or a UUID. Reports its E2EE mode and policy.") });
-const groupJoinInput = z.object({
-	group: z.string().describe("The group to join: a handle (`#name@org`), bare name, or a UUID. Resolved against your pending invites, or pass the UUID directly for a publicly discovered open-enrollment group."),
-	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({});
-//#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 12 rine tools.
-*
-* Rich `.describe()` on EVERY field: the field descriptions are the #1 lever on
-* tool-call accuracy (the AI-DX). Identity/credentials NEVER appear here — the
-* acting agent + config dir come from `process.env`, never the model-visible
-* input schema.
-*/
-const DEFAULT_MESSAGE_TYPE = "rine.v1.task_request";
-const DEFAULT_REPLY_TYPE = "rine.v1.task_response";
-const sendInput = z.object({
-	to: z.string().describe("Recipient address: a 1:1 agent handle `name@org`, a UUID, or a group handle prefixed with `#` (e.g. `#ops@acme`). A `#` target sends to the whole group over its E2EE channel (MLS or sender-key, chosen automatically)."),
-	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 `name@org` 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 checkInboxInput = z.object({ limit: z.number().int().min(1).max(100).default(20).describe("Maximum number of new messages to fetch and decrypt (1–100, default 20). 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({
-	conversationId: z.string().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."),
-	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 (`name@org`, resolved via WebFinger) or a UUID. Returns the full public profile.") });
-//#endregion
-//#region src/tools/discovery.ts
-/**
-* The 2 discovery tool factories: `rine_discover`, `rine_inspect`. Both are
-* unauthenticated directory reads.
-*/
-/** `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 (`name@org`) 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));
-		})
-	});
-}
-//#endregion
-//#region src/tools/groups.ts
-/**
-* The 6 group tool factories: `rine_group_create`, `rine_group_invite`,
-* `rine_group_remove`, `rine_group_inspect`, `rine_group_join`,
-* `rine_group_invites`. Groups are MLS-by-default.
-*
-* The TS SDK's `groups.invite`/`removeMember` take BRANDED UUIDs positionally, so
-* invite/remove/inspect PRE-RESOLVE handle→UUID here:
-*   - a group → `groups.list()` + local match (`findGroup`),
-*   - an agent → `resolveToUuid` (WebFinger) → its UUID (or pass a UUID through),
-*     so unlisted agents resolve too.
-* `join` resolves a handle the same way but against the caller's PENDING
-* INVITES (`groups.listInvites()`) — an invitee isn't a member yet, so it can't
-* appear in `groups.list()`. A bare UUID always passes through unchanged (the
-* path for a publicly discovered open-enrollment group with no invite record).
-*/
-/** True for a bare UUID string (no `@`, matches the rine UUID shape). */
-function isUuid(s) {
-	return UUID_RE.test(s);
-}
-/** A handle's bare local name: `#ops@acme` / `ops` → `ops`. */
-function bareLocalName(handle) {
-	return handle.replace(/^#/, "").split("@")[0] ?? handle;
-}
-/** Match a group among the caller's groups by UUID, full handle, or bare name. */
-function findGroup(groups, target) {
-	if (isUuid(target)) return groups.find((g) => g.id === target);
-	if (!target.includes("@")) {
-		const want = bareLocalName(target);
-		return groups.find((g) => bareLocalName(g.handle) === want);
-	}
-	const want = normalizeHandle(target.startsWith("#") ? target : `#${target}`);
-	return groups.find((g) => normalizeHandle(g.handle) === want);
-}
-/** Resolve a group handle/UUID to its `GroupUuid` via the caller's group list. */
-async function resolveGroupUuid(client, target) {
-	if (isUuid(target)) return asGroupUuid(target);
-	const match = findGroup((await client.groups.list()).items, target);
-	if (!match) throw new NotFoundError(`No group '${target}' among the groups this agent belongs to`);
-	return asGroupUuid(match.id);
-}
-/** 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));
-}
-/** Match a pending invite among the caller's invites by UUID, full handle, or bare name. */
-function findInvite(invites, target) {
-	if (isUuid(target)) return invites.find((inv) => inv.group_id === target);
-	if (!target.includes("@")) {
-		const want = bareLocalName(target);
-		return invites.find((inv) => inv.group_handle && bareLocalName(inv.group_handle) === want || inv.group_name === target);
-	}
-	const want = normalizeHandle(target.startsWith("#") ? target : `#${target}`);
-	return invites.find((inv) => inv.group_handle && normalizeHandle(inv.group_handle) === want);
-}
-/**
-* Resolve a group handle/UUID to its `GroupUuid` for `rine_group_join`. A bare
-* UUID passes straight through (the open-enrollment discovery case); a handle
-* is resolved against the caller's PENDING INVITES, since an invitee isn't a
-* member yet and so can't appear in `groups.list()`.
-*/
-async function resolveGroupUuidForJoin(client, target) {
-	if (isUuid(target)) return asGroupUuid(target);
-	const match = findInvite(await client.groups.listInvites(), target);
-	if (!match) throw new NotFoundError(`No pending invite for group '${target}' — pass the group UUID directly for an open-enrollment group, or check rine_group_invites`);
-	return asGroupUuid(match.group_id);
-}
-/** `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 MLS (RFC 9420) encryption with forward secrecy. This is a real, irreversible network action. Returns the new group handle, id, E2EE mode, and enrollment policy.",
-		inputSchema: jsonSchema(groupCreateInput),
-		outputSchema: STRING_OUTPUT,
-		needsApproval: approvalGate(opts),
-		execute: makeExecute(groupCreateInput, opts, async (client, i) => {
-			const g = await client.groups.create(i.name, {
-				description: i.description,
-				enrollment: i.enrollment,
-				visibility: i.visibility,
-				enableMls: i.enableMls
-			});
-			const mode = groupIsMls(g) ? "MLS" : "sender-key";
-			return `Created group ${g.handle} (id ${g.id}, ${mode} E2EE, enrollment ${g.enrollment_policy}).`;
-		})
-	});
-}
-/** `rine_group_invite` — invite an agent into a group (handle→UUID pre-resolved). */
-function rineGroupInviteTool(opts = {}) {
-	return defineTool({
-		description: "Invite an agent into a group your agent administers (group and agent may be handles or UUIDs). This is a real, irreversible network action. Returns the invite status.",
-		inputSchema: jsonSchema(groupInviteInput),
-		outputSchema: STRING_OUTPUT,
-		needsApproval: approvalGate(opts),
-		execute: makeExecute(groupInviteInput, opts, async (client, i, apiUrl) => {
-			const groupId = await resolveGroupUuid(client, i.group);
-			const agentId = await resolveAgentUuid(apiUrl, i.agentToInvite);
-			const result = await client.groups.invite(groupId, agentId, { message: i.message });
-			return `Invited ${i.agentToInvite} to ${i.group} (status ${result.status}).`;
-		})
-	});
-}
-/** `rine_group_remove` — remove a member; group keys rotate (handle→UUID pre-resolved). */
-function rineGroupRemoveTool(opts = {}) {
-	return defineTool({
-		description: "Remove a member from a group your agent administers (group and agent may be handles or UUIDs). Group keys are rotated for forward secrecy. 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 groupId = await resolveGroupUuid(client, i.group);
-			const agentId = await resolveAgentUuid(apiUrl, i.agentId);
-			await client.groups.removeMember(groupId, agentId);
-			return `Removed ${i.agentId} from ${i.group}; keys rotated.`;
-		})
-	});
-}
-/** `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 confirm your agent can read and post to it. Accepts a group handle or UUID.",
-		inputSchema: jsonSchema(groupInspectInput),
-		outputSchema: STRING_OUTPUT,
-		execute: makeExecute(groupInspectInput, opts, async (client, i) => {
-			const match = findGroup((await client.groups.list()).items, i.group);
-			if (!match) throw new NotFoundError(`No group '${i.group}' among the groups this agent belongs to`);
-			return renderGroup(match);
-		})
-	});
-}
-/** `rine_group_join` — accept an invite (or self-join an open group). */
-function rineGroupJoinTool(opts = {}) {
-	return defineTool({
-		description: "Join a group: accept a pending invite, or self-join a publicly discovered open-enrollment group by UUID. Instant for open enrollment; for closed/majority/unanimity groups this submits a request that members vote on. 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 resolveGroupUuidForJoin(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 your agent's pending group invites — group, who invited you, status, and any message. Join one 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 5 messaging tool factories: `rine_send`, `rine_send_and_wait`,
-* `rine_check_inbox`, `rine_read`, `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`/`check_inbox` 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 (`name@org` / UUID) or, with a `#`-prefixed handle, to a whole group over its E2EE channel. 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 (`name@org` / 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_check_inbox` — poll the newest new messages, decrypt them, then
-* best-effort `markDelivered` the decryptable ids so a later check returns only
-* newer mail. On ack failure: warn but still return the reads.
-*/
-function rineCheckInboxTool(opts = {}) {
-	return defineTool({
-		description: "Fetch and decrypt your newest unread messages (1:1 and group), then mark them delivered so a later check returns only newer mail. Returns a numbered list of decrypted messages, or 'No new messages.'.",
-		inputSchema: jsonSchema(checkInboxInput),
-		outputSchema: STRING_OUTPUT,
-		toModelOutput: redactToText,
-		execute: makeExecute(checkInboxInput, opts, async (client, i) => {
-			const items = (await client.inbox({
-				status: "new",
-				limit: i.limit
-			})).items;
-			const rendered = renderInbox(items);
-			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 by its UUID. Returns every turn (yours and the peer's) ordered oldest→newest, each role-tagged (`[sent] you:` / `[received] handle:`). A turn you cannot decrypt renders `[unavailable]`. Use to recover the full context of a conversation on demand.",
-		inputSchema: jsonSchema(threadInput),
-		outputSchema: STRING_OUTPUT,
-		toModelOutput: redactToText,
-		execute: makeExecute(threadInput, opts, async (client, i) => {
-			return renderThread(await client.thread(i.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,
-	rineCheckInboxTool,
-	rineReadTool,
-	rineReplyTool,
-	rineThreadTool,
-	rineDiscoverTool,
-	rineInspectTool,
-	rineGroupCreateTool,
-	rineGroupInviteTool,
-	rineGroupRemoveTool,
-	rineGroupInspectTool,
-	rineGroupJoinTool,
-	rineGroupInvitesTool,
-	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 { rineInspectTool as _, rineReadTool as a, rineSendTool as c, rineGroupInspectTool as d, rineGroupInviteTool as f, rineDiscoverTool as g, rineGroupRemoveTool as h, rineCheckInboxTool 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 };