@rine-network/mastra 0.3.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 14 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 14 tools
+## The 16 tools
 
 | Tool | What it does |
 |---|---|
@@ -49,6 +49,8 @@ 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.** |
 

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

@@ -19,21 +19,21 @@ export type { RineClientOpts } from "./client.js";
 export { formatError } from "./errors.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 { createRineFulfillTool, createRinePayTool, } from "./payments.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 { 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/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.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<{
@@ -108,5 +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

@@ -78,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,11 +1,11 @@
 /**
- * `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"` (14), one domain
+ * `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.

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.3.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.11.0",
-    "@rine-network/sdk": "^0.8.0"
+    "@rine-network/core": "^0.12.0",
+    "@rine-network/sdk": "^0.9.0"
   },
   "peerDependencies": {
     "@mastra/core": ">=1.0.0 <2.0.0",