rapier-runtime 0.1.0__py3-none-any.whl

rapier/__init__.py

@@ -0,0 +1,70 @@
+"""Rapier Runtime — a code-orchestrated engine that runs the SPARRING method.
+
+Rapier executes a SPARRING *method* declared in a YAML manifest: grounded,
+cross-vendor adversarial review for AI-in-the-loop decisions. This is M0 — the
+skeleton (Envelope, Stage contract, Pipeline controller, model/provider layer,
+ledger) proven with a dummy echo stage. The Resolver port (M1) and the Proposer
+build (M2) come next.
+"""
+from __future__ import annotations
+
+from .envelope import Artifact, Envelope, TraceEntry
+from .manifest import Manifest
+from .models import (
+    ModelClient,
+    ModelResponse,
+    ModelSpec,
+    OpenAICompatibleModelClient,
+    Policy,
+    PolicyError,
+    available_vendors,
+    build_client,
+)
+from .pipeline import Pipeline, StageSpec
+from .stage import (
+    ConvergenceStage,
+    Stage,
+    StageContext,
+    TransformStage,
+    get_stage,
+    register_stage,
+    registered_stages,
+)
+from . import stages  # noqa: F401  (registers built-in stages on import)
+
+# Single source of truth is pyproject's version; read it from the installed
+# package metadata so __version__ can never drift from what was published.
+try:
+    from importlib.metadata import PackageNotFoundError, version as _pkg_version
+
+    try:
+        __version__ = _pkg_version("rapier-runtime")
+    except PackageNotFoundError:  # running from a source tree, not installed
+        __version__ = "0.0.0+source"
+except Exception:  # pragma: no cover - defensive
+    __version__ = "0.0.0+source"
+
+__all__ = [
+    "Envelope",
+    "Artifact",
+    "TraceEntry",
+    "Stage",
+    "TransformStage",
+    "ConvergenceStage",
+    "StageContext",
+    "register_stage",
+    "get_stage",
+    "registered_stages",
+    "Manifest",
+    "Pipeline",
+    "StageSpec",
+    "ModelSpec",
+    "ModelClient",
+    "ModelResponse",
+    "OpenAICompatibleModelClient",
+    "Policy",
+    "PolicyError",
+    "build_client",
+    "available_vendors",
+    "__version__",
+]

rapier/_json.py

@@ -0,0 +1,39 @@
+"""Tolerant JSON extraction from model output (fences, surrounding prose)."""
+from __future__ import annotations
+
+import json
+import re
+from typing import Any
+
+
+def parse_json_lenient(text: str | None) -> Any:
+    """Best-effort: strip code fences, else grab the first balanced {...}/[...].
+
+    Returns {} on failure rather than raising — a malformed model reply becomes
+    an empty round, not a crash (fail-soft).
+    """
+    if not text:
+        return {}
+    t = text.strip()
+    t = re.sub(r"^```(?:json)?\s*", "", t)
+    t = re.sub(r"\s*```$", "", t)
+    try:
+        return json.loads(t)
+    except Exception:
+        pass
+    for opener, closer in (("{", "}"), ("[", "]")):
+        start = t.find(opener)
+        if start == -1:
+            continue
+        depth = 0
+        for i in range(start, len(t)):
+            if t[i] == opener:
+                depth += 1
+            elif t[i] == closer:
+                depth -= 1
+                if depth == 0:
+                    try:
+                        return json.loads(t[start : i + 1])
+                    except Exception:
+                        break
+    return {}

rapier/cli.py

@@ -0,0 +1,244 @@
+"""The ``rapier`` CLI.
+
+    rapier sparring --request "should we do X?"          # full ceremony
+    rapier spar     --request "should we do X?"           # Resolver only
+    rapier spar     --request-file pack.md                # read the pack from a file
+    rapier proposer --request "should we do X?"           # Proposer only
+    rapier run --manifest path.yaml --request-file pack.md  # a custom manifest
+    rapier doctor                                     # which vendor keys are set
+    rapier init                                       # scaffold a .env.example
+    rapier mcp                                        # run the MCP server (stdio)
+
+``spar`` / ``sparring`` are the thin adapters the SPARRING skills call.
+"""
+from __future__ import annotations
+
+import argparse
+import itertools
+import os
+import re
+import sys
+import tempfile
+import threading
+import time
+
+from . import __version__, stages  # noqa: F401  (ensure built-in stages are registered)
+from .manifest import Manifest
+from .presets import VERIFY_MODES, load_preset
+
+# A ceremony is a sequence of model calls that each take tens of seconds — long
+# enough that a novice fears it hung. Give each stage a plain-language label and,
+# on a TTY, a live spinner + elapsed clock + "N/M" so it plainly reads as working.
+_STAGE_LABELS = {
+    "author": "Drafting the recommendation",
+    "cross_review": "Independent cross-vendor challenge",
+    "anchored_fix": "Revising to address the challenge",
+    "definitiveness_gate": "Correctness check",
+    "citation_gate": "Grounding citations against public registries",
+    "compose": "Composing the report",
+    "spark": "Widening the options (SPARK)",
+    "pattern_lock": "Filtering repetition (Pattern Lock)",
+    "cut": "Committing one option (the Cut)",
+    "echo": "Echo",
+}
+
+
+class _Progress:
+    """Render stage progress. On a TTY: an in-place spinner + elapsed seconds +
+    N/M counter, animated on a background thread while the (blocking) stage runs.
+    Piped/redirected: plain one-line-per-stage output, no control characters, so
+    logs stay clean."""
+
+    _FRAMES = "⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏"
+
+    def __init__(self, total: int, stream=None):
+        self.total = total
+        self.stream = stream or sys.stderr
+        self.tty = bool(getattr(self.stream, "isatty", lambda: False)())
+        self.i = 0
+        self._label = ""
+        self._start = 0.0
+        self._stop = None
+        self._thread = None
+
+    def log(self, msg: str) -> None:
+        m = re.match(r"stage: (\w+)", msg)
+        if m:
+            self._finish()
+            self.i += 1
+            self._label = _STAGE_LABELS.get(m.group(1), m.group(1).replace("_", " "))
+            self._begin()
+        elif any(w in msg.lower() for w in ("fail", "cancel", "error")):
+            if self.tty:
+                self.stream.write("\r" + " " * 72 + "\r")
+            print(f"· {msg.strip()}", file=self.stream, flush=True)
+        elif not self.tty:
+            print(f"·   {msg.strip()}", file=self.stream, flush=True)
+
+    def _begin(self) -> None:
+        if not self.tty:
+            print(f"· [{self.i}/{self.total}] {self._label}…", file=self.stream, flush=True)
+            return
+        self._start = time.monotonic()
+        self._stop = threading.Event()
+        self._thread = threading.Thread(target=self._spin, daemon=True)
+        self._thread.start()
+
+    def _spin(self) -> None:
+        frames = itertools.cycle(self._FRAMES)
+        while not self._stop.is_set():
+            el = int(time.monotonic() - self._start)
+            self.stream.write(f"\r  {next(frames)} [{self.i}/{self.total}] {self._label}… {el}s   ")
+            self.stream.flush()
+            self._stop.wait(0.1)
+
+    def _finish(self) -> None:
+        if not self._thread:
+            return
+        self._stop.set()
+        self._thread.join(timeout=1.0)
+        el = int(time.monotonic() - self._start)
+        self.stream.write(f"\r  ✓ [{self.i}/{self.total}] {self._label}  ({el}s){' ' * 12}\n")
+        self.stream.flush()
+        self._thread = None
+
+    def done(self) -> None:
+        self._finish()
+
+
+def _run(manifest: Manifest, request: str, ledger_dir: str | None, report_all: bool = False) -> int:
+    # Always capture a run: without an explicit --ledger-dir, write the full
+    # transcript + per-stage records under a temp dir and tell the user where.
+    default_root = ledger_dir is None
+    root = ledger_dir or os.path.join(tempfile.gettempdir(), "rapier-runs")
+    pipe = manifest.build()
+    progress = _Progress(total=len(pipe.stages))
+    try:
+        env = pipe.run(request, ledger_root=root, log=progress.log)
+    finally:
+        progress.done()
+    # Prefer the composed report if the pipeline produced one.
+    out = env.meta.get("report_md") or env.recommendation or ""
+    # --report-all: prepend the first half's handoff report (SPARRING is two
+    # parts — the Proposer commits an option, the Resolver pressure-tests it).
+    proposer_md = env.meta.get("proposer_report_md")
+    if report_all and proposer_md:
+        out = f"{proposer_md}\n\n{out}"
+    print(out)
+    run_id = env.meta.get("run_id")
+    if run_id:
+        run_dir = os.path.join(root, run_id)
+        hint = "Full transcript, per-stage records, and this report saved to:"
+        if default_root:
+            hint = "No --ledger-dir given, so the full transcript + records were saved to:"
+        print(f"\n· {hint}\n  {run_dir}", file=sys.stderr)
+    return 0
+
+
+def _resolve_request(args) -> str:
+    """The decision text — inline via --request, or read from --request-file
+    (``-`` for stdin). The mutually-exclusive group guarantees exactly one."""
+    path = getattr(args, "request_file", None)
+    if path:
+        if path == "-":
+            return sys.stdin.read()
+        with open(path, encoding="utf-8") as fh:
+            return fh.read()
+    return args.request
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(
+        prog="rapier",
+        description="Rapier Runtime — run a SPARRING method from a manifest or preset.",
+        epilog="a ResourceForge project  ·  docs: https://rapierruntime.com  ·  "
+               "update: pip install -U rapier-runtime",
+    )
+    parser.add_argument(
+        "--version", action="version", version=f"rapier-runtime {__version__}",
+        help="print the installed version and exit",
+    )
+    sub = parser.add_subparsers(dest="cmd", required=True)
+
+    def add_common(p):
+        src = p.add_mutually_exclusive_group(required=True)
+        src.add_argument("--request", help="the decision/request text, given inline")
+        src.add_argument(
+            "--request-file", metavar="PATH",
+            help="read the decision/request text from a file (use '-' for stdin) — "
+                 "friendlier than --request for a multi-line context pack",
+        )
+        p.add_argument("--ledger-dir", default=None, help="write run artifacts (transcript, report, records) here")
+
+    for preset in ("spar", "sparring", "proposer"):
+        p = sub.add_parser(preset, help=f"run the '{preset}' ceremony preset")
+        add_common(p)
+        if preset in ("spar", "sparring"):  # resolver knobs — no-ops for proposer-only
+            p.add_argument(
+                "--settle", type=int, default=0, metavar="N",
+                help="extra review-and-revise rounds on the recommendation for decision-stability (default 0)",
+            )
+            p.add_argument(
+                "--verify", choices=list(VERIFY_MODES), default="gate",
+                help="external-canon citation gate: off | gate (default) | round",
+            )
+        if preset == "sparring":  # the Proposer half only exists in the full ceremony
+            p.add_argument(
+                "--report-all", action="store_true",
+                help="also surface the Proposer report (the committed option + its standing objections) above the Resolver report",
+            )
+
+    run = sub.add_parser("run", help="run a custom manifest")
+    run.add_argument("--manifest", required=True, help="path to a pipeline manifest (YAML)")
+    add_common(run)
+
+    sub.add_parser("doctor", help="check which AI vendor keys are configured")
+    ip = sub.add_parser("init", help="scaffold a .env.example for vendor keys")
+    ip.add_argument("--dir", default=".", help="directory to write .env.example into (default: cwd)")
+    sub.add_parser("mcp", help="run the MCP server (stdio) exposing spar/sparring as tools")
+
+    args = parser.parse_args(argv)
+
+    if args.cmd == "doctor":
+        from .onboarding import doctor_report
+
+        print(doctor_report())
+        return 0
+    if args.cmd == "init":
+        from .onboarding import init as _init
+
+        _path, _created, instructions = _init(args.dir)
+        print(instructions)
+        return 0
+    if args.cmd == "mcp":
+        from .mcp import serve
+
+        return serve()
+
+    try:
+        request = _resolve_request(args)
+    except OSError as e:
+        print(f"rapier: cannot read --request-file: {e}", file=sys.stderr)
+        return 2
+    if not (request or "").strip():
+        print("rapier: the request is empty", file=sys.stderr)
+        return 2
+
+    if args.cmd in ("spar", "sparring", "proposer"):
+        from .onboarding import preflight_error
+
+        err = preflight_error()
+        if err:  # no vendor keys — fail loudly, not silently
+            print(err, file=sys.stderr)
+            return 2
+        preset = load_preset(
+            args.cmd, settle=getattr(args, "settle", 0), verify=getattr(args, "verify", "gate")
+        )
+        return _run(preset, request, args.ledger_dir, report_all=getattr(args, "report_all", False))
+    if args.cmd == "run":
+        return _run(Manifest.load(args.manifest), request, args.ledger_dir)
+    return 1  # pragma: no cover
+
+
+if __name__ == "__main__":  # pragma: no cover
+    raise SystemExit(main())

rapier/convergence.py

@@ -0,0 +1,93 @@
+"""The convergence primitive — the two-agent Generator×Challenger loop, once.
+
+SPARK, Pattern Lock, and the Cut are all this loop with a different Challenger
+function (expand / filter / close) and exit goal. Written once here; the phase
+stages configure it.
+
+Each round: the Generator produces/extends a payload; the Challenger applies its
+function and raises artifact-cited concerns; both emit ``agree``. The phase
+converges only when **both** agree (the proposer can't close alone). At the cap
+it exits unresolved.
+
+G3 (convergence integrity) is built in, not bolted on:
+- *Instrumentation* — every round is recorded; ``no_op`` flags a phase whose
+  final payload never moved off the round-1 proposal (a rubber-stamp).
+- *A reopen-capable integrity check* — an optional cross-vendor predicate that,
+  on a both-agree, can judge the convergence premature and reopen the phase
+  (up to ``reopen_cap``), so convergence is verified, not merely self-reported.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, Callable
+
+
+@dataclass
+class ConvergenceRound:
+    index: int
+    generator: dict[str, Any]
+    challenger: dict[str, Any]
+    both_agree: bool
+
+
+@dataclass
+class ConvergenceResult:
+    converged: bool
+    payload: Any
+    rounds: list[ConvergenceRound] = field(default_factory=list)
+    resolved_at: int | None = None
+    no_op: bool = False
+    integrity_reopened: int = 0
+
+
+# generator(prev_payload, challenger_concerns) -> {"payload", "agree", "reasoning"}
+Generator = Callable[[Any, Any], dict]
+# challenger(payload) -> {"concerns", "agree", "reasoning"}
+Challenger = Callable[[Any], dict]
+
+
+def _default_delta(a: Any, b: Any) -> bool:
+    return a != b  # True == "changed"
+
+
+def run_convergence(
+    generator: Generator,
+    challenger: Challenger,
+    cap: int,
+    *,
+    integrity: Callable[[Any, list[ConvergenceRound]], bool] | None = None,
+    reopen_cap: int = 1,
+    delta: Callable[[Any, Any], bool] | None = None,
+    log: Callable[[str], None] = lambda _m: None,
+) -> ConvergenceResult:
+    delta = delta or _default_delta
+    rounds: list[ConvergenceRound] = []
+    reopened = 0
+
+    gen = generator(None, None)
+    first_payload = gen.get("payload")
+
+    for i in range(cap):
+        chal = challenger(gen.get("payload"))
+        both = bool(gen.get("agree")) and bool(chal.get("agree"))
+        rounds.append(ConvergenceRound(i + 1, gen, chal, both))
+
+        if both:
+            if integrity is not None and reopened < reopen_cap and not integrity(gen.get("payload"), rounds):
+                reopened += 1
+                log(f"convergence-integrity: reopened phase (premature) [{reopened}/{reopen_cap}]")
+                gen = generator(gen.get("payload"), chal.get("concerns"))
+                continue
+            no_op = not delta(first_payload, gen.get("payload"))
+            return ConvergenceResult(True, gen.get("payload"), rounds, i + 1, no_op, reopened)
+
+        # Only revise if another challenge round follows. A final, un-challenged
+        # revision must NOT become the committed payload: the phase exits on the
+        # option the Challenger actually last evaluated, so the committed option
+        # and its standing objections (rounds[-1].challenger) refer to the SAME
+        # payload — no committed-vs-objection mismatch.
+        if i < cap - 1:
+            gen = generator(gen.get("payload"), chal.get("concerns"))
+
+    no_op = not delta(first_payload, gen.get("payload"))
+    return ConvergenceResult(False, gen.get("payload"), rounds, None, no_op, reopened)

rapier/envelope.py

@@ -0,0 +1,66 @@
+"""The Envelope — the single typed state object that flows through the pipeline.
+
+Every stage reads and writes one Envelope. Nothing else is passed between
+stages. Get this contract right and stages become independently swappable:
+a stage is just ``run(envelope) -> envelope``.
+
+The Envelope carries the whole ceremony: the request in, the Proposer's
+evolving option space, the committed option, the Resolver's recommendation and
+trust rider, the accumulated grounding artifacts, and an append-only trace that
+feeds the ledger/audit sink.
+"""
+from __future__ import annotations
+
+import time
+from dataclasses import asdict, dataclass, field
+from typing import Any
+
+
+@dataclass
+class TraceEntry:
+    """One append-only record of what a stage did. Feeds the audit ledger."""
+
+    stage: str
+    kind: str
+    summary: str
+    data: dict[str, Any] = field(default_factory=dict)
+    ts: float = field(default_factory=time.time)
+
+
+@dataclass
+class Artifact:
+    """A checkable grounding claim raised during the ceremony.
+
+    ``ref`` is the bare checkable token (a CWE id, a DOI, a ``path:line``, a
+    ``#3`` pack-fact pointer, a URL). ``verdict`` is set by the verification
+    service in later milestones.
+    """
+
+    ref: str
+    claim: str
+    load_bearing: bool = False
+    verdict: str = "unchecked"  # unchecked | verified | refuted | unverifiable
+
+
+@dataclass
+class Envelope:
+    """The state passed through every stage of a Rapier pipeline."""
+
+    request: str
+    options: list[str] = field(default_factory=list)
+    committed: str | None = None
+    recommendation: str | None = None
+    trust_rider: dict[str, Any] | None = None
+    artifacts: list[Artifact] = field(default_factory=list)
+    trace: list[TraceEntry] = field(default_factory=list)
+    verdict: str | None = None
+    meta: dict[str, Any] = field(default_factory=dict)
+
+    def add_trace(self, stage: str, kind: str, summary: str, **data: Any) -> "Envelope":
+        """Append an audit trace entry and return self (for chaining)."""
+        self.trace.append(TraceEntry(stage=stage, kind=kind, summary=summary, data=data))
+        return self
+
+    def to_dict(self) -> dict[str, Any]:
+        """Plain-dict view for serialization (redacted before it is persisted)."""
+        return asdict(self)

rapier/ledger.py

@@ -0,0 +1,71 @@
+"""The audit sink — persists a run's trace and envelope to a run directory.
+
+Every ceremony leaves a re-readable log on disk (the framework's auditability
+discipline). Two security properties, both part of the M0 exit criterion:
+
+* Everything written is passed through :func:`rapier.secrets.redact_obj` first.
+* Files and directories are created owner-only (0600 / 0700).
+"""
+from __future__ import annotations
+
+import json
+import os
+import re
+import time
+
+from .envelope import Envelope
+from .secrets import redact_obj
+
+
+def _slug(text: str) -> str:
+    text = re.sub(r"[^a-z0-9]+", "-", (text or "").lower()).strip("-")
+    return text[:40] or "run"
+
+
+class Ledger:
+    def __init__(self, root: str, run_slug: str = "run"):
+        stamp = time.strftime("%Y%m%d%H%M%S")
+        self.run_dir = os.path.join(root, f"{stamp}-{_slug(run_slug)}")
+        os.makedirs(self.run_dir, mode=0o700, exist_ok=True)
+        try:
+            os.chmod(self.run_dir, 0o700)
+        except OSError:  # pragma: no cover - platform dependent
+            pass
+        self.ledger_path = os.path.join(self.run_dir, "ledger.jsonl")
+
+    def _open_owner_only(self, path: str, append: bool) -> int:
+        flags = os.O_WRONLY | os.O_CREAT | (os.O_APPEND if append else os.O_TRUNC)
+        return os.open(path, flags, 0o600)
+
+    def _write(self, name: str, obj) -> str:
+        path = os.path.join(self.run_dir, name)
+        payload = json.dumps(redact_obj(obj), indent=2, default=str)
+        with os.fdopen(self._open_owner_only(path, append=False), "w") as fh:
+            fh.write(payload)
+        return path
+
+    def record_stage(self, stage_name: str, entry: dict) -> None:
+        line = json.dumps(redact_obj({"stage": stage_name, **entry}), default=str)
+        with os.fdopen(self._open_owner_only(self.ledger_path, append=True), "a") as fh:
+            fh.write(line + "\n")
+
+    def write_text(self, name: str, text: str) -> str:
+        """Write a redacted text/markdown artifact (owner-only) to the run dir."""
+        path = os.path.join(self.run_dir, name)
+        with os.fdopen(self._open_owner_only(path, append=False), "w") as fh:
+            fh.write(redact_obj(text))
+        return path
+
+    def write_json(self, name: str, obj) -> str:
+        """Write a redacted JSON artifact (owner-only) to the run dir."""
+        return self._write(name, obj)
+
+    def record_transcript(self, event: dict) -> None:
+        """Append one verbatim model-call record (redacted) to transcript.jsonl."""
+        path = os.path.join(self.run_dir, "transcript.jsonl")
+        line = json.dumps(redact_obj(event), default=str)
+        with os.fdopen(self._open_owner_only(path, append=True), "a") as fh:
+            fh.write(line + "\n")
+
+    def persist_envelope(self, env: Envelope) -> str:
+        return self._write("envelope.json", env.to_dict())

rapier/manifest.py

@@ -0,0 +1,75 @@
+"""The manifest loader — the method as declarative data.
+
+A manifest is a YAML file that lists the stages of a pipeline, each with its
+config and its role→model bindings. Editing the manifest changes the *method*
+without touching the engine; that is what makes the method modular and
+upgradeable (swap a model, reorder a stage, add a module).
+
+Parsed with ``yaml.safe_load`` — never ``load`` — so a manifest can never
+execute arbitrary Python (threat model: untrusted config / deserialization).
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+import yaml
+
+from .models import ModelSpec, Policy
+from .pipeline import Pipeline, StageSpec
+
+
+@dataclass
+class Manifest:
+    name: str
+    stages: list[StageSpec]
+    policy: Policy | None = None
+
+    @classmethod
+    def load(cls, path: str) -> "Manifest":
+        with open(path, encoding="utf-8") as fh:
+            data = yaml.safe_load(fh)
+        if not isinstance(data, dict):
+            raise ValueError("manifest must be a YAML mapping at the top level")
+        return cls.from_dict(data)
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> "Manifest":
+        name = data.get("name", "pipeline")
+        raw_stages = data.get("pipeline")
+        if not isinstance(raw_stages, list) or not raw_stages:
+            raise ValueError("manifest 'pipeline' must be a non-empty list")
+
+        stages: list[StageSpec] = []
+        for i, entry in enumerate(raw_stages):
+            if not isinstance(entry, dict) or "stage" not in entry:
+                raise ValueError(f"pipeline[{i}] must be a mapping with a 'stage' key")
+            roles: dict[str, ModelSpec] = {}
+            for role, binding in (entry.get("roles") or {}).items():
+                if "vendor" not in binding or "model" not in binding:
+                    raise ValueError(
+                        f"pipeline[{i}].roles.{role} needs both 'vendor' and 'model'"
+                    )
+                roles[role] = ModelSpec(
+                    vendor=binding["vendor"],
+                    model=binding["model"],
+                    prompt_template=binding.get("prompt"),
+                    max_tokens=binding.get("max_tokens", 4096),
+                    temperature=binding.get("temperature", 1.0),
+                )
+            stages.append(
+                StageSpec(stage=entry["stage"], config=entry.get("config") or {}, roles=roles)
+            )
+
+        policy = None
+        pol = data.get("policy")
+        if isinstance(pol, dict):
+            policy = Policy(
+                vendors=pol.get("vendors"),
+                independence=pol.get("independence", "preferred"),
+                avoid_jurisdictions=pol.get("avoid_jurisdictions") or [],
+            )
+        return cls(name=name, stages=stages, policy=policy)
+
+    def build(self) -> Pipeline:
+        return Pipeline.from_manifest(self)

rapier/mcp/__init__.py

@@ -0,0 +1,9 @@
+"""Rapier's MCP server (optional — needs the ``mcp`` extra).
+
+``pip install "rapier-runtime[mcp]"`` then run ``rapier mcp``. The SDK is imported
+lazily inside :func:`build_server`, so importing this package (and the rest of the
+CLI) never requires the extra.
+"""
+from .server import build_server, serve
+
+__all__ = ["build_server", "serve"]