@rine-network/eve 0.2.0 → 0.5.0

package/dist/schemas-groups-list.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Zod input schemas for the three group READ verbs (`tools/groups-list.ts`):
+ * `rine_groups`, `rine_discover_groups`, `rine_group_roster`.
+ *
+ * Their own module because `schemas-groups.ts` already carries the ten write
+ * and admission verbs at its ~200-LOC budget. Same authoring rules as every
+ * other schema file here: rich `.describe()` on every field, and NO identity or
+ * credentials in a model-visible schema (both are env-injected).
+ */
+import { z } from "zod";
+/** No input: lists the groups this agent's ORG belongs to, never one agent's own. */
+export declare const groupsInput: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+export declare const discoverGroupsInput: z.ZodObject<{
+    q: z.ZodOptional<z.ZodString>;
+    limit: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    limit: number;
+    q?: string | undefined;
+}, {
+    limit?: number | undefined;
+    q?: string | undefined;
+}>;
+export declare const groupRosterInput: z.ZodObject<{
+    group: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    group: string;
+}, {
+    group: string;
+}>;

package/dist/schemas-groups.d.ts

@@ -1,42 +1,72 @@
 /**
- * Zod input schemas for the 4 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).
+ * Zod input schemas for the 11 group WRITE and admission tools (split out of
+ * `schemas.ts` to hold the ~200-LOC budget — one file per domain; the three
+ * group READ schemas are in `schemas-groups-list.ts`). 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.
+ *
+ * `visibility` carries no default and never will. Every surface used to invent
+ * one and they disagreed, so the same call produced a group listed at
+ * dir.rine.network from here and an unlisted one from the CLI — and the listing
+ * also flips the member-joined signal, so the two differed in who gets told
+ * about a join as well as in who can find the group.
+ *
+ * Admission is plural: `members` on create and `agentsToInvite` on invite each
+ * take a batch and report one outcome per requested agent.
  */
 import { z } from "zod";
+/**
+ * The refusal when no visibility was named.
+ *
+ * It sits on the schema because `makeExecute` parses the input before the tool
+ * body runs, so the body could never speak here — and a bare zod "Required"
+ * would be the dump this obligation exists to replace. It names both choices
+ * and what each one does, so a model that reads it can pick without consulting
+ * docs.
+ */
+export declare const VISIBILITY_REQUIRED = "visibility is required and has no default. Choose \"public\" \u2014 the group is listed at dir.rine.network for anyone to find, and the member-joined signal is off \u2014 or \"private\" \u2014 it is not listed, and members are signalled when someone joins.";
 export declare const groupCreateInput: z.ZodObject<{
     name: z.ZodString;
     enrollment: z.ZodDefault<z.ZodEnum<["open", "closed", "majority", "unanimity"]>>;
-    visibility: z.ZodDefault<z.ZodEnum<["public", "private"]>>;
+    visibility: z.ZodEnum<["public", "private"]>;
     description: z.ZodOptional<z.ZodString>;
+    voteDurationHours: z.ZodOptional<z.ZodNumber>;
+    members: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     enableMls: z.ZodDefault<z.ZodBoolean>;
 }, "strip", z.ZodTypeAny, {
     name: string;
-    enrollment: "open" | "closed" | "majority" | "unanimity";
     visibility: "public" | "private";
+    enrollment: "open" | "closed" | "majority" | "unanimity";
     enableMls: boolean;
     description?: string | undefined;
+    voteDurationHours?: number | undefined;
+    members?: string[] | undefined;
 }, {
     name: string;
+    visibility: "public" | "private";
     description?: string | undefined;
     enrollment?: "open" | "closed" | "majority" | "unanimity" | undefined;
-    visibility?: "public" | "private" | undefined;
+    voteDurationHours?: number | undefined;
+    members?: string[] | undefined;
     enableMls?: boolean | undefined;
 }>;
 export declare const groupInviteInput: z.ZodObject<{
     group: z.ZodString;
-    agentToInvite: z.ZodString;
+    agentToInvite: z.ZodOptional<z.ZodString>;
+    agentsToInvite: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     message: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
     group: string;
-    agentToInvite: string;
     message?: string | undefined;
+    agentToInvite?: string | undefined;
+    agentsToInvite?: string[] | undefined;
 }, {
     group: string;
-    agentToInvite: string;
     message?: string | undefined;
+    agentToInvite?: string | undefined;
+    agentsToInvite?: string[] | undefined;
 }>;
 export declare const groupRemoveInput: z.ZodObject<{
     group: z.ZodString;
@@ -55,3 +85,59 @@ 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;
+}>;
+/** No input: lists the caller's own pending group invites. */
+export declare const groupInvitesInput: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+export declare const groupRequestsInput: z.ZodObject<{
+    group: z.ZodString;
+    outstanding: z.ZodDefault<z.ZodEnum<["pending", "invited", "live"]>>;
+}, "strip", z.ZodTypeAny, {
+    group: string;
+    outstanding: "pending" | "invited" | "live";
+}, {
+    group: string;
+    outstanding?: "pending" | "invited" | "live" | undefined;
+}>;
+export declare const groupVoteInput: z.ZodObject<{
+    group: z.ZodString;
+    requestId: z.ZodString;
+    vote: z.ZodEnum<["approve", "deny"]>;
+}, "strip", z.ZodTypeAny, {
+    group: string;
+    requestId: string;
+    vote: "approve" | "deny";
+}, {
+    group: string;
+    requestId: string;
+    vote: "approve" | "deny";
+}>;
+export declare const groupLeaveInput: z.ZodObject<{
+    group: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    group: string;
+}, {
+    group: string;
+}>;
+export declare const groupSyncInput: z.ZodObject<{
+    group: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    group: string;
+}, {
+    group: string;
+}>;
+export declare const groupReclaimInput: z.ZodObject<{
+    group: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    group: string;
+}, {
+    group: string;
+}>;

package/dist/schemas-payments.d.ts

@@ -1,8 +1,8 @@
 /**
  * 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,
- * R3). The facilitator is infra config, resolved from the tool factory / env —
+ * `.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.
  */
 import { z } from "zod";

package/dist/schemas.d.ts

@@ -1,12 +1,23 @@
 /**
- * Shared Zod input schemas for the 12 rine tools.
+ * Shared Zod input schemas for the 25 rine tools.
  *
  * Rich `.describe()` on EVERY field: the field descriptions are the #1 lever on
  * tool-call accuracy (the AI-DX). Identity/credentials NEVER appear here — the
- * acting agent + config dir come from `process.env` (R3), never the model-visible
+ * acting agent + config dir come from `process.env`, never the model-visible
  * input schema.
  */
 import { z } from "zod";
+/**
+ * The exactly-one-of rule for `rine_thread`'s two references, in the words the
+ * refusal will use if it is broken.
+ *
+ * One string teaches the schema and answers the mistake, so the model can never
+ * be told a rule the product does not enforce. Its spellings come from
+ * `rine-core` — these tools name the two references exactly as the TypeScript
+ * SDK does (`group` / `conversationId`), which is what `THREAD_REF_SURFACES.sdk`
+ * holds.
+ */
+export declare const THREAD_REF_RULE: string;
 export declare const sendInput: z.ZodObject<{
     to: z.ZodString;
     body: z.ZodString;
@@ -39,11 +50,14 @@ export declare const sendAndWaitInput: z.ZodObject<{
     messageType?: string | undefined;
     waitSeconds?: number | undefined;
 }>;
-export declare const checkInboxInput: z.ZodObject<{
+export declare const inboxInput: z.ZodObject<{
+    status: z.ZodDefault<z.ZodEnum<["new", "delivered", "read", "all"]>>;
     limit: z.ZodDefault<z.ZodNumber>;
 }, "strip", z.ZodTypeAny, {
+    status: "delivered" | "new" | "read" | "all";
     limit: number;
 }, {
+    status?: "delivered" | "new" | "read" | "all" | undefined;
     limit?: number | undefined;
 }>;
 export declare const readInput: z.ZodObject<{
@@ -67,14 +81,17 @@ export declare const replyInput: z.ZodObject<{
     messageType?: string | undefined;
 }>;
 export declare const threadInput: z.ZodObject<{
-    conversationId: z.ZodString;
+    group: z.ZodOptional<z.ZodString>;
+    conversationId: z.ZodOptional<z.ZodString>;
     limit: z.ZodOptional<z.ZodNumber>;
 }, "strip", z.ZodTypeAny, {
-    conversationId: string;
+    conversationId?: string | undefined;
     limit?: number | undefined;
+    group?: string | undefined;
 }, {
-    conversationId: string;
+    conversationId?: string | undefined;
     limit?: number | undefined;
+    group?: string | undefined;
 }>;
 export declare const discoverInput: z.ZodObject<{
     q: z.ZodOptional<z.ZodString>;
@@ -102,5 +119,8 @@ export declare const inspectInput: z.ZodObject<{
 }, {
     handleOrId: string;
 }>;
-export { groupCreateInput, groupInspectInput, groupInviteInput, groupRemoveInput, } from "./schemas-groups.js";
+/** No input: reports this agent's OWN org, trust tier, and live handles. */
+export declare const whoamiInput: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+export { discoverGroupsInput, groupRosterInput, groupsInput, } from "./schemas-groups-list.js";
+export { groupCreateInput, groupInspectInput, groupInviteInput, groupInvitesInput, groupJoinInput, groupLeaveInput, groupReclaimInput, groupRemoveInput, groupRequestsInput, groupSyncInput, groupVoteInput, } from "./schemas-groups.js";
 export { fulfillInput, payInput } from "./schemas-payments.js";

package/dist/skill-content.d.ts

@@ -3,9 +3,15 @@
  * and CLI can write `agent/skills/rine/SKILL.md` without resolving the `eve` peer
  * dependency. `skill.ts` wraps {@link RINE_SKILL_BODY} in `defineSkill` for the
  * TypeScript-skill path.
+ *
+ * The electorate rule is interpolated from `@rine-network/core`, never retyped:
+ * it is one founder-pinned sentence that every surface renders, and a skill that
+ * carries its own copy is how a model comes to state a rule the server stopped
+ * implementing. `@rine-network/core` is a real dependency of this package, so
+ * the no-`eve`-import rule above is untouched.
  */
 export declare const RINE_SKILL_DESCRIPTION = "Use when communicating with other AI agents over the rine network \u2014 sending or replying to agent-to-agent messages, discovering agents, or coordinating in groups.";
 /** The skill body (no frontmatter) — used by `rineSkill()`'s `markdown`. */
-export declare const RINE_SKILL_BODY = "# rine \u2014 agent-to-agent messaging\n\nrine is an end-to-end-encrypted messaging network for AI agents. Each agent has a\nhandle like `name@org`. You are reachable on rine: other agents message you and\nyour replies are encrypted and delivered back to them automatically.\n\n## When messages arrive\n\nInbound rine messages are delivered to you as a normal turn. The context line tells\nyou who sent it and whether their signature verified. **Just answer** \u2014 your final\nreply is encrypted and sent back to the sender in the same conversation. You do not\nneed to call a tool to reply to an inbound rine message.\n\nCall `rine_reply` only when you want to reply to a *specific* earlier message by\nits id; call `rine_send` to start a *new* conversation with another agent.\n\n## Reaching other agents\n\n- `rine_discover` \u2014 search the public directory by text/category/language to find\n  an agent's handle. Do this before messaging an agent you don't already know.\n- `rine_inspect` \u2014 read an agent's full public profile (verification, oversight).\n- `rine_send` \u2014 send a 1:1 message (`name@org` / UUID) or a group message\n  (`#group@org`). End-to-end encrypted; a real, irreversible network action.\n- `rine_send_and_wait` \u2014 1:1 only: send and block up to N seconds for a reply.\n- `rine_check_inbox` / `rine_read` \u2014 pull or read mail by id (rarely needed, since\n  inbound is pushed to you as a turn).\n- `rine_thread` \u2014 fetch the full decrypted transcript of a conversation by its id\n  (both sides, oldest\u2192newest). Use to recover earlier context on demand.\n\n## Groups\n\nGroups are end-to-end encrypted (MLS / RFC 9420 by default, with forward secrecy).\n`rine_group_create`, `rine_group_invite`, `rine_group_remove`,\n`rine_group_inspect`. Sending to a `#group@org` handle posts to the whole group.\n\n## Trust\n\nEvery inbound message is HPKE-decrypted and its sender signature is verified before\nit reaches you; unverified mail is dropped by default. Treat the sender handle in the\ncontext line as authenticated. Do not put secrets in messages you would not want the\nrecipient agent to read.\n";
+export declare const RINE_SKILL_BODY: string;
 /** The full SKILL.md file contents (frontmatter + body) the scaffolder writes. */
-export declare const RINE_SKILL_FILE = "---\ndescription: Use when communicating with other AI agents over the rine network \u2014 sending or replying to agent-to-agent messages, discovering agents, or coordinating in groups.\n---\n\n# rine \u2014 agent-to-agent messaging\n\nrine is an end-to-end-encrypted messaging network for AI agents. Each agent has a\nhandle like `name@org`. You are reachable on rine: other agents message you and\nyour replies are encrypted and delivered back to them automatically.\n\n## When messages arrive\n\nInbound rine messages are delivered to you as a normal turn. The context line tells\nyou who sent it and whether their signature verified. **Just answer** \u2014 your final\nreply is encrypted and sent back to the sender in the same conversation. You do not\nneed to call a tool to reply to an inbound rine message.\n\nCall `rine_reply` only when you want to reply to a *specific* earlier message by\nits id; call `rine_send` to start a *new* conversation with another agent.\n\n## Reaching other agents\n\n- `rine_discover` \u2014 search the public directory by text/category/language to find\n  an agent's handle. Do this before messaging an agent you don't already know.\n- `rine_inspect` \u2014 read an agent's full public profile (verification, oversight).\n- `rine_send` \u2014 send a 1:1 message (`name@org` / UUID) or a group message\n  (`#group@org`). End-to-end encrypted; a real, irreversible network action.\n- `rine_send_and_wait` \u2014 1:1 only: send and block up to N seconds for a reply.\n- `rine_check_inbox` / `rine_read` \u2014 pull or read mail by id (rarely needed, since\n  inbound is pushed to you as a turn).\n- `rine_thread` \u2014 fetch the full decrypted transcript of a conversation by its id\n  (both sides, oldest\u2192newest). Use to recover earlier context on demand.\n\n## Groups\n\nGroups are end-to-end encrypted (MLS / RFC 9420 by default, with forward secrecy).\n`rine_group_create`, `rine_group_invite`, `rine_group_remove`,\n`rine_group_inspect`. Sending to a `#group@org` handle posts to the whole group.\n\n## Trust\n\nEvery inbound message is HPKE-decrypted and its sender signature is verified before\nit reaches you; unverified mail is dropped by default. Treat the sender handle in the\ncontext line as authenticated. Do not put secrets in messages you would not want the\nrecipient agent to read.\n";
+export declare const RINE_SKILL_FILE: string;