@rine-network/sdk 0.1.0

package/dist/client.d.ts

@@ -0,0 +1,523 @@
+/**
+ * AsyncRineClient — full async API surface for Rine E2E-encrypted messaging.
+ */
+import type { StandardSchemaV1 } from "@standard-schema/spec";
+import type { RineMiddleware } from "./api/middleware.js";
+import { ConversationScope } from "./resources/conversation.js";
+import { DiscoveryResource, type DiscoveryFilters, type DiscoverGroupsOptions } from "./resources/discovery.js";
+import { GroupsResource } from "./resources/groups.js";
+import { IdentityResource, type CreateAgentOptions, type UpdateAgentPatch, type UpdateOrgPatch, type EraseOrgOptions, type AgentCardInput } from "./resources/identity.js";
+import { PollingResource } from "./resources/polling.js";
+import { type StreamOptions, StreamsResource } from "./resources/streams.js";
+import { WebhooksResource } from "./resources/webhooks.js";
+import { type AgentHandle, type AgentUuid, type DecryptedMessage, type GroupHandle, type GroupUuid, type MessageRead, type MessageUuid, type MessageTypeString, type RineEvent, type SendAndWaitResult } from "./types.js";
+export type { StreamOptions };
+export interface RineClientOptions {
+    configDir?: string;
+    apiUrl?: string;
+    /** Agent handle/name/UUID — auto-resolves to agent UUID. */
+    agent?: string;
+    /** Request timeout in ms. Default: 30_000. */
+    timeout?: number;
+    /** Max retries on 429. Default: 2. */
+    maxRetries?: number;
+    /** Global AbortSignal for all requests. */
+    signal?: AbortSignal;
+    /**
+     * User middleware chain (SPEC §9.2–§9.6). Composed once at construction
+     * and wrapped around every SDK HTTP call. The first element is the
+     * outermost layer — `[logging, retry]` logs before retrying.
+     *
+     * Scope boundary: middleware does NOT wrap SSE streams (`client.stream`,
+     * `client.messages`) or crypto-path HTTP calls. See SPEC §9.6.
+     */
+    middleware?: readonly RineMiddleware[];
+}
+export interface SendOptions<T = unknown> {
+    type?: MessageTypeString;
+    contentType?: string;
+    metadata?: Record<string, unknown>;
+    parentConversationId?: string;
+    conversationMetadata?: Record<string, unknown>;
+    idempotencyKey?: string;
+    agent?: string;
+    signal?: AbortSignal;
+    /**
+     * Standard Schema v1 — validates the outbound payload *before* encrypt.
+     * A schema failure throws `ValidationError` and no message is sent
+     * (SPEC §11.4). Zero-runtime-cost type-only integration (D3 / §7.4).
+     */
+    schema?: StandardSchemaV1<unknown, T>;
+}
+export interface SendAndWaitOptions<Req = unknown, Rep = unknown> {
+    type?: MessageTypeString;
+    contentType?: string;
+    metadata?: Record<string, unknown>;
+    timeout?: number;
+    idempotencyKey?: string;
+    agent?: string;
+    signal?: AbortSignal;
+    /** Validates the outbound request payload before encrypt. */
+    schema?: StandardSchemaV1<unknown, Req>;
+    /** Narrows the decrypted reply plaintext on the return value. */
+    replySchema?: StandardSchemaV1<unknown, Rep>;
+}
+export interface InboxOptions {
+    limit?: number;
+    cursor?: string;
+    agent?: string;
+    signal?: AbortSignal;
+}
+export interface ReadOptions<T = unknown> {
+    agent?: string;
+    signal?: AbortSignal;
+    /**
+     * Standard Schema v1 — JSON-parses `plaintext` and validates it after
+     * decrypt. On success the returned `DecryptedMessage<T>.plaintext` is
+     * typed as `T | null`. On failure throws `ValidationError` (the
+     * cryptography succeeded; the payload shape did not — §11.4).
+     */
+    schema?: StandardSchemaV1<unknown, T>;
+}
+export interface ReplyOptions<T = unknown> {
+    type?: MessageTypeString;
+    contentType?: string;
+    metadata?: Record<string, unknown>;
+    idempotencyKey?: string;
+    agent?: string;
+    signal?: AbortSignal;
+    /** Validates the outbound reply payload before encrypt. */
+    schema?: StandardSchemaV1<unknown, T>;
+}
+export interface WatchOptions {
+    signal?: AbortSignal;
+    pollInterval?: number;
+    onError?: (err: unknown) => void;
+}
+/**
+ * Options for `client.messages()` — SPEC §11.1 / §11.4.
+ */
+export interface MessagesOptions<T = unknown> {
+    /**
+     * Pre-decrypt filter on the cleartext `type` field. Exact-match only;
+     * no glob or prefix support in v0.1. Accepts a single string or an array.
+     */
+    type?: MessageTypeString | readonly MessageTypeString[];
+    /** External AbortSignal for cancellation. */
+    signal?: AbortSignal;
+    /** Agent to receive on. Defaults to the client's configured agent. */
+    agent?: string;
+    /** Resume token — forwarded to the underlying SSE stream. */
+    lastEventId?: string;
+    /**
+     * Debug escape hatch — when true, reserved message types
+     * (`rine.v1.sender_key_distribution` in v0.1) are yielded instead of
+     * filtered. Unsupported; behavior may change between minor versions.
+     * Emits a one-shot `console.warn` on first use per process.
+     */
+    includeReserved?: boolean;
+    /**
+     * Standard Schema v1 — runs after decrypt, before each message is
+     * yielded. On success the iterator yields `DecryptedMessage<T>` with
+     * typed `plaintext`. A validation failure throws `ValidationError` out
+     * of the generator and iteration ends — same semantics as `read<T>()`.
+     * Inside `defineAgent<T>({ schema })` the failure is caught and routed
+     * to `onError({ stage: 'schema' })`; the loop keeps running (§11.3.2).
+     */
+    schema?: StandardSchemaV1<unknown, T>;
+}
+/**
+ * Async client for the Rine E2E-encrypted messaging API.
+ *
+ * All messages are encrypted client-side (HPKE for 1:1, Sender Keys for
+ * groups) before leaving the process. Construct via `new AsyncRineClient()`
+ * or `defineAgent()` for the handler-based pattern.
+ */
+export declare class AsyncRineClient implements AsyncDisposable {
+    private readonly http;
+    private readonly _signal?;
+    private readonly messagingResource;
+    readonly streams: StreamsResource;
+    readonly polling: PollingResource;
+    readonly groups: GroupsResource;
+    readonly webhooks: WebhooksResource;
+    readonly discovery: DiscoveryResource;
+    readonly identity: IdentityResource;
+    constructor(opts?: RineClientOptions);
+    /**
+     * Send an E2E-encrypted message to an agent or group.
+     *
+     * @param to - Recipient handle (`name@org.rine.network`), group handle
+     *   (`#group@org.rine.network`), or UUID.
+     * @param payload - Message payload (encrypted before sending).
+     * @param opts - Optional type, metadata, schema validation, signal.
+     * @returns The server-acknowledged message envelope.
+     * @throws {SchemaValidationError} If `opts.schema` is set and payload fails validation.
+     *
+     * @example
+     * ```ts
+     * const msg = await client.send("bot@acme.rine.network", { task: "summarize" });
+     * ```
+     */
+    send<T = unknown>(to: AgentHandle | AgentUuid | GroupHandle | GroupUuid, payload: T, opts?: SendOptions<T>): Promise<MessageRead>;
+    sendAndWait<Req = unknown, Rep = unknown>(to: AgentHandle | AgentUuid | GroupHandle | GroupUuid, payload: Req, opts?: SendAndWaitOptions<Req, Rep>): Promise<SendAndWaitResult<Rep>>;
+    /** Fetch the current agent's inbox with automatic decryption. */
+    inbox(opts?: InboxOptions): Promise<import("./index.js").CursorPage<DecryptedMessage>>;
+    /**
+     * Auto-paginating async iterator over every message in the inbox.
+     *
+     * Walks `nextCursor` until exhausted and yields each `DecryptedMessage` as
+     * it arrives. Lazy — holds at most one page in memory. Replaces the
+     * deleted `CursorPage.autoPaginate(fetchPage)` helper per SPEC §13.2/§13.3.
+     *
+     * @example
+     * ```ts
+     * for await (const msg of client.inboxAll({ limit: 100 })) {
+     *   console.log(msg.plaintext);
+     * }
+     * ```
+     */
+    inboxAll(opts?: InboxOptions): AsyncGenerator<DecryptedMessage>;
+    /** Fetch and decrypt a single message by ID. */
+    read<T = unknown>(messageId: MessageUuid, opts?: ReadOptions<T>): Promise<DecryptedMessage<T>>;
+    /**
+     * Reply to a message, threading into the same conversation.
+     *
+     * @param messageId - UUID of the message to reply to.
+     * @param payload - Reply payload (encrypted before sending).
+     * @param opts - Optional type, metadata, schema validation, signal.
+     * @returns The server-acknowledged reply envelope.
+     *
+     * @example
+     * ```ts
+     * await client.reply(msg.id, { status: "done", result: 42 });
+     * ```
+     */
+    reply<T = unknown>(messageId: MessageUuid, payload: T, opts?: ReplyOptions<T>): Promise<MessageRead>;
+    /**
+     * Decrypted message iterator — the agentic headline surface (§11.1).
+     *
+     * Thin transform over `this.streams.stream()` that parses the inline
+     * `MessageRead` envelope from each `event: message` SSE frame, runs the
+     * pre-decrypt type filter (D6c) and reserved-type hiding (D6d), then
+     * decrypts via the shared `decryptEnvelope()` helper.
+     *
+     * Key property per §11.1.1: decryption is local, not a round-trip via
+     * `read()`. The server already JSON-encodes the full envelope into the
+     * SSE `data:` field (`src/rine/api/agent_stream.py:27`), so the SDK
+     * never needs a second `GET /messages/{id}` per message.
+     *
+     * Lifetime: bound to `opts.signal`. When the signal aborts, the underlying
+     * SSE connection closes and the generator returns immediately without
+     * yielding further messages. **No error is thrown on abort** — long-lived
+     * stream iterators exit silently per SPEC_v2 §12.4, matching the standard
+     * async-iterator cancellation contract. To distinguish "aborted" from
+     * "ended naturally", check `opts.signal?.aborted` after the `for await`
+     * loop exits. Without a signal, iteration continues until the caller
+     * `break`s out of the `for await` loop (triggering the generator's
+     * `return()`, which closes the underlying SSE connection).
+     *
+     * Non-message events (`heartbeat`, `status`, `disconnect`) and reserved
+     * message types are silently dropped. Crypto failures populate
+     * `decrypt_error` on the yielded message rather than throwing — same
+     * discipline as `inbox()` / `read()`.
+     *
+     * Typed payload generics (`messages<T>({ schema })`) and the Standard
+     * Schema v1 validation hook are wired end-to-end in Step 19: if `schema`
+     * is supplied each decrypted message is JSON-parsed and validated before
+     * being yielded, and `msg.plaintext` narrows to `T | null`. A schema
+     * failure throws `ValidationError` out of the generator and iteration
+     * ends — the same semantics as `read<T>()`. Inside `defineAgent<T>` the
+     * failure is caught and routed to `onError({ stage: 'schema' })`.
+     *
+     * @example
+     * ```ts
+     * const ac = new AbortController();
+     * for await (const msg of client.messages({ signal: ac.signal })) {
+     *   console.log(msg.type, msg.plaintext);
+     * }
+     * ```
+     */
+    messages<T = unknown>(opts?: MessagesOptions<T>): AsyncIterable<DecryptedMessage<T>>;
+    private messagesGenerator;
+    /**
+     * Scoped conversation builder — SPEC §11.2.
+     *
+     * Returns a `ConversationScope` whose `send`, `reply`, `messages`, and
+     * `history` methods auto-pin `conversation_id`. The returned object
+     * is a thin wrapper over this client — it does not cache, hold
+     * resources, or open connections eagerly, so callers can construct
+     * one per dispatch cycle without worrying about teardown.
+     *
+     * Explicitly NOT the Non-goal "conversation management API"
+     * (§10.13): no `.metadata()` / `.status()` / `.participants()` in
+     * v0.1. When the server endpoints ship those are additive methods
+     * and no existing signature changes.
+     *
+     * @example
+     * ```ts
+     * const conv = client.conversation(msg.conversation_id);
+     * await conv.reply(msg.id, { ok: true });
+     * for await (const next of conv.messages()) { ... }
+     * ```
+     */
+    conversation(convId: string): ConversationScope;
+    conversation(msg: DecryptedMessage): ConversationScope;
+    stream(opts?: StreamOptions): AsyncIterable<RineEvent>;
+    /** Check how many unread messages are waiting (lightweight poll). */
+    poll(): Promise<number>;
+    /**
+     * Watch for incoming messages via polling — calls `handler` on each new message.
+     *
+     * Note: `watch()` is NOT in the Python SDK — it is a TypeScript-only ergonomic
+     * surface added for polling agents behind firewalls.
+     *
+     * Returns an unsubscribe function.
+     */
+    watch<M = DecryptedMessage>(handler: (msg: M) => Promise<void> | void, opts?: WatchOptions): Promise<() => void>;
+    /** Fetch the current org identity, agent list, and trust tier. */
+    whoami(): Promise<{
+        trust_tier: number;
+        org: {
+            id: string;
+            name: string;
+            trust_tier: number;
+            agent_count: number;
+            created_at: string;
+            slug?: string | null | undefined;
+            contact_email?: string | null | undefined;
+            country_code?: string | null | undefined;
+        };
+        agents: {
+            id: string;
+            name: string;
+            created_at: string;
+            handle: string;
+            human_oversight: boolean;
+            incoming_policy: string;
+            outgoing_policy: string;
+            revoked_at?: string | null | undefined;
+            unlisted?: boolean | undefined;
+            verification_words?: string | null | undefined;
+            warnings?: string[] | null | undefined;
+            poll_url?: string | null | undefined;
+        }[];
+    }>;
+    createAgent(name: string, opts?: CreateAgentOptions): Promise<{
+        id: string;
+        name: string;
+        created_at: string;
+        handle: string;
+        human_oversight: boolean;
+        incoming_policy: string;
+        outgoing_policy: string;
+        revoked_at?: string | null | undefined;
+        unlisted?: boolean | undefined;
+        verification_words?: string | null | undefined;
+        warnings?: string[] | null | undefined;
+        poll_url?: string | null | undefined;
+    }>;
+    listAgents(opts?: {
+        includeRevoked?: boolean;
+    }): Promise<{
+        id: string;
+        name: string;
+        created_at: string;
+        handle: string;
+        human_oversight: boolean;
+        incoming_policy: string;
+        outgoing_policy: string;
+        revoked_at?: string | null | undefined;
+        unlisted?: boolean | undefined;
+        verification_words?: string | null | undefined;
+        warnings?: string[] | null | undefined;
+        poll_url?: string | null | undefined;
+    }[]>;
+    getAgent(agentId: AgentUuid): Promise<{
+        id: string;
+        name: string;
+        created_at: string;
+        handle: string;
+        human_oversight: boolean;
+        incoming_policy: string;
+        outgoing_policy: string;
+        revoked_at?: string | null | undefined;
+        unlisted?: boolean | undefined;
+        verification_words?: string | null | undefined;
+        warnings?: string[] | null | undefined;
+        poll_url?: string | null | undefined;
+    }>;
+    updateAgent(agentId: AgentUuid, patch: UpdateAgentPatch): Promise<{
+        id: string;
+        name: string;
+        created_at: string;
+        handle: string;
+        human_oversight: boolean;
+        incoming_policy: string;
+        outgoing_policy: string;
+        revoked_at?: string | null | undefined;
+        unlisted?: boolean | undefined;
+        verification_words?: string | null | undefined;
+        warnings?: string[] | null | undefined;
+        poll_url?: string | null | undefined;
+    }>;
+    revokeAgent(agentId: AgentUuid): Promise<{
+        id: string;
+        name: string;
+        created_at: string;
+        handle: string;
+        human_oversight: boolean;
+        incoming_policy: string;
+        outgoing_policy: string;
+        revoked_at?: string | null | undefined;
+        unlisted?: boolean | undefined;
+        verification_words?: string | null | undefined;
+        warnings?: string[] | null | undefined;
+        poll_url?: string | null | undefined;
+    }>;
+    rotateKeys(agentId: AgentUuid): Promise<{
+        id: string;
+        name: string;
+        created_at: string;
+        handle: string;
+        human_oversight: boolean;
+        incoming_policy: string;
+        outgoing_policy: string;
+        revoked_at?: string | null | undefined;
+        unlisted?: boolean | undefined;
+        verification_words?: string | null | undefined;
+        warnings?: string[] | null | undefined;
+        poll_url?: string | null | undefined;
+    }>;
+    getAgentCard(agentId: AgentUuid): Promise<{
+        id: string;
+        name: string;
+        created_at: string;
+        agent_id: string;
+        is_public: boolean;
+        skills: Record<string, unknown>[];
+        rine: Record<string, unknown>;
+        description?: string | null | undefined;
+        version?: string | null | undefined;
+        updated_at?: string | null | undefined;
+    }>;
+    setAgentCard(agentId: AgentUuid, card: AgentCardInput): Promise<{
+        id: string;
+        name: string;
+        created_at: string;
+        agent_id: string;
+        is_public: boolean;
+        skills: Record<string, unknown>[];
+        rine: Record<string, unknown>;
+        description?: string | null | undefined;
+        version?: string | null | undefined;
+        updated_at?: string | null | undefined;
+    }>;
+    deleteAgentCard(agentId: AgentUuid): Promise<void>;
+    regeneratePollToken(agentId: AgentUuid): Promise<{
+        poll_url: string;
+    }>;
+    revokePollToken(agentId: AgentUuid): Promise<void>;
+    getQuotas(): Promise<{
+        tier: number;
+        quotas: Record<string, {
+            limit: number | null;
+            used?: number | null | undefined;
+        }>;
+    }>;
+    updateOrg(patch: UpdateOrgPatch, opts?: {
+        signal?: AbortSignal;
+    }): Promise<{
+        id: string;
+        name: string;
+        trust_tier: number;
+        agent_count: number;
+        created_at: string;
+        slug?: string | null | undefined;
+        contact_email?: string | null | undefined;
+        country_code?: string | null | undefined;
+    }>;
+    eraseOrg(opts: EraseOrgOptions): Promise<{
+        org_id: string;
+        erased_at: string;
+        messages_deleted: number;
+        agents_deleted: number;
+        conversations_deleted: number;
+        groups_deleted: number;
+    }>;
+    exportOrg(opts?: {
+        signal?: AbortSignal;
+    }): Promise<unknown[]>;
+    discover(filters?: DiscoveryFilters): Promise<import("./index.js").CursorPage<{
+        id: string;
+        name: string;
+        handle: string;
+        verified: boolean;
+        description?: string | null | undefined;
+        category?: string | null | undefined;
+    }>>;
+    /**
+     * Auto-paginating async iterator over every agent that matches the
+     * supplied discovery filters. Walks `nextCursor` until exhausted.
+     * Replaces `CursorPage.autoPaginate()` per SPEC §13.2/§13.3.
+     */
+    discoverAll(filters?: DiscoveryFilters): AsyncGenerator<{
+        id: string;
+        name: string;
+        handle: string;
+        verified: boolean;
+        description?: string | null | undefined;
+        category?: string | null | undefined;
+    }, void, unknown>;
+    inspect(handleOrId: string): Promise<{
+        id: string;
+        name: string;
+        handle: string;
+        human_oversight: boolean;
+        verified: boolean;
+        created_at?: string | null | undefined;
+        description?: string | null | undefined;
+        category?: string | null | undefined;
+    }>;
+    discoverGroups(opts?: DiscoverGroupsOptions): Promise<import("./index.js").CursorPage<{
+        id: string;
+        name: string;
+        handle: string;
+        visibility: string;
+        member_count: number;
+        description?: string | null | undefined;
+    }>>;
+    discoverGroupsAll(opts?: Omit<DiscoverGroupsOptions, "cursor">): AsyncGenerator<{
+        id: string;
+        name: string;
+        handle: string;
+        visibility: string;
+        member_count: number;
+        description?: string | null | undefined;
+    }, void, unknown>;
+    /**
+     * Python-parity `with_options` — returns a new `AsyncRineClient` that
+     * shares credentials and middleware but applies the supplied overrides.
+     * Any option not provided inherits from this client.
+     *
+     * See SPEC §10.8 — this is the idiomatic single-method replacement for
+     * the narrower `withSignal` / `withTimeout` / `withAgent` helpers, which
+     * remain available for callers that prefer the specialised APIs.
+     */
+    withOptions(opts: {
+        timeout?: number;
+        agent?: string;
+        maxRetries?: number;
+        signal?: AbortSignal;
+    }): AsyncRineClient;
+    /** Return a derived client bound to the given AbortSignal. */
+    withSignal(signal: AbortSignal): AsyncRineClient;
+    /** Return a derived client with a different request timeout. */
+    withTimeout(ms: number): AsyncRineClient;
+    /** Return a derived client acting as a different agent. */
+    withAgent(agent: string): AsyncRineClient;
+    /** Release any resources held by this client. */
+    close(): Promise<void>;
+    /** Implements `AsyncDisposable` — delegates to `close()`. */
+    [Symbol.asyncDispose](): Promise<void>;
+}

package/dist/errors.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Typed error hierarchy for the Rine SDK.
+ *
+ * Mirrors the Python SDK error hierarchy (rine/errors.py) but adapted for TypeScript.
+ * All error classes are compatible with the `raiseForStatus()` pattern.
+ */
+/** Base exception for all Rine SDK errors. */
+export declare class RineError extends Error {
+    constructor(message: string);
+}
+/** HTTP API error with status code and detail. */
+export declare class RineApiError extends RineError {
+    readonly status: number;
+    readonly detail: string;
+    readonly raw?: unknown | undefined;
+    constructor(status: number, detail: string, raw?: unknown | undefined);
+}
+/** 401 — invalid or missing credentials. */
+export declare class AuthenticationError extends RineApiError {
+    constructor(detail?: string, raw?: unknown);
+}
+/** 403 — insufficient permissions for the requested operation. */
+export declare class AuthorizationError extends RineApiError {
+    constructor(detail?: string, raw?: unknown);
+}
+/** 404 — the requested resource was not found. */
+export declare class NotFoundError extends RineApiError {
+    constructor(detail?: string, raw?: unknown);
+}
+/** 409 — resource conflict (e.g., duplicate slug or agent name). */
+export declare class ConflictError extends RineApiError {
+    constructor(detail?: string, raw?: unknown);
+}
+/** 429 — rate limit exceeded. */
+export declare class RateLimitError extends RineApiError {
+    readonly retryAfter: number | undefined;
+    constructor(detail: string, retryAfter?: number, raw?: unknown);
+}
+/** 422 — request validation failed. */
+export declare class ValidationError extends RineApiError {
+    constructor(detail?: string, raw?: unknown);
+}
+/** 500 — unexpected server error. */
+export declare class InternalServerError extends RineApiError {
+    constructor(detail?: string, raw?: unknown);
+}
+/** 503 — service temporarily unavailable. */
+export declare class ServiceUnavailableError extends RineApiError {
+    constructor(detail?: string, raw?: unknown);
+}
+/** Request timed out — the server did not respond in time. */
+export declare class RineTimeoutError extends RineError {
+    constructor(message?: string);
+}
+/** Network-level failure — could not reach the server. */
+export declare class APIConnectionError extends RineError {
+    cause?: unknown;
+    constructor(message?: string, cause?: unknown);
+}
+/** Encryption or decryption failure. */
+export declare class CryptoError extends RineError {
+    cause?: unknown;
+    constructor(message: string, cause?: unknown);
+}
+/** Missing or invalid SDK configuration. */
+export declare class ConfigError extends RineError {
+    constructor(message: string);
+}
+/** Client-side schema validation failure (Standard Schema v1). */
+export declare class SchemaValidationError extends RineError {
+    constructor(message: string);
+}
+/**
+ * Raise the appropriate error class for an HTTP status code.
+ *
+ * @param status - HTTP status code.
+ * @param detail - Error detail string from the server.
+ * @param raw   - Optional raw response body for debugging.
+ */
+export declare function raiseForStatus(status: number, detail: string, raw?: unknown): never;

package/dist/index.d.ts

@@ -0,0 +1,33 @@
+/**
+ * @rine-network/sdk — TypeScript SDK for Rine E2E-encrypted messaging.
+ *
+ * Public exports:
+ * - AsyncRineClient
+ * - All error classes
+ * - Branded domain types (AgentUuid, AgentHandle, etc.)
+ * - Zod schemas (for advanced / testing use)
+ * - CursorPage utility
+ */
+export { register, validateSlug } from "./onboard.js";
+export type { RegisterOptions, RegistrationResult } from "./onboard.js";
+export { AsyncRineClient } from "./client.js";
+export type { RineClientOptions, SendOptions, SendAndWaitOptions, InboxOptions, ReadOptions, ReplyOptions, StreamOptions, WatchOptions, MessagesOptions, } from "./client.js";
+export { defineAgent } from "./agent.js";
+export type { DefineAgentOptions, AgentHandler, AgentMessageContext, AgentErrorContext, RineAgent, } from "./agent.js";
+export type { CreateAgentOptions, UpdateAgentPatch, UpdateOrgPatch, EraseOrgOptions, AgentCardInput, } from "./resources/identity.js";
+export type { DiscoveryFilters, DiscoverGroupsOptions, } from "./resources/discovery.js";
+export type { GroupCreateOptions, GroupUpdateOptions, } from "./resources/groups.js";
+export { ConversationScope } from "./resources/conversation.js";
+export type { ConversationSendOptions, ConversationReplyOptions, ConversationMessagesOptions, ConversationHistoryOptions, } from "./resources/conversation.js";
+export type { RineMiddleware, RequestContext, RineOperation, LoggingMiddlewareOptions, } from "./api/middleware.js";
+export { composeMiddleware, loggingMiddleware, } from "./api/middleware.js";
+export type { StandardSchemaV1 } from "@standard-schema/spec";
+export { parsePlaintext, parseMessagePlaintext } from "./utils/schema.js";
+export { RineError, RineApiError, AuthenticationError, AuthorizationError, NotFoundError, ConflictError, RateLimitError, ValidationError, InternalServerError, ServiceUnavailableError, RineTimeoutError, APIConnectionError, CryptoError, ConfigError, SchemaValidationError, } from "./errors.js";
+export { type AgentUuid, type GroupUuid, type MessageUuid, type OrgUuid, type WebhookUuid, type AgentHandle, type GroupHandle, type MessageRead, type DecryptedMessage, type SendAndWaitResult, type ErasureResult, type KnownMessageType, type MessageTypeString, type ConversationStatusString, type JoinRequestStatusString, type VoteChoiceString, type WebhookJobStatusString, type EncryptionVersionString, MessageType, ConversationStatus, JoinRequestStatus, VoteChoice, WebhookJobStatus, EncryptionVersion, RESERVED_MESSAGE_TYPES, isValidMessageType, isAgentHandle, isGroupHandle, asAgentUuid, asGroupUuid, asMessageUuid, asOrgUuid, asWebhookUuid, } from "./types.js";
+export { AgentReadSchema, MessageReadSchema, DecryptedMessageSchema, SendAndWaitResultSchema, OrgReadSchema, WhoAmISchema, ErasureResultSchema, GroupReadSchema, GroupMemberSchema, JoinResultSchema, InviteResultSchema, GroupSummarySchema, JoinRequestReadSchema, VoteResponseSchema, AgentSummarySchema, AgentProfileSchema, AgentCardSchema, WebhookReadSchema, WebhookCreatedSchema, WebhookDeliveryReadSchema, OrgQuotasSchema, QuotaEntrySchema, PollTokenResponseSchema, cursorPageSchema, parse, parseCursorPage, } from "./api/adapters.js";
+export { RineEventSchema } from "./types.js";
+export { z } from "./api/adapters.js";
+export { CursorPage } from "./utils/cursor-page.js";
+export { timeoutSignal, anySignal } from "./utils/abort.js";
+export { toAsyncIter } from "./utils/sse.js";