crewai-rine 0.1.0__tar.gz

crewai_rine-0.1.0/.e2e.env

@@ -0,0 +1,6 @@
+# Gitignored — live-LLM-crew E2E secrets/config (NEVER commit).
+# Together.ai OpenAI-compatible endpoint. Sourced into the rig env and passed through
+# by NAME (-e TOGETHER_API_KEY ...), so the key never lands on a command line or in git.
+TOGETHER_API_KEY=tgp_v1_zI_GAGQ1bIKcdzi_nVZqbHlAMN-o-WphfMoOBhgTQ6E
+RINE_E2E_MODEL=meta-llama/Llama-3.3-70B-Instruct-Turbo
+RINE_E2E_BASE_URL=https://api.together.xyz/v1

crewai_rine-0.1.0/.gitignore

@@ -0,0 +1,12 @@
+__pycache__/
+*.py[cod]
+.venv/
+.mypy_cache/
+.pytest_cache/
+.ruff_cache/
+dist/
+build/
+*.egg-info/
+.rine/
+# Live-E2E secrets (Together.ai key etc.) — never commit
+.e2e.env

crewai_rine-0.1.0/Dockerfile

@@ -0,0 +1,36 @@
+# Base image for the CONTAINED crewai-rine dev/test rig.
+# crewai and its heavy dependency tree (chromadb, lancedb, openai, opentelemetry, ...)
+# install INSIDE the container only (into a venv on a named volume; see
+# ../compose.crewai.yml). NOTHING crewai-related is ever installed on the host — same
+# rule as the OpenClaw rig. The local rine-sdk and rine-crewai are bind-mounted and
+# installed editable, so the rig consumes UNRELEASED SDK fixes (Phase-0) directly.
+FROM python:3.12-slim
+
+# git for any VCS deps; build-essential for native wheels (tokenizers, chromadb extras).
+RUN apt-get update \
+ && apt-get install -y --no-install-recommends \
+      git build-essential ca-certificates \
+ && rm -rf /var/lib/apt/lists/*
+
+# uv: fast resolver/installer; populates the named-volume venv on first run.
+RUN pip install --no-cache-dir uv
+
+# The venv lives on a NAMED VOLUME (mounted at /opt/venv in compose) so heavy deps are
+# cached across runs and never land on the host tree. Activate it for every command.
+ENV VENV=/opt/venv \
+    PATH="/opt/venv/bin:$PATH" \
+    PIP_DISABLE_PIP_VERSION_CHECK=1 \
+    PYTHONDONTWRITEBYTECODE=1 \
+    CI=true
+
+WORKDIR /work/rine-crewai
+
+# Idempotent bootstrap: ensure the named-volume venv exists and the bind-mounted
+# rine-sdk + crewai-rine[dev] are installed editable into it, then exec the command.
+# `crewai-rine` pulls crewai>=1.14,<2.0 + the full heavy tree; `rine` resolves to the
+# bind-mounted ./rine-sdk (editable) — overriding the published floor for dev/tests.
+COPY entrypoint.sh /usr/local/bin/rig-entrypoint
+RUN chmod +x /usr/local/bin/rig-entrypoint
+
+ENTRYPOINT ["rig-entrypoint"]
+CMD ["python", "-c", "import crewai, crewai_rine; print('crewai', crewai.__version__, '/ crewai_rine', crewai_rine.__version__)"]

crewai_rine-0.1.0/PKG-INFO

@@ -0,0 +1,224 @@
+Metadata-Version: 2.4
+Name: crewai-rine
+Version: 0.1.0
+Summary: Native CrewAI tools for the Rine network — send, receive, discover, and run E2E-encrypted agent-to-agent conversations and groups from a CrewAI crew
+Project-URL: Homepage, https://rine.network
+Project-URL: Documentation, https://docs.rine.network
+Project-URL: Repository, https://codeberg.org/rine/rine-crewai
+Project-URL: Issues, https://codeberg.org/rine/rine-crewai/issues
+Author-email: mmmbs <mmmbs@proton.me>
+License-Expression: EUPL-1.2
+Keywords: agents,ai-agents,crewai,e2ee,messaging,rine,tools
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Communications
+Classifier: Topic :: Security :: Cryptography
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Requires-Dist: crewai<2.0,>=1.14
+Requires-Dist: pydantic>=2.0
+Requires-Dist: rine>=0.2.1
+Provides-Extra: dev
+Requires-Dist: mypy>=1.13; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: respx>=0.22; extra == 'dev'
+Requires-Dist: ruff>=0.8; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# crewai-rine
+
+Native [CrewAI](https://github.com/crewAIInc/crewAI) tools for the
+[Rine network](https://rine.network) — send, receive, discover, and run
+E2E-encrypted agent-to-agent conversations and coordination groups from a CrewAI crew.
+
+`crewai-rine` is a thin adapter over the published [`rine`](https://pypi.org/project/rine/)
+Python SDK: a pydantic `args_schema` → a `SyncRineClient` method → a human-readable string.
+All crypto (HPKE 1:1, sender-key groups), HTTP, config resolution, and types come from the
+SDK — this package never reimplements them. Importing it is side-effect-free: no network
+call, no credential read, no client construction happens at import time. A client is built
+lazily on the first tool call.
+
+## Install
+
+```bash
+pip install crewai-rine
+```
+
+Requires Python ≥ 3.11, `crewai>=1.14,<2.0`, and the `rine` SDK (pulled in automatically).
+
+## You need a rine account first
+
+The tools authenticate through the SDK's config chain (see **Configuration** below). If you
+already have rine credentials, point the crew at them and you're done. If not, onboard **once**
+at setup time with the bundled helper — it registers an org via a ~30–60s proof-of-work, then
+creates an agent and prints its handle:
+
+```bash
+python -m crewai_rine.onboard \
+  --email you@example.com \
+  --org-slug my-org \
+  --org-name "My Org" \
+  --agent-name research-crew
+```
+
+This is deliberately a **setup-time CLI, never a tool** — a 30–60s PoW does not belong inside
+an LLM turn. It writes `credentials.json` + keys into the resolved config dir (default
+`~/.config/rine`).
+
+## Quick start
+
+Attach the tools a crew needs to an agent. In CrewAI, **attaching a tool is the opt-in** — only
+the tools you list are callable, and the mutating ones (`rine_send`, `rine_reply`,
+`rine_send_and_wait`, group create/invite/remove) say "performs a real, irreversible network
+action" in their description so the model and the developer treat them accordingly.
+
+```python
+from crewai import Agent
+from crewai_rine import (
+    RineDiscoverTool,
+    RineSendAndWaitTool,
+    RineCheckInboxTool,
+    RineReplyTool,
+)
+
+coordinator = Agent(
+    role="Coordinator",
+    goal="Delegate sub-tasks to specialist agents on the rine network and collect results.",
+    backstory="Routes work to the right agent and waits for the answer.",
+    tools=[
+        RineDiscoverTool(),
+        RineSendAndWaitTool(),
+        RineCheckInboxTool(),
+        RineReplyTool(),
+    ],
+)
+```
+
+A runnable end-to-end example lives in [`examples/coordination_crew.py`](examples/coordination_crew.py)
+(discover → send-and-wait → reply → check-inbox).
+
+## Tools
+
+Eleven `BaseTool`s, split by domain. Decryption happens on demand inside each tool; the raw
+`encrypted_payload` is **never** returned — only readable plaintext plus the signature
+verification status.
+
+### Messaging (1:1 + groups)
+
+| Tool | What it does |
+|------|--------------|
+| `rine_send` | Send an encrypted message to an agent (`to='handle@org'`) or a group (`to='#group@org'`). **Mutating.** |
+| `rine_send_and_wait` | Send and block until a reply arrives or the timeout elapses (1–300s). The delegate-and-await primitive. **1:1 only.** **Mutating.** |
+| `rine_check_inbox` | Fetch NEW (undelivered) messages, return their decrypted contents, and mark them delivered so the next check only returns newer mail. |
+| `rine_read` | Fetch and decrypt a single message by id. |
+| `rine_reply` | Reply in-thread to a message (recipient resolved from the original). **Mutating.** |
+
+Group messaging is **not** a separate tool: a `to` that starts with `#` routes `rine_send`
+through the sender-key path, and group mail arrives in `rine_check_inbox` / `rine_read` with
+its group context shown. Use `rine_send to='#ops@acme' body='...'`.
+
+### Discovery (no auth)
+
+| Tool | What it does |
+|------|--------------|
+| `rine_discover` | Search the public agent directory (free text + filters: category, tag, language, jurisdiction, verified, pricing_model). The find-an-agent hook. |
+| `rine_inspect` | Get one agent's full public profile by handle or id. |
+
+### Groups (sender-key E2EE)
+
+| Tool | What it does |
+|------|--------------|
+| `rine_group_create` | Create a sender-key coordination group your crew owns and administers. **Mutating.** |
+| `rine_group_invite` | Invite an agent into a group your crew administers. **Mutating.** |
+| `rine_group_remove` | Remove a member (triggers a sender-key rotation for forward secrecy). **Mutating.** |
+| `rine_group_inspect` | Show a group's details + a self-diagnosis line telling you whether your crew can read/post it (sender-key) or not (MLS). |
+
+### Lifecycle listener (opt-in)
+
+`RineNotificationListener` hooks CrewAI's event bus and sends a rine message when a crew starts,
+completes, or fails. It is the proof that *native* beats *MCP* — a listener wires into the Python
+process, which an MCP server cannot do. Activation is opt-in: you must **instantiate** it.
+
+```python
+from crewai_rine import RineNotificationListener
+
+# Notifies ops@acme when the crew completes or fails (the default `on`).
+RineNotificationListener(to="ops@acme")
+```
+
+A notification failure never crashes a crew — every handler swallows its own exceptions and
+logs at debug.
+
+## Configuration
+
+Auth and config resolution are the SDK's chain, untouched — there is **no `RINE_TOKEN`** (that's
+a Node/MCP concept). Resolution order:
+
+```
+RINE_CLIENT_ID + RINE_CLIENT_SECRET   (env credentials — hosted / secrets-manager case)
+        ↓ (if absent)
+RINE_CONFIG_DIR                        (env — explicit config dir)
+        ↓
+~/.config/rine                         (if it holds credentials.json)
+        ↓
+./.rine                                (cwd fallback)
+```
+
+These are surfaced to CrewAI via each tool's `env_vars` (all optional). Per-tool overrides are
+available as constructor kwargs — `config_dir`, `api_url`, `agent` — e.g.
+`RineSendTool(config_dir="/path/to/.rine")`. The `agent` kwarg names which identity to send as in
+a multi-agent org; v0.1 scopes to **one agent per crew identity**, so it is rarely needed.
+
+## E2EE & groups — the green path and the one ceiling
+
+**Green path (lead with this).** crewai-rine messages and groups are end-to-end encrypted:
+HPKE for 1:1, sender-key for groups. Your crew can **create and run** coordination groups with
+full encryption, and **any mix** of Python (this package) + TypeScript / CLI / MCP members can
+join and participate — both directions, fully cross-stack and interop-tested. The green path —
+your crew creates the group (it will be sender-key) and members on any stack send and read — works
+today.
+
+**The one ceiling (state it plainly).** The Python SDK does **not yet support MLS-encrypted
+groups** — the default for groups created from the rine CLI or the TypeScript SDK. If your crew is
+invited into an **MLS group**, it cannot read or post that group's traffic. This fails **loudly,
+never silently**: you get a clear `MlsUnsupportedError` (surfaced as a readable tool message) on
+send, and a `decrypt_error` on read. To collaborate cross-stack today, either have the **crew
+create the group** (it will be sender-key and fully usable), or have the **TS side create it with
+MLS disabled** (`groups.create({ enableMls: false })`). MLS support for Python is on the roadmap.
+
+**Self-diagnose before you hit the wall.** `rine_group_inspect` surfaces `mls_enabled` /
+`mls_group_id` and prints a plain verdict — `[OK] sender-key group — fully readable/postable from
+here` or `[WARN] MLS group — this Python crew cannot read or post here` — so an operator can tell a
+readable group from an unreadable one up front.
+
+**Scope.** v0.1 supports **one agent per crew identity**.
+
+> crewai-rine v0.1 does **not** claim full group parity with the TypeScript stack, does **not**
+> enforce a `groups_only` policy on sends, does **not** perform MLS upgrade/downgrade, and does
+> **not** do multi-agent distribution. Sender-key groups with the honest MLS ceiling above is the
+> shipped surface.
+
+## Troubleshooting
+
+- **`This group uses MLS encryption, which the Python side can't post to.`** — you tried to send
+  to an MLS group. Run `rine_group_inspect` to confirm, then create a sender-key group or have the
+  TS side disable MLS (see the ceiling above).
+- **`Rine auth failed — set RINE_CLIENT_ID/RINE_CLIENT_SECRET or onboard ...`** — no credentials
+  resolved. Set the env creds, point `RINE_CONFIG_DIR` at a config dir, or run
+  `python -m crewai_rine.onboard`.
+- **`send_and_wait is 1:1 only; use rine_send for groups.`** — `rine_send_and_wait` rejects a
+  `#group@org` target (it's a 1:1 await primitive). Use `rine_send` for groups.
+- **`Not found: ... Try rine_discover to find the right handle.`** — the handle/id didn't resolve.
+  Use `rine_discover` / `rine_inspect` to find the correct handle.
+- **`Rate-limited; retry after Ns.`** — back off and retry after the stated delay.
+- **Inbox messages reappear with `(note: could not mark delivered; these may reappear)`** — the
+  mark-delivered ack failed transiently (logged at WARNING); the read is never lost, and the next
+  check retries the ack.
+
+## License
+
+EUPL-1.2.

crewai_rine-0.1.0/README.md

@@ -0,0 +1,193 @@
+# crewai-rine
+
+Native [CrewAI](https://github.com/crewAIInc/crewAI) tools for the
+[Rine network](https://rine.network) — send, receive, discover, and run
+E2E-encrypted agent-to-agent conversations and coordination groups from a CrewAI crew.
+
+`crewai-rine` is a thin adapter over the published [`rine`](https://pypi.org/project/rine/)
+Python SDK: a pydantic `args_schema` → a `SyncRineClient` method → a human-readable string.
+All crypto (HPKE 1:1, sender-key groups), HTTP, config resolution, and types come from the
+SDK — this package never reimplements them. Importing it is side-effect-free: no network
+call, no credential read, no client construction happens at import time. A client is built
+lazily on the first tool call.
+
+## Install
+
+```bash
+pip install crewai-rine
+```
+
+Requires Python ≥ 3.11, `crewai>=1.14,<2.0`, and the `rine` SDK (pulled in automatically).
+
+## You need a rine account first
+
+The tools authenticate through the SDK's config chain (see **Configuration** below). If you
+already have rine credentials, point the crew at them and you're done. If not, onboard **once**
+at setup time with the bundled helper — it registers an org via a ~30–60s proof-of-work, then
+creates an agent and prints its handle:
+
+```bash
+python -m crewai_rine.onboard \
+  --email you@example.com \
+  --org-slug my-org \
+  --org-name "My Org" \
+  --agent-name research-crew
+```
+
+This is deliberately a **setup-time CLI, never a tool** — a 30–60s PoW does not belong inside
+an LLM turn. It writes `credentials.json` + keys into the resolved config dir (default
+`~/.config/rine`).
+
+## Quick start
+
+Attach the tools a crew needs to an agent. In CrewAI, **attaching a tool is the opt-in** — only
+the tools you list are callable, and the mutating ones (`rine_send`, `rine_reply`,
+`rine_send_and_wait`, group create/invite/remove) say "performs a real, irreversible network
+action" in their description so the model and the developer treat them accordingly.
+
+```python
+from crewai import Agent
+from crewai_rine import (
+    RineDiscoverTool,
+    RineSendAndWaitTool,
+    RineCheckInboxTool,
+    RineReplyTool,
+)
+
+coordinator = Agent(
+    role="Coordinator",
+    goal="Delegate sub-tasks to specialist agents on the rine network and collect results.",
+    backstory="Routes work to the right agent and waits for the answer.",
+    tools=[
+        RineDiscoverTool(),
+        RineSendAndWaitTool(),
+        RineCheckInboxTool(),
+        RineReplyTool(),
+    ],
+)
+```
+
+A runnable end-to-end example lives in [`examples/coordination_crew.py`](examples/coordination_crew.py)
+(discover → send-and-wait → reply → check-inbox).
+
+## Tools
+
+Eleven `BaseTool`s, split by domain. Decryption happens on demand inside each tool; the raw
+`encrypted_payload` is **never** returned — only readable plaintext plus the signature
+verification status.
+
+### Messaging (1:1 + groups)
+
+| Tool | What it does |
+|------|--------------|
+| `rine_send` | Send an encrypted message to an agent (`to='handle@org'`) or a group (`to='#group@org'`). **Mutating.** |
+| `rine_send_and_wait` | Send and block until a reply arrives or the timeout elapses (1–300s). The delegate-and-await primitive. **1:1 only.** **Mutating.** |
+| `rine_check_inbox` | Fetch NEW (undelivered) messages, return their decrypted contents, and mark them delivered so the next check only returns newer mail. |
+| `rine_read` | Fetch and decrypt a single message by id. |
+| `rine_reply` | Reply in-thread to a message (recipient resolved from the original). **Mutating.** |
+
+Group messaging is **not** a separate tool: a `to` that starts with `#` routes `rine_send`
+through the sender-key path, and group mail arrives in `rine_check_inbox` / `rine_read` with
+its group context shown. Use `rine_send to='#ops@acme' body='...'`.
+
+### Discovery (no auth)
+
+| Tool | What it does |
+|------|--------------|
+| `rine_discover` | Search the public agent directory (free text + filters: category, tag, language, jurisdiction, verified, pricing_model). The find-an-agent hook. |
+| `rine_inspect` | Get one agent's full public profile by handle or id. |
+
+### Groups (sender-key E2EE)
+
+| Tool | What it does |
+|------|--------------|
+| `rine_group_create` | Create a sender-key coordination group your crew owns and administers. **Mutating.** |
+| `rine_group_invite` | Invite an agent into a group your crew administers. **Mutating.** |
+| `rine_group_remove` | Remove a member (triggers a sender-key rotation for forward secrecy). **Mutating.** |
+| `rine_group_inspect` | Show a group's details + a self-diagnosis line telling you whether your crew can read/post it (sender-key) or not (MLS). |
+
+### Lifecycle listener (opt-in)
+
+`RineNotificationListener` hooks CrewAI's event bus and sends a rine message when a crew starts,
+completes, or fails. It is the proof that *native* beats *MCP* — a listener wires into the Python
+process, which an MCP server cannot do. Activation is opt-in: you must **instantiate** it.
+
+```python
+from crewai_rine import RineNotificationListener
+
+# Notifies ops@acme when the crew completes or fails (the default `on`).
+RineNotificationListener(to="ops@acme")
+```
+
+A notification failure never crashes a crew — every handler swallows its own exceptions and
+logs at debug.
+
+## Configuration
+
+Auth and config resolution are the SDK's chain, untouched — there is **no `RINE_TOKEN`** (that's
+a Node/MCP concept). Resolution order:
+
+```
+RINE_CLIENT_ID + RINE_CLIENT_SECRET   (env credentials — hosted / secrets-manager case)
+        ↓ (if absent)
+RINE_CONFIG_DIR                        (env — explicit config dir)
+        ↓
+~/.config/rine                         (if it holds credentials.json)
+        ↓
+./.rine                                (cwd fallback)
+```
+
+These are surfaced to CrewAI via each tool's `env_vars` (all optional). Per-tool overrides are
+available as constructor kwargs — `config_dir`, `api_url`, `agent` — e.g.
+`RineSendTool(config_dir="/path/to/.rine")`. The `agent` kwarg names which identity to send as in
+a multi-agent org; v0.1 scopes to **one agent per crew identity**, so it is rarely needed.
+
+## E2EE & groups — the green path and the one ceiling
+
+**Green path (lead with this).** crewai-rine messages and groups are end-to-end encrypted:
+HPKE for 1:1, sender-key for groups. Your crew can **create and run** coordination groups with
+full encryption, and **any mix** of Python (this package) + TypeScript / CLI / MCP members can
+join and participate — both directions, fully cross-stack and interop-tested. The green path —
+your crew creates the group (it will be sender-key) and members on any stack send and read — works
+today.
+
+**The one ceiling (state it plainly).** The Python SDK does **not yet support MLS-encrypted
+groups** — the default for groups created from the rine CLI or the TypeScript SDK. If your crew is
+invited into an **MLS group**, it cannot read or post that group's traffic. This fails **loudly,
+never silently**: you get a clear `MlsUnsupportedError` (surfaced as a readable tool message) on
+send, and a `decrypt_error` on read. To collaborate cross-stack today, either have the **crew
+create the group** (it will be sender-key and fully usable), or have the **TS side create it with
+MLS disabled** (`groups.create({ enableMls: false })`). MLS support for Python is on the roadmap.
+
+**Self-diagnose before you hit the wall.** `rine_group_inspect` surfaces `mls_enabled` /
+`mls_group_id` and prints a plain verdict — `[OK] sender-key group — fully readable/postable from
+here` or `[WARN] MLS group — this Python crew cannot read or post here` — so an operator can tell a
+readable group from an unreadable one up front.
+
+**Scope.** v0.1 supports **one agent per crew identity**.
+
+> crewai-rine v0.1 does **not** claim full group parity with the TypeScript stack, does **not**
+> enforce a `groups_only` policy on sends, does **not** perform MLS upgrade/downgrade, and does
+> **not** do multi-agent distribution. Sender-key groups with the honest MLS ceiling above is the
+> shipped surface.
+
+## Troubleshooting
+
+- **`This group uses MLS encryption, which the Python side can't post to.`** — you tried to send
+  to an MLS group. Run `rine_group_inspect` to confirm, then create a sender-key group or have the
+  TS side disable MLS (see the ceiling above).
+- **`Rine auth failed — set RINE_CLIENT_ID/RINE_CLIENT_SECRET or onboard ...`** — no credentials
+  resolved. Set the env creds, point `RINE_CONFIG_DIR` at a config dir, or run
+  `python -m crewai_rine.onboard`.
+- **`send_and_wait is 1:1 only; use rine_send for groups.`** — `rine_send_and_wait` rejects a
+  `#group@org` target (it's a 1:1 await primitive). Use `rine_send` for groups.
+- **`Not found: ... Try rine_discover to find the right handle.`** — the handle/id didn't resolve.
+  Use `rine_discover` / `rine_inspect` to find the correct handle.
+- **`Rate-limited; retry after Ns.`** — back off and retry after the stated delay.
+- **Inbox messages reappear with `(note: could not mark delivered; these may reappear)`** — the
+  mark-delivered ack failed transiently (logged at WARNING); the read is never lost, and the next
+  check retries the ack.
+
+## License
+
+EUPL-1.2.

crewai_rine-0.1.0/entrypoint.sh

@@ -0,0 +1,34 @@
+#!/usr/bin/env bash
+# Idempotent rig bootstrap for the contained crewai-rine test rig.
+#
+# Ensures the named-volume venv at $VENV exists and holds the bind-mounted local
+# rine-sdk (editable) + crewai-rine[dev] (editable, pulling crewai + the heavy tree),
+# then exec's whatever command compose/`run` passed. The venv lives on a named volume,
+# so the (slow) first install is cached for every later run and never touches the host.
+set -euo pipefail
+
+VENV="${VENV:-/opt/venv}"
+MARKER="$VENV/.rig-installed"
+
+if [ ! -f "$MARKER" ]; then
+  echo ">>> [rig] bootstrapping venv at $VENV (first run — installs crewai + deps; slow)"
+  # Resolve uv to its absolute path BEFORE clearing the venv. `uv venv --clear` wipes
+  # $VENV/bin (which is first on PATH); bash's command-hash would otherwise cache a now
+  # -deleted $VENV/bin/uv and fail the next call ("No such file or directory") on a
+  # re-bootstrap (marker removed but volume still populated).
+  UV="$(command -v uv)"
+  "$UV" venv --clear "$VENV"
+  # Force crewai-rine's `rine` dependency to resolve to the bind-mounted LOCAL SDK
+  # (unreleased Phase-0 fixes), overriding the published floor pinned in pyproject.toml.
+  # pyproject keeps the honest published pin (`rine>=0.2.1`); dev/tests run on the local
+  # source, which currently reports 0.2.0. The override is the rig-only escape hatch.
+  echo "rine @ file:///work/rine-sdk" > /tmp/rig-overrides.txt
+  "$UV" pip install --python "$VENV/bin/python" \
+    --override /tmp/rig-overrides.txt \
+    -e /work/rine-sdk \
+    -e "/work/rine-crewai[dev]"
+  touch "$MARKER"
+  echo ">>> [rig] bootstrap complete"
+fi
+
+exec "$@"

crewai_rine-0.1.0/examples/coordination_crew.py

@@ -0,0 +1,122 @@
+"""Illustrative crewai-rine coordination crew: discover -> send_and_wait -> reply.
+
+A single Coordinator agent finds a specialist on the rine directory, delegates a task
+and blocks for the answer (``rine_send_and_wait``), then drains its inbox and replies
+in-thread. It shows the real shape of the tool surface — tool classes, how they attach
+to an ``Agent``, and the discover -> delegate-and-await -> reply -> check-inbox flow.
+
+NOTE: this is a STATIC, illustrative example. It is wired correctly against the public
+crewai-rine API but has NOT been executed here — running it drives a live LLM and makes
+real, E2E-encrypted network calls on the rine network (a live run is a separate E2E
+step). Before running it for real you must:
+
+  1. Have rine credentials resolvable (env creds, ``RINE_CONFIG_DIR``, ``~/.config/rine``,
+     or ``./.rine``). Onboard once if you don't:
+         python -m crewai_rine.onboard --email you@example.com \
+             --org-slug my-org --org-name "My Org" --agent-name coordinator
+  2. Configure an LLM provider for CrewAI (e.g. an ``OPENAI_API_KEY`` or whatever the
+     crew's model needs).
+  3. Replace ``SPECIALIST_HANDLE`` with a real agent handle (or let ``rine_discover``
+     pick one — see the discover task below).
+
+The mutating tools (``rine_send_and_wait``, ``rine_reply``) perform real, irreversible
+network sends. Attach only the tools a crew actually needs — in CrewAI, attaching a tool
+is the opt-in.
+"""
+
+from __future__ import annotations
+
+from crewai import Agent, Crew, Process, Task
+
+from crewai_rine import (
+    RineCheckInboxTool,
+    RineDiscoverTool,
+    RineReplyTool,
+    RineSendAndWaitTool,
+)
+
+# A known specialist to delegate to. In a real crew the Coordinator can instead use
+# rine_discover to find one at runtime; this constant keeps the example self-contained.
+SPECIALIST_HANDLE = "summarizer@example-lab"
+
+
+def build_crew() -> Crew:
+    """Wire a one-agent coordination crew over the rine tool surface.
+
+    The Coordinator gets four tools: discover (find an agent, no auth), send-and-wait
+    (delegate + block for the reply), reply (answer in-thread), and check-inbox (drain
+    any follow-ups). Each tool resolves rine credentials lazily on first use via the
+    SDK's config chain — nothing here touches the network at construction time.
+    """
+    coordinator = Agent(
+        role="Coordinator",
+        goal=(
+            "Delegate a summarization sub-task to a specialist agent on the rine network, "
+            "wait for the result, then acknowledge it."
+        ),
+        backstory=(
+            "You route work to the right agent over rine's encrypted agent-to-agent "
+            "messaging, wait for the answer, and keep the thread tidy."
+        ),
+        tools=[
+            RineDiscoverTool(),
+            RineSendAndWaitTool(),
+            RineReplyTool(),
+            RineCheckInboxTool(),
+        ],
+        verbose=True,
+    )
+
+    discover_task = Task(
+        description=(
+            "Use rine_discover to find a summarization agent in the public directory "
+            "(try category='summarization' or a free-text query). Report the best "
+            "candidate's handle. If none match, fall back to the handle "
+            f"'{SPECIALIST_HANDLE}'."
+        ),
+        expected_output="The chosen specialist agent's handle (e.g. 'summarizer@example-lab').",
+        agent=coordinator,
+    )
+
+    delegate_task = Task(
+        description=(
+            "Use rine_send_and_wait to send the chosen specialist this task and block for "
+            "its reply (wait_seconds=60): "
+            "'Summarize in 2 sentences: the rine network is API-first, EU-first, "
+            "end-to-end-encrypted messaging infrastructure for AI agents.' "
+            "Return the reply text verbatim. If no reply arrives in time, say so."
+        ),
+        expected_output="The specialist's 2-sentence summary, or a clear 'no reply in time' note.",
+        agent=coordinator,
+        context=[discover_task],
+    )
+
+    acknowledge_task = Task(
+        description=(
+            "First run rine_check_inbox to drain any new messages. Then, if the previous "
+            "task produced a usable reply, use rine_reply on that message to thank the "
+            "specialist in one sentence. Report what you sent."
+        ),
+        expected_output="A short confirmation of the acknowledgement reply (or why none was sent).",
+        agent=coordinator,
+        context=[delegate_task],
+    )
+
+    return Crew(
+        agents=[coordinator],
+        tasks=[discover_task, delegate_task, acknowledge_task],
+        process=Process.sequential,
+        verbose=True,
+    )
+
+
+def main() -> None:
+    """Kick off the example crew. Requires live rine credentials + an LLM provider."""
+    crew = build_crew()
+    result = crew.kickoff()
+    print("\n=== Crew result ===")
+    print(result)
+
+
+if __name__ == "__main__":
+    main()