@rine-network/eve 0.1.0 → 0.3.0

package/dist/{tools-Bm9N6tB5.js → tools-BhkhV3Mv.js}

@@ -1,6 +1,6 @@
-import { a as GROUP_ON_WAIT_MESSAGE, c as groupIsMls, d as renderInbox, f as renderMessageBody, h as renderThread, i as redactToText, l as renderDiscover, m as renderSingleMessage, n as asRecipient, p as renderProfile, r as makeExecute, s as isGroupUnsupportedOnWait, t as approvalGate, u as renderGroup, v as verifiedNote } from "./tool-BC49DldZ.js";
-import { t as RINE_TOOL_META } from "./registry-BG7S2XJg.js";
-import { NotFoundError, asAgentUuid, asGroupUuid, asMessageUuid } from "@rine-network/sdk";
+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";
@@ -19,9 +19,9 @@ const STRING_OUTPUT = { type: "string" };
 //#endregion
 //#region src/schemas-groups.ts
 /**
-* Zod input schemas for the 4 group tools (split out of `schemas.ts` to hold the
+* 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, R3).
+* on every field, NO identity/credentials in the schema (env-injected).
 *
 * Groups are MLS-capable by default — `enableMls` (default true) on create.
 */
@@ -47,6 +47,31 @@ const groupRemoveInput = z.object({
 	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
 /**
@@ -54,7 +79,7 @@ const groupInspectInput = z.object({ group: z.string().describe("The group to in
 *
 * Rich `.describe()` on EVERY field: the field descriptions are the #1 lever on
 * tool-call accuracy (the AI-DX). Identity/credentials NEVER appear here — the
-* acting agent + config dir come from `process.env` (R3), never the model-visible
+* acting agent + config dir come from `process.env`, never the model-visible
 * input schema.
 */
 const DEFAULT_MESSAGE_TYPE = "rine.v1.task_request";
@@ -127,14 +152,19 @@ function rineInspectTool(opts = {}) {
 //#endregion
 //#region src/tools/groups.ts
 /**
-* The 4 group tool factories: `rine_group_create`, `rine_group_invite`,
-* `rine_group_remove`, `rine_group_inspect`. Groups are MLS-by-default.
+* 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) {
@@ -166,6 +196,28 @@ 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({
@@ -228,6 +280,31 @@ function rineGroupInspectTool(opts = {}) {
 		})
 	});
 }
+/** `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
 /**
@@ -237,7 +314,7 @@ function rineGroupInspectTool(opts = {}) {
 * `makeExecute` (lazy env client + formatError). The runtime tool NAME comes from
 * the filename slug of the scaffolded `agent/tools/<name>.ts`, not from here.
 *
-* R4 holds throughout: renderers read only plaintext/decrypt_error/verification,
+* Renderers read only plaintext/decrypt_error/verification,
 * never the ciphertext envelope. `read`/`check_inbox` add a `toModelOutput`
 * redactor as defence-in-depth.
 */
@@ -345,6 +422,151 @@ function rineReplyTool(opts = {}) {
 	});
 }
 //#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,
@@ -358,7 +580,11 @@ const FACTORIES = {
 	rineGroupCreateTool,
 	rineGroupInviteTool,
 	rineGroupRemoveTool,
-	rineGroupInspectTool
+	rineGroupInspectTool,
+	rineGroupJoinTool,
+	rineGroupInvitesTool,
+	rinePayTool,
+	rineFulfillTool
 };
 /** The metadata registry with live factories attached (programmatic use). */
 const RINE_TOOLS = RINE_TOOL_META.map((m) => ({
@@ -366,4 +592,4 @@ const RINE_TOOLS = RINE_TOOL_META.map((m) => ({
 	factory: FACTORIES[m.factoryName]
 }));
 //#endregion
-export { rineSendAndWaitTool as a, rineGroupCreateTool as c, rineGroupRemoveTool as d, rineDiscoverTool as f, rineReplyTool as i, rineGroupInspectTool as l, rineCheckInboxTool as n, rineSendTool as o, rineInspectTool as p, rineReadTool as r, rineThreadTool as s, RINE_TOOLS as t, rineGroupInviteTool as u };
+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 };

package/dist/transcript.d.ts

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

package/dist/types.d.ts

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

package/dist/webhook.d.ts

@@ -5,7 +5,7 @@
  * by webhook (no daemon, serverless-native). This registers a rine webhook that
  * POSTs new-message notifications to the channel route, and returns the HMAC
  * `secret` the channel verifies with (`RINE_WEBHOOK_SECRET`). `--delete` tears it
- * down. R1: the client is built lazily inside the call.
+ * down. The client is built lazily inside the call.
  */
 /** Options shared by register/delete. */
 export interface WebhookOptions {

package/dist/webhook.js

@@ -1,4 +1,4 @@
-import { t as getRineClient } from "./client-X_-9CpQT.js";
+import { t as getRineClient } from "./client-DsG2xtKs.js";
 import { asAgentUuid, asWebhookUuid } from "@rine-network/sdk";
 import { UUID_RE, resolveApiUrl, resolveToUuid } from "@rine-network/core";
 //#region src/webhook.ts
@@ -9,7 +9,7 @@ import { UUID_RE, resolveApiUrl, resolveToUuid } from "@rine-network/core";
 * by webhook (no daemon, serverless-native). This registers a rine webhook that
 * POSTs new-message notifications to the channel route, and returns the HMAC
 * `secret` the channel verifies with (`RINE_WEBHOOK_SECRET`). `--delete` tears it
-* down. R1: the client is built lazily inside the call.
+* down. The client is built lazily inside the call.
 */
 const DEFAULT_INBOUND_PATH = "/rine/v1/inbound";
 function inboundUrl(opts) {

package/dist/x402.d.ts

@@ -0,0 +1,38 @@
+/**
+ * x402 payment-aware inbound re-surfacing for the rine channel.
+ *
+ * The three x402 payment frames are first-class message types carrying a verbatim
+ * x402 V2 object, NOT a chat turn. v1.0 dropped them wholesale (a stateless gateway
+ * that auto-replied prose into a payment handshake would corrupt it). v1.1 re-surfaces
+ * them as an agent turn with STRUCTURED payment context so the model can act via the
+ * dedicated pay / fulfill tools — while the terminal assistant prose stays suppressed
+ * in EVERY case (the `x402` continuation-token flag; the guard hazard never re-arms):
+ *
+ *   - `x402_payment_required` → the quote + guidance to pay via `rine_pay`.
+ *   - `x402_payment`          → the signed authorization + guidance to `rine_fulfill`.
+ *   - `x402_receipt`          → the settlement outcome, informational (no reply).
+ *
+ * Auto-pay (opt-in, DEFAULT OFF): when enabled, a `payment_required` at/below the
+ * policy's `autoPayThreshold` is paid with NO LLM turn — still bounded by the policy
+ * caps, deny-by-default, journal and reserve-lock (all in rine-core). Any decline
+ * falls back to surfacing the quote to the model.
+ */
+import type { InboundDeps } from "./channel-core.js";
+import type { DecryptedMessage } from "./types.js";
+/** The three x402 frame types this module re-surfaces. */
+export declare const X402_FRAME_TYPES: readonly ["rine.v1.x402_payment_required", "rine.v1.x402_payment", "rine.v1.x402_receipt"];
+/** Whether a message type is one of the three x402 payment frames. */
+export declare function isX402Frame(type: string): boolean;
+/**
+ * The structured payment body handed to the model as the turn's primary message.
+ * Reads only the decrypted plaintext (the verbatim x402 object) — never ciphertext.
+ */
+export declare function renderX402Body(msg: DecryptedMessage): string;
+/** The routing-guidance line: what the model should do, and the do-not-reply rule. */
+export declare function x402GuidanceLine(msg: DecryptedMessage): string;
+/**
+ * Handle a verified inbound x402 frame. `payment_required` may auto-pay
+ * when enabled and at/below threshold; otherwise, and for `payment` / `receipt`,
+ * the frame is surfaced to the model as a payment-aware turn.
+ */
+export declare function handleX402Inbound(deps: InboundDeps, msg: DecryptedMessage, messageId: string): Promise<Response>;

package/package.json

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