@rine-network/mastra 0.2.0 → 0.4.0

package/MASTRA.md

@@ -98,7 +98,7 @@ works on any of the three.
 The TS SDK decrypts **all** rine encryption modes — `hpke-v1`, `hpke-hybrid-v1` (PQ X25519+ML-KEM-768),
 `sender-key-v1`, **and `mls-v1`** — and `rine_group_create` defaults to MLS. So a Mastra agent can
 **create, read, AND post MLS group traffic and exchange PQ-hybrid 1:1 messages**. This was proven
-**live end-to-end against production** (Phase F, 2026-06-11): a real `mls-v1` group round-trip, a real
+**live end-to-end against production** (2026-06-11): a real `mls-v1` group round-trip, a real
 `hpke-hybrid-v1` 1:1 round-trip, and a cross-process suspend/resume.
 
 `rine_group_inspect` renders **`[OK] MLS group — readable/postable`** (not a warning) and

package/README.md

@@ -28,13 +28,13 @@ export const rineAgent = new Agent({
   name: "Rine Agent",
   instructions: "You message and coordinate with other agents over rine.",
   model: openai("gpt-4o-mini"),
-  tools: rineToolkit({ agent: "support" }), // all 12 rine_* tools, keyed by id
+  tools: rineToolkit({ agent: "support" }), // all 16 rine_* tools, keyed by id
 });
 ```
 
 `rineToolkit()` returns a keyed `Record<string, Tool>` — spread it into a Mastra `Agent`'s `tools` map. The acting identity (`agent`, `configDir`, `apiUrl`) is host-injected, never chosen by the model, so credentials never enter the model's context.
 
-## The 12 tools
+## The 16 tools
 
 | Tool | What it does |
 |---|---|
@@ -49,6 +49,16 @@ export const rineAgent = new Agent({
 | `rine_group_create` | Create a group — **MLS-encrypted by default**. |
 | `rine_group_invite` / `rine_group_remove` | Manage group membership. |
 | `rine_group_inspect` | Inspect a group's E2EE mode + members. |
+| `rine_group_join` | Accept a pending invite (or request to join an open group by UUID). **Mutating.** |
+| `rine_group_invites` | List your agent's pending group invites. |
+| `rine_pay` | Pay a received `rine.v1.x402_payment_required` quote under the local spend policy. **Mutating.** |
+| `rine_fulfill` | Payee side: verify + settle a received `rine.v1.x402_payment` through a facilitator and reply with a receipt. **Mutating.** |
+
+## Payments (x402)
+
+`rine_pay` and `rine_fulfill` carry [x402](https://docs.rine.network/concepts/x402-payments/) stablecoin payments — signed messages that ride the same encrypted thread. Both wrap `client.payments`; the agent never holds or reimplements signing, policy, or settlement logic. The wallet key stays on the host and is never returned to the model, and a deny-by-default spend policy bounds every signature. `rine_pay` returns one of the shared payer statuses (`payment-submitted`, `no-wallet`, `not-payment-required`, `policy-refused`, `above-auto-pay-threshold`, `already-paid`, `wallet-busy`); `rine_fulfill` reports `settled` / `settlement-failed` / `verification-failed` / `facilitator-error` / `no-facilitator`.
+
+Auto-pay is **opt-in, off by default**: `rineToolkit({ payments: { autoPay: true } })` defaults `rine_pay` to paying only quotes at/below the wallet policy's auto-pay threshold. `rine_fulfill`'s facilitator comes from `rineToolkit({ payments: { facilitator } })` (a preset `cdp` / `payai` / `x402-rs`, a base URL, or a `FacilitatorConfig`) — provider auth never comes from a model input.
 
 ## Beyond tools
 

package/dist/_zod.d.ts

@@ -1,9 +1,9 @@
 /**
  * Host-zod re-export + the shared string output schema.
  *
- * Every tool's `outputSchema` is `z.string()` (D-output) — a tool returns clean
+ * Every tool's `outputSchema` is `z.string()` — a tool returns clean
  * text to the model, so ciphertext can never ride a struct field and benign
- * "no reply" strings never trip v1 output-validation (PHASE0_CONTRACT P0-2).
+ * "no reply" strings never trip v1 output-validation.
  * This is authored with the HOST `zod` (the single hoisted instance Mastra
  * validates against), NOT the SDK's re-exported `z`. Centralizing the one shared
  * instance here keeps `import { z } from "zod"` out of every tool module while

package/dist/context.d.ts

@@ -1,5 +1,5 @@
 /**
- * Identity injection via Mastra's `RequestContext` (P0-3, BLOCKING — verified
+ * Identity injection via Mastra's `RequestContext` (BLOCKING — verified
  * in-rig). The acting agent + config dir are read from `ctx.requestContext`
  * inside a tool's `execute`, NEVER from the model-visible `inputSchema` (I-2 /
  * Mastra's own security rule). Keys are `rine-`-namespaced to avoid collision

package/dist/discovery.d.ts

@@ -1,8 +1,8 @@
 /**
- * The 2 discovery tools: `rine_discover`, `rine_inspect` (SPEC §6 discovery
- * table). Both are unauthenticated directory reads. `discover` exposes only the
+ * The 2 discovery tools: `rine_discover`, `rine_inspect`. Both are
+ * unauthenticated directory reads. `discover` exposes only the
  * fields the TS `DiscoveryFilters` supports — q/category/language/verified/limit
- * (the Python tag/jurisdiction/pricingModel fields are dropped, D-discover-fields).
+ * (the Python tag/jurisdiction/pricingModel fields are dropped).
  */
 import { type RineToolOpts } from "./tool.js";
 /** `rine_discover` — search the public agent directory. */

package/dist/drivers.d.ts

@@ -1,5 +1,5 @@
 /**
- * Tier-3 wake drivers (D-tier3-driver). Two ways to feed inbound rine messages
+ * Tier-3 wake drivers. Two ways to feed inbound rine messages
  * into a {@link RineThreadResumer}:
  *
  *   - {@link PollDriver} (default) — a long-lived host loop over the SDK's

package/dist/format.d.ts

@@ -1,16 +1,16 @@
 /**
  * Pure render functions: turn SDK return values into the human-readable strings
  * tools hand back to the LLM. Ported field-for-field from the Python `_format.py`
- * (`AGENT_OUT_precedent_blueprint.md §6`) — same snake_case wire field names —
+ * — same snake_case wire field names —
  * with ONE inversion: the group MLS branch reads `[OK]` instead of `[WARN]`,
- * because the TS SDK fully reads/posts MLS + PQ traffic (D-mls).
+ * because the TS SDK fully reads/posts MLS + PQ traffic.
  *
  * Invariant I-2: these read ONLY `plaintext` / `decrypt_error` / verification
  * fields. They NEVER read `encrypted_payload` or any envelope/ciphertext field,
  * so ciphertext can never reach the LLM context through a rendered string.
  */
 import type { ThreadEntry } from "@rine-network/sdk";
-import type { AgentProfile, AgentSummary, DecryptedMessage, GroupRead } from "./types.js";
+import type { AgentProfile, AgentSummary, DecryptedMessage, GroupRead, JoinRequestRead } from "./types.js";
 /**
  * Render a both-sided transcript (oldest→newest) for `rine_thread`. Each turn is a
  * role-tagged line; `[unavailable]` text passes through unchanged.
@@ -51,3 +51,5 @@ export declare function groupIsMls(g: GroupRead): boolean;
  * read/post`).
  */
 export declare function renderGroup(g: GroupRead): string;
+/** A numbered list of the caller's pending group invites, or the empty-state line. */
+export declare function renderInvites(items: readonly JoinRequestRead[]): string;

package/dist/groups.d.ts

@@ -1,18 +1,22 @@
 /**
- * The 4 group tools: `rine_group_create`, `rine_group_invite`,
- * `rine_group_remove`, `rine_group_inspect` (SPEC §6 groups table — the
- * INVERTED, MLS-capable section).
+ * The 6 group tools: `rine_group_create`, `rine_group_invite`,
+ * `rine_group_remove`, `rine_group_inspect` (the INVERTED, MLS-capable
+ * section), `rine_group_join`, `rine_group_invites`.
  *
- * `group_create` exposes `enableMls` (default true) — the headline differentiator
- * (D-mls): the SDK best-effort-inits an MLS group and the renderer reports
+ * `group_create` exposes `enableMls` (default true) — the headline differentiator:
+ * the SDK best-effort-inits an MLS group and the renderer reports
  * `[OK] MLS`, not a `[WARN]` ceiling.
  *
  * The TS SDK's `groups.invite`/`removeMember`/`get` take BRANDED UUIDs
  * positionally (unlike the Python SDK, which resolved handles internally), so
- * invite/remove/inspect PRE-RESOLVE handle→UUID here (D-handle-resolve):
+ * invite/remove/inspect/join PRE-RESOLVE handle→UUID here:
  *   - a group → `groups.list()` + local match (`findGroup`),
  *   - an agent → `resolveToUuid` (WebFinger) → its UUID (or pass a UUID through).
  *     WebFinger — not the public directory — so unlisted agents resolve too.
+ *
+ * `rine_group_join`/`rine_group_invites` close the accept-side gap: an agent
+ * invited into a group previously had no tool to join it or see its pending
+ * invites (only create/invite/remove/inspect existed).
  */
 import { type RineToolOpts } from "./tool.js";
 /** `rine_group_create` — create an MLS-by-default coordination group. */
@@ -23,3 +27,7 @@ export declare function createRineGroupInviteTool(opts?: RineToolOpts): import("
 export declare function createRineGroupRemoveTool(opts?: RineToolOpts): import("@mastra/core/tools").Tool<any, any, any, any, import("@mastra/core/tools").ToolExecutionContext<any, any, unknown>, "rine_group_remove", unknown>;
 /** `rine_group_inspect` — report a group's E2EE mode + policy (`[OK] MLS` self-diagnosis). */
 export declare function createRineGroupInspectTool(opts?: RineToolOpts): import("@mastra/core/tools").Tool<any, any, any, any, import("@mastra/core/tools").ToolExecutionContext<any, any, unknown>, "rine_group_inspect", unknown>;
+/** `rine_group_join` — accept a pending invite / request to join (handle→UUID pre-resolved). */
+export declare function createRineGroupJoinTool(opts?: RineToolOpts): import("@mastra/core/tools").Tool<any, any, any, any, import("@mastra/core/tools").ToolExecutionContext<any, any, unknown>, "rine_group_join", unknown>;
+/** `rine_group_invites` — list the caller's own pending group invites. */
+export declare function createRineGroupInvitesTool(opts?: RineToolOpts): import("@mastra/core/tools").Tool<any, any, any, any, import("@mastra/core/tools").ToolExecutionContext<any, any, unknown>, "rine_group_invites", unknown>;

package/dist/inbound.d.ts

@@ -6,7 +6,7 @@
  *   1. resolve the message's `(handle, conversation_id)` → stored `runId` via the
  *      {@link ThreadMapStore} (no mapping ⇒ skip, do NOT ack — lossless);
  *   2. **rehydrate the snapshot via `getWorkflowRunById(runId)` BEFORE resume**
- *      (the load-bearing P0-10 recipe; defends mastra #5521 where
+ *      (the load-bearing recipe; defends mastra #5521 where
  *      `createRun({runId})` would otherwise read an empty in-process run-map);
  *      a non-suspended / unknown run ⇒ skip, do NOT ack;
  *   3. build `resumeData` from `plaintext` / `verified` / `from` ONLY
@@ -14,14 +14,14 @@
  *      decrypt-failed message ⇒ skip, do NOT ack;
  *   4. `createRun({runId}).resume({ step, resumeData })` to continue the run.
  *
- * **Lossless-by-default (langchain D16):** every skip path leaves the message in
+ * **Lossless-by-default:** every skip path leaves the message in
  * the rine inbox (no `markDelivered`), so a later poll can retry after the run is
  * mapped / key recovery succeeds. The resumer NEVER acks.
  */
 import type { ThreadMapStore } from "./threadmap.js";
 import type { DecryptedMessage } from "./types.js";
 /**
- * The minimal Mastra-workflow surface the resumer drives (the P0-10 recipe). A
+ * The minimal Mastra-workflow surface the resumer drives (the recipe). A
  * real `mastra.getWorkflow(id)` satisfies this structurally — we type only the
  * two methods used so the package does not hard-couple to a workflow generic and
  * tests can pass a fake. `step` is the suspended step (a `createStep` object or
@@ -65,7 +65,7 @@ export interface ResumeData {
 }
 /** Options for {@link RineThreadResumer}. */
 export interface RineThreadResumerOptions {
-    /** A pre-built workflow with snapshot storage already bound (P0-10). */
+    /** A pre-built workflow with snapshot storage already bound. */
     workflow: ResumableWorkflow;
     /** The durable `(handle, conversation) → runId` map. */
     threadMap: ThreadMapStore;

package/dist/index.d.ts

@@ -17,22 +17,23 @@
 export { getRineClient } from "./client.js";
 export type { RineClientOpts } from "./client.js";
 export { formatError } from "./errors.js";
-export type { RineToolOpts } from "./tool.js";
+export type { RinePaymentToolOpts, RineToolOpts } from "./tool.js";
 export { createRineCheckInboxTool, createRineReadTool, createRineReplyTool, createRineSendAndWaitTool, createRineSendTool, createRineThreadTool, } from "./messaging.js";
-export { createRineDiscoverTool, createRineInspectTool, } from "./discovery.js";
-export { createRineGroupCreateTool, createRineGroupInspectTool, createRineGroupInviteTool, createRineGroupRemoveTool, } from "./groups.js";
+export { createRineDiscoverTool, createRineInspectTool } from "./discovery.js";
+export { createRineGroupCreateTool, createRineGroupInspectTool, createRineGroupInviteTool, createRineGroupInvitesTool, createRineGroupJoinTool, createRineGroupRemoveTool, } from "./groups.js";
+export { createRineFulfillTool, createRinePayTool } from "./payments.js";
 export { rineToolkit } from "./tools.js";
-export type { RineToolDomain, RineToolkitOptions } from "./tools.js";
+export type { RinePaymentsConfig, RineToolDomain, RineToolkitOptions, } from "./tools.js";
 export { rineLifecycle } from "./lifecycle.js";
 export type { RineLifecycleCallbacks, RineLifecycleEvent, RineLifecycleOptions, } from "./lifecycle.js";
 export { RineThreadResumer } from "./inbound.js";
 export type { ResumableRun, ResumableWorkflow, ResumeData, ResumeOutcome, RineThreadResumerOptions, WorkflowSnapshot, } from "./inbound.js";
-export { InMemoryThreadMap, SqliteThreadMap, } from "./threadmap.js";
-export type { SqliteThreadMapOptions, ThreadMapStore, } from "./threadmap.js";
+export { InMemoryThreadMap, SqliteThreadMap } from "./threadmap.js";
+export type { SqliteThreadMapOptions, ThreadMapStore } from "./threadmap.js";
 export { makeWebhookHandler, PollDriver } from "./drivers.js";
 export type { PollDriverOptions, WebhookHandler, WebhookHandlerOptions, } from "./drivers.js";
 export { parseOnboardArgs, runOnboard } from "./onboard.js";
 export type { OnboardArgs, OnboardIO, OnboardOptions } from "./onboard.js";
-export { RINE_ACTING_AGENT, RINE_API_URL, RINE_CONFIG_DIR, } from "./context.js";
+export { RINE_ACTING_AGENT, RINE_API_URL, RINE_CONFIG_DIR } from "./context.js";
 export type { RineToolContext } from "./context.js";
-export type { AgentProfile, AgentSummary, DecryptedMessage, GroupRead, InviteResult, MessageRead, } from "./types.js";
+export type { AgentProfile, AgentSummary, DecryptedMessage, GroupRead, InviteResult, JoinRequestRead, MessageRead, } from "./types.js";

package/dist/lifecycle.d.ts

@@ -1,10 +1,10 @@
 /**
- * Outbound lifecycle bridge `rineLifecycle` (SPEC §8 + PHASE0_CONTRACT P0-7).
+ * Outbound lifecycle bridge `rineLifecycle`.
  *
  * Mastra has NO callback-handler object class. The faithful 1:1 of the Python
  * `RineCallbackHandler` is a FACTORY returning the top-level callbacks
  * `agent.stream(...)` / `agent.generate(...)` accept — verified identical across
- * both methods (P0-7). Spread the result into either:
+ * both methods. Spread the result into either:
  *   const cb = rineLifecycle({ to: "ops@acme", on: ["finish", "error"] });
  *   await agent.stream(input, { ...cb });    // or .generate(input, { ...cb })
  *

package/dist/messaging.d.ts

@@ -1,6 +1,6 @@
 /**
  * The 5 messaging tools: `rine_send`, `rine_send_and_wait`, `rine_check_inbox`,
- * `rine_read`, `rine_reply` (SPEC §6 messaging table). Each is a thin
+ * `rine_read`, `rine_reply`. Each is a thin
  * `createTool` adapter: one `AsyncRineClient` call rendered to a string, wrapped
  * by `makeExecute` (lazy client + formatError). Identity comes from
  * `ctx.requestContext`, never the model-visible `inputSchema`.

package/dist/onboard.d.ts

@@ -1,5 +1,5 @@
 /**
- * Setup helper — `npx @rine-network/mastra onboard` (SPEC §11, D-not-tools).
+ * Setup helper — `npx @rine-network/mastra onboard`.
  *
  * Runs the SDK's RSA time-lock proof-of-work to register a fresh org, then
  * creates the first agent and prints its handle + verification words. This is
@@ -11,7 +11,7 @@
  * to the SDK's `register(opts)` (over rine-core `performRegistration`); the agent
  * keypair is generated + persisted by `client.createAgent(name)`.
  *
- * Config resolution is explicit (D-config-resolve): `register` REQUIRES concrete
+ * Config resolution is explicit: `register` REQUIRES concrete
  * `apiUrl`/`configDir` strings, so we resolve them via rine-core unless the caller
  * passed overrides (the SDK never resolves them itself).
  */

package/dist/onboard.js

@@ -2,7 +2,7 @@ import { resolveApiUrl, resolveConfigDir } from "@rine-network/core";
 import { AsyncRineClient, register } from "@rine-network/sdk";
 //#region src/onboard.ts
 /**
-* Setup helper — `npx @rine-network/mastra onboard` (SPEC §11, D-not-tools).
+* Setup helper — `npx @rine-network/mastra onboard`.
 *
 * Runs the SDK's RSA time-lock proof-of-work to register a fresh org, then
 * creates the first agent and prints its handle + verification words. This is
@@ -14,7 +14,7 @@ import { AsyncRineClient, register } from "@rine-network/sdk";
 * to the SDK's `register(opts)` (over rine-core `performRegistration`); the agent
 * keypair is generated + persisted by `client.createAgent(name)`.
 *
-* Config resolution is explicit (D-config-resolve): `register` REQUIRES concrete
+* Config resolution is explicit: `register` REQUIRES concrete
 * `apiUrl`/`configDir` strings, so we resolve them via rine-core unless the caller
 * passed overrides (the SDK never resolves them itself).
 */

package/dist/payments.d.ts

@@ -0,0 +1,38 @@
+/**
+ * The 2 x402 payment tools: `rine_pay` (payer) and `rine_fulfill` (payee). Each
+ * is a thin `createTool` adapter over the ts-sdk `client.payments` facade — the
+ * SAME single implementation the CLI/MCP payer and the ts-sdk payee use, so no
+ * signing / policy / journal / facilitator logic is reimplemented here (I-14).
+ *
+ * `rine_pay` consumes a received `rine.v1.x402_payment_required` and returns the
+ * `rine_pay` 7-status vocabulary VERBATIM (parity with MCP `rine_pay` and the
+ * cc-plugin skill). `rine_fulfill` consumes a received `rine.v1.x402_payment`,
+ * verifies + settles via the configured facilitator (plain external HTTP, never
+ * rine), sends the receipt in-thread, and returns the PINNED payee vocabulary
+ * (`settled` / `settlement-failed` / `verification-failed` / `facilitator-error`
+ * / `no-facilitator` / `not-payment`), identical across every surface
+ * (CLI/MCP/eve/mastra).
+ *
+ * Invariants held: deny-by-default policy; sign → reserve LAST → transmit;
+ * permanent debit (no retry-with-fresh-reserve loop — a single `pay` call);
+ * marker `{status,rail}`-only, default ON; wallet key never surfaced; typed
+ * outcomes never throw for an expected refusal; the settlement `.network` is
+ * stored/echoed verbatim, never CAIP-2 string-matched (PayAI echoes the v1 slug).
+ */
+import { type RinePaymentToolOpts } from "./tool.js";
+/**
+ * `rine_pay` — pay a received x402 quote in-thread (payer). Mode T: an explicit
+ * tool call is the authorization, hard-bounded by the spend caps. The toolkit's
+ * `payments.autoPay` config (D2, default OFF) sets the default of the `autoPay`
+ * input; when on, only quotes at/below the policy's `autoPayThreshold` are paid.
+ */
+export declare function createRinePayTool(opts?: RinePaymentToolOpts): import("@mastra/core/tools").Tool<any, any, any, any, import("@mastra/core/tools").ToolExecutionContext<any, any, unknown>, "rine_pay", unknown>;
+/**
+ * `rine_fulfill` — verify + settle a received x402 payment and send the receipt
+ * in-thread (payee). Settle-first: on a valid authorization it settles via the
+ * configured facilitator and sends a success receipt; on an invalid one it skips
+ * settlement and sends a failure receipt so the payer reaches a terminal state.
+ * The facilitator is plain external HTTP (never rine); its `.network` slug is
+ * echoed verbatim.
+ */
+export declare function createRineFulfillTool(opts?: RinePaymentToolOpts): import("@mastra/core/tools").Tool<any, any, any, any, import("@mastra/core/tools").ToolExecutionContext<any, any, unknown>, "rine_fulfill", unknown>;

package/dist/schemas-groups.d.ts

@@ -1,11 +1,11 @@
 /**
  * Zod input schemas for the 4 group tools (split out of `schemas.ts` to hold the
- * ~200-LOC budget — the schema concentration the SPEC §4 endorses, one file per
+ * ~200-LOC budget — one file per
  * domain). Same authoring rules: HOST `zod`, rich `.describe()` on every field,
  * NO identity/credentials in the schema (host-injected via `ctx.requestContext`).
  *
  * Groups are MLS-capable by default — `enableMls` (default true) on create is the
- * headline inversion vs the Python siblings (D-mls).
+ * headline inversion vs the Python siblings.
  */
 import { z } from "zod";
 export declare const groupCreateInput: z.ZodObject<{
@@ -57,3 +57,15 @@ export declare const groupInspectInput: z.ZodObject<{
 }, {
     group: string;
 }>;
+export declare const groupJoinInput: z.ZodObject<{
+    group: z.ZodString;
+    message: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    group: string;
+    message?: string | undefined;
+}, {
+    group: string;
+    message?: string | undefined;
+}>;
+/** `rine_group_invites` takes no input — it lists the caller's own pending invites. */
+export declare const groupInvitesInput: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;

package/dist/schemas-payments.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Zod input schemas for the two x402 payment tools (`rine_pay`, `rine_fulfill`).
+ *
+ * One file per domain (mirrors `schemas-groups.ts`) to keep `schemas.ts` within
+ * the ~200-LOC budget; re-exported from `schemas.ts` so the schema entry point
+ * stays single. Authored with the HOST `zod` (`import { z } from "zod"`) — the
+ * one hoisted instance Mastra validates against. Identity/credentials NEVER
+ * appear here (I-2): the acting agent + config dir come from `ctx.requestContext`.
+ *
+ * The wallet key, spend policy, caps, and facilitator auth are NEVER model
+ * inputs — they live on disk / in the toolkit config. A tool input can name a
+ * facilitator PRESET or base URL, but never carries key material or provider auth.
+ */
+import { z } from "zod";
+export declare const payInput: z.ZodObject<{
+    messageId: z.ZodString;
+    autoPay: z.ZodOptional<z.ZodBoolean>;
+    emitMarker: z.ZodOptional<z.ZodBoolean>;
+    allowRepay: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    messageId: string;
+    autoPay?: boolean | undefined;
+    emitMarker?: boolean | undefined;
+    allowRepay?: boolean | undefined;
+}, {
+    messageId: string;
+    autoPay?: boolean | undefined;
+    emitMarker?: boolean | undefined;
+    allowRepay?: boolean | undefined;
+}>;
+export declare const fulfillInput: z.ZodObject<{
+    messageId: z.ZodString;
+    facilitator: z.ZodOptional<z.ZodString>;
+    emitMarker: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    messageId: string;
+    emitMarker?: boolean | undefined;
+    facilitator?: string | undefined;
+}, {
+    messageId: string;
+    emitMarker?: boolean | undefined;
+    facilitator?: string | undefined;
+}>;

package/dist/schemas.d.ts

@@ -10,7 +10,7 @@
  *
  * `messageType`/`idempotencyKey`/etc. ports drop the Python `tag`/`jurisdiction`/
  * `pricingModel` discover fields (the TS `DiscoveryFilters` lacks them) and add
- * `enableMls` (default true) on group_create — the headline inversion (D-mls).
+ * `enableMls` (default true) on group_create — the headline inversion.
  */
 import { z } from "zod";
 export declare const threadInput: z.ZodObject<{
@@ -74,12 +74,12 @@ export declare const replyInput: z.ZodObject<{
     body: z.ZodString;
     messageType: z.ZodDefault<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
+    messageId: string;
     body: string;
     messageType: string;
-    messageId: string;
 }, {
-    body: string;
     messageId: string;
+    body: string;
     messageType?: string | undefined;
 }>;
 export declare const discoverInput: z.ZodObject<{
@@ -108,4 +108,5 @@ export declare const inspectInput: z.ZodObject<{
 }, {
     handleOrId: string;
 }>;
-export { groupCreateInput, groupInspectInput, groupInviteInput, groupRemoveInput, } from "./schemas-groups.js";
+export { groupCreateInput, groupInspectInput, groupInviteInput, groupInvitesInput, groupJoinInput, groupRemoveInput, } from "./schemas-groups.js";
+export { fulfillInput, payInput } from "./schemas-payments.js";

package/dist/tool.d.ts

@@ -15,6 +15,7 @@
  * `createTool` from `@mastra/core/tools` is invoked by each domain module; this
  * file only builds the `execute` closure and the shared option/ctx types.
  */
+import type { FacilitatorConfig } from "@rine-network/core";
 import type { AgentHandle, AgentUuid, AsyncRineClient, GroupHandle, GroupUuid } from "@rine-network/sdk";
 import { type RineClientOpts } from "./client.js";
 import { type RineToolContext } from "./context.js";
@@ -28,6 +29,30 @@ export interface RineToolOpts extends RineClientOpts {
     /** A shared client to reuse (set by `rineToolkit` for AC-11). */
     client?: AsyncRineClient;
 }
+/**
+ * Extra options the two x402 payment tools (`rine_pay`, `rine_fulfill`) accept
+ * on top of {@link RineToolOpts}, threaded from `rineToolkit({ payments })`.
+ * None carry key material: the wallet key and spend policy stay on disk, and a
+ * facilitator config carries only a URL (+ optional provider-auth headers the
+ * HOST supplies, never the model).
+ */
+export interface RinePaymentToolOpts extends RineToolOpts {
+    /**
+     * D2 auto-pay default (default OFF). When true, `rine_pay` defaults to paying
+     * ONLY quotes at/below the policy's `autoPayThreshold`; a per-call `autoPay`
+     * input still overrides it. Caps + deny-by-default + reserve-lock bound it
+     * regardless.
+     */
+    autoPay?: boolean;
+    /**
+     * The facilitator `rine_fulfill` verifies/settles through — a `FacilitatorConfig`
+     * (URL + optional auth headers) or a preset key / base-URL string. A per-call
+     * `facilitator` input overrides it.
+     */
+    facilitator?: FacilitatorConfig | string;
+    /** Default for the payment/receipt cleartext marker (default ON). */
+    emitMarker?: boolean;
+}
 /**
  * Resolve the effective `AsyncRineClient` for one `execute` call: prefer a
  * shared client from the toolkit, else build one from the ctx-injected identity
@@ -53,7 +78,7 @@ type Recipient = AgentHandle | AgentUuid | GroupHandle | GroupUuid;
 export declare function asRecipient(to: string): Recipient;
 /**
  * I-2 layer (c): the belt-and-suspenders ciphertext redactor for `read` /
- * `check_inbox` (SPEC §2.2 / D-output). Layers (a) plaintext-only renderers and
+ * `check_inbox`. Layers (a) plaintext-only renderers and
  * (b) `outputSchema: z.string()` already guarantee the `execute` return is a
  * redacted string; this coerces ANY value to plain text content before it can
  * reach the model, so even a regression that returned a richer object containing

package/dist/tools.d.ts

@@ -1,12 +1,14 @@
 /**
- * `rineToolkit(opts)` — the aggregator (SPEC §7). Returns a plain keyed
+ * `rineToolkit(opts)` — the aggregator. Returns a plain keyed
  * `Record<string, Tool>` (Mastra has no `BaseToolkit` class). The object KEY is
  * the model-facing tool name, so each entry is keyed by its `id`
  * (`toolName === id`). Drop the record straight into a Mastra `Agent`'s
  * `tools: {}` map.
  *
- * `include` curates the surface: `"all"` (12), one domain
- * (`"messaging"`/`"discovery"`/`"groups"`), or an array union of domains.
+ * `include` curates the surface: `"all"` (16), one domain
+ * (`"messaging"`/`"discovery"`/`"groups"`/`"payments"`), or an array union of
+ * domains. The `"payments"` domain (`rine_pay`, `rine_fulfill`) moves funds —
+ * bounded by the on-disk spend policy (deny-by-default) and D2 auto-pay OFF.
  *
  * AC-11 shared client: ONE lazily-built `AsyncRineClient` is created per
  * `rineToolkit(...)` call and threaded into every tool's `opts.client`, so all
@@ -17,8 +19,22 @@
  * "attach only what you need" ergonomic.
  */
 import type { Tool } from "@mastra/core/tools";
+import type { RinePaymentToolOpts } from "./tool.js";
 /** The domains a toolkit can be filtered to. */
-export type RineToolDomain = "messaging" | "discovery" | "groups";
+export type RineToolDomain = "messaging" | "discovery" | "groups" | "payments";
+/**
+ * Payment configuration for the `"payments"` domain tools (`rine_pay`,
+ * `rine_fulfill`). All optional; the tools work with sensible defaults (auto-pay
+ * OFF, marker ON) and a facilitator is only needed to `rine_fulfill`.
+ */
+export interface RinePaymentsConfig {
+    /** D2 auto-pay default (default OFF). See {@link RinePaymentToolOpts.autoPay}. */
+    autoPay?: RinePaymentToolOpts["autoPay"];
+    /** Facilitator for `rine_fulfill`. See {@link RinePaymentToolOpts.facilitator}. */
+    facilitator?: RinePaymentToolOpts["facilitator"];
+    /** Default for the cleartext marker (default ON). */
+    emitMarker?: RinePaymentToolOpts["emitMarker"];
+}
 /** Options for {@link rineToolkit}. */
 export interface RineToolkitOptions {
     /** Explicit config dir; when omitted, `resolveConfigDir()` is used. */
@@ -29,6 +45,8 @@ export interface RineToolkitOptions {
     agent?: string;
     /** Which tools to include. Default `"all"`. */
     include?: "all" | RineToolDomain | readonly RineToolDomain[];
+    /** Config for the `"payments"` domain tools (auto-pay OFF by default). */
+    payments?: RinePaymentsConfig;
 }
 /**
  * Build the rine tool record. The returned object is keyed by each tool's `id`

package/dist/types.d.ts

@@ -8,7 +8,7 @@
  * 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, 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;
@@ -19,4 +19,5 @@ export type GroupRead = Infer<typeof GroupReadSchema>;
 export type InviteResult = Infer<typeof InviteResultSchema>;
 export type AgentSummary = Infer<typeof AgentSummarySchema>;
 export type AgentProfile = Infer<typeof AgentProfileSchema>;
+export type JoinRequestRead = Infer<typeof JoinRequestReadSchema>;
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rine-network/mastra",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "Native Mastra.ai tools for the rine network \u2014 E2E-encrypted (HPKE 1:1, MLS groups, PQ-hybrid) agent-to-agent messaging, discovery, and coordination as createTool tools, a toolkit aggregator, a lifecycle bridge, a Tier-3 workflow-resume bridge, and a setup CLI.",
   "author": "mmmbs <mmmbs@proton.me>",
   "license": "EUPL-1.2",
@@ -42,8 +42,8 @@
   },
   "dependencies": {
     "@libsql/client": "^0.15.0",
-    "@rine-network/core": "^0.7.0",
-    "@rine-network/sdk": "^0.4.0"
+    "@rine-network/core": "^0.12.0",
+    "@rine-network/sdk": "^0.9.0"
   },
   "peerDependencies": {
     "@mastra/core": ">=1.0.0 <2.0.0",