mrpd 0.1.0__py3-none-any.whl

mrpd/commands/publish.py

@@ -0,0 +1,102 @@
+from __future__ import annotations
+
+import asyncio
+import json
+import time
+from urllib.parse import urlparse
+
+import httpx
+import typer
+
+from mrpd.core.defaults import MRP_DEFAULT_REGISTRY_BASE
+
+
+def publish(
+    manifest_url: str,
+    registry: str | None,
+    poll_seconds: float,
+) -> None:
+    """Self-register a provider in the public registry using HTTP-01 domain control.
+
+    Flow:
+    1) POST /mrp/registry/submit {manifest_url}
+    2) Operator publishes challenge at /.well-known/mrp-registry-challenge/<token>
+    3) POST /mrp/registry/verify {token}
+
+    This is intentionally zero-trust: registry verifies domain control + manifest reachability.
+    """
+
+    async def _run() -> int:
+        base = (registry or MRP_DEFAULT_REGISTRY_BASE).rstrip("/")
+        submit_url = f"{base}/mrp/registry/submit"
+        verify_url = f"{base}/mrp/registry/verify"
+
+        # sanity check
+        try:
+            u = urlparse(manifest_url)
+            if u.scheme not in ("http", "https") or not u.netloc:
+                raise ValueError("manifest_url must be an http(s) URL")
+        except Exception as e:
+            typer.echo(f"Invalid manifest_url: {e}")
+            return 2
+
+        async with httpx.AsyncClient(timeout=20.0, follow_redirects=False) as client:
+            r = await client.post(
+                submit_url,
+                json={"manifest_url": manifest_url},
+                headers={"Content-Type": "application/json", "Accept": "application/mrp+json, application/json"},
+            )
+            if r.status_code >= 400:
+                typer.echo(f"Submit failed ({r.status_code}): {r.text}")
+                return 1
+
+            data = r.json()
+            challenge = (data.get("challenge") or {})
+            token = data.get("token")
+            expected = challenge.get("expected")
+            path = challenge.get("path")
+            url = challenge.get("url")
+
+            if not token or not expected or not path or not url:
+                typer.echo("Registry returned malformed challenge:")
+                typer.echo(json.dumps(data, indent=2))
+                return 1
+
+            typer.echo("\n=== MRP Registry HTTP-01 Challenge ===")
+            typer.echo(f"Registry: {base}")
+            typer.echo(f"Manifest: {manifest_url}")
+            typer.echo("")
+            typer.echo("Create a public file at:")
+            typer.echo(f"  {path}")
+            typer.echo("So that this URL returns EXACTLY this string:")
+            typer.echo(f"  {url}")
+            typer.echo("")
+            typer.echo(expected)
+            typer.echo("")
+            typer.echo("When ready, I will verify and publish the entry.")
+
+            # Poll verify
+            while True:
+                vr = await client.post(
+                    verify_url,
+                    json={"token": token},
+                    headers={"Content-Type": "application/json", "Accept": "application/mrp+json, application/json"},
+                )
+
+                if vr.status_code == 200:
+                    out = vr.json()
+                    typer.echo("\n✅ Verified and published:")
+                    typer.echo(json.dumps(out.get("entry") or out, indent=2, ensure_ascii=False))
+                    return 0
+
+                try:
+                    out = vr.json()
+                except Exception:
+                    out = {"error": vr.text}
+
+                err = out.get("error") or out.get("message") or vr.text
+                typer.echo(f"Waiting… ({err})")
+
+                await asyncio.sleep(poll_seconds)
+
+    raise typer.Exit(code=asyncio.run(_run()))

mrpd/commands/route.py

@@ -0,0 +1,126 @@
+from __future__ import annotations
+
+import asyncio
+
+import typer
+
+from mrpd.core.registry import RegistryClient, fetch_manifest
+from mrpd.core.scoring import ScoreResult, rank_entries
+
+
+def route(
+    intent: str,
+    capability: str | None,
+    policy: str | None,
+    registry: str | None,
+    limit: int,
+    bootstrap_raw: str | None,
+) -> None:
+    """Discover candidates for an intent from the registry and print ranked results.
+
+    v0: discovery + ranking + manifest fetch.
+    v1: negotiate/execute.
+    """
+
+    def loss_reason(winner: ScoreResult, candidate: ScoreResult) -> str:
+        if candidate.missing:
+            return f"missing requirements: {', '.join(candidate.missing)}"
+        if candidate.score != winner.score:
+            return f"lower score ({candidate.score:.2f} vs {winner.score:.2f})"
+        if candidate.required_matches != winner.required_matches:
+            return "fewer required matches"
+        if candidate.trust_score != winner.trust_score:
+            return "lower trust score"
+        if candidate.proofs_count != winner.proofs_count:
+            return "fewer proofs"
+        if (candidate.entry.name or "").lower() != (winner.entry.name or "").lower():
+            return "tiebreaker: name order"
+        return "tiebreaker: id order"
+
+    async def _run() -> int:
+        if bootstrap_raw:
+            import os
+
+            os.environ["MRP_BOOTSTRAP_REGISTRY_RAW"] = bootstrap_raw
+        client = RegistryClient(base_url=registry) if registry else RegistryClient()
+        try:
+            res = await client.query(capability=capability, policy=policy, limit=limit)
+        except Exception as ex:
+            typer.echo(f"Registry query failed: {ex}")
+            return 1
+
+        entries = list(res.results)
+        if not entries and (capability or policy):
+            try:
+                res = await client.query(limit=limit)
+                entries = list(res.results)
+            except Exception as ex:
+                typer.echo(f"Registry query failed: {ex}")
+                return 1
+
+        if not entries:
+            typer.echo("No registry entries matched (and entries must include manifest_url).")
+            return 1
+
+        ranked = rank_entries(entries, capability=capability, policy=policy)
+        satisfying = [r for r in ranked if r.satisfied]
+
+        typer.echo(f"Intent: {intent}")
+        if capability:
+            typer.echo(f"Filter capability: {capability}")
+        if policy:
+            typer.echo(f"Filter policy: {policy}")
+        typer.echo("")
+
+        if satisfying:
+            winner = satisfying[0]
+            typer.echo(
+                f"Winner: score={winner.score:.2f} id={winner.entry.id} name={winner.entry.name}"
+            )
+            winner_reason = ", ".join(winner.reasons) if winner.reasons else "best tiebreaker"
+            typer.echo(f"Why winner won: {winner_reason}")
+            typer.echo(f"Manifest: {winner.entry.manifest_url}")
+            if winner.entry.repo:
+                typer.echo(f"Repo: {winner.entry.repo}")
+            try:
+                manifest = await fetch_manifest(winner.entry.manifest_url)
+                caps = manifest.get("capability") or manifest.get("capability_id")
+                typer.echo(f"Manifest capability: {caps}")
+                endpoints = manifest.get("endpoints") or {}
+                if endpoints:
+                    typer.echo(f"Endpoints: {endpoints}")
+            except Exception as ex:
+                typer.echo(f"Manifest fetch FAILED: {ex}")
+            typer.echo("")
+
+            for r in satisfying[1:limit]:
+                typer.echo(f"- score={r.score:.2f} id={r.entry.id} name={r.entry.name}")
+                typer.echo(f"  why lost: {loss_reason(winner, r)}")
+                typer.echo(f"  manifest: {r.entry.manifest_url}")
+                if r.entry.repo:
+                    typer.echo(f"  repo: {r.entry.repo}")
+                try:
+                    manifest = await fetch_manifest(r.entry.manifest_url)
+                    caps = manifest.get("capability") or manifest.get("capability_id")
+                    typer.echo(f"  manifest.capability: {caps}")
+                    endpoints = manifest.get("endpoints") or {}
+                    if endpoints:
+                        typer.echo(f"  endpoints: {endpoints}")
+                except Exception as ex:
+                    typer.echo(f"  manifest fetch FAILED: {ex}")
+                typer.echo("")
+        else:
+            typer.echo("No candidates satisfied the requested requirements. Near-miss list:")
+            typer.echo("")
+            for r in ranked[:limit]:
+                missing = ", ".join(r.missing) if r.missing else "none"
+                typer.echo(f"- score={r.score:.2f} id={r.entry.id} name={r.entry.name}")
+                typer.echo(f"  missing: {missing}")
+                typer.echo(f"  manifest: {r.entry.manifest_url}")
+                if r.entry.repo:
+                    typer.echo(f"  repo: {r.entry.repo}")
+                typer.echo("")
+
+        return 0
+
+    raise typer.Exit(code=asyncio.run(_run()))

mrpd/commands/run.py

@@ -0,0 +1,169 @@
+from __future__ import annotations
+
+import asyncio
+import json
+import uuid
+
+import httpx
+import typer
+
+from mrpd.core.defaults import MRP_DEFAULT_REGISTRY_BASE
+from mrpd.core.envelopes import mk_envelope
+from mrpd.core.evidence import write_evidence_bundle
+from mrpd.core.registry import RegistryClient, fetch_manifest, normalize_manifest_endpoints
+from mrpd.core.scoring import rank_entries
+from mrpd.core.util import utc_now_rfc3339
+
+
+def run(
+    intent: str,
+    url: str,
+    capability: str,
+    policy: str | None,
+    registry: str | None,
+    manifest_url: str | None,
+    max_tokens: int | None,
+    max_cost: float | None,
+) -> None:
+    """End-to-end demo: query registry -> discover -> execute -> print evidence.
+
+    v0: expects provider implements /mrp/discover and /mrp/execute per manifest endpoints.
+    """
+
+    async def _run() -> int:
+        manifest: dict
+        receiver_id: str | None = None
+        if manifest_url:
+            typer.echo("Fetching manifest...")
+            manifest = await fetch_manifest(manifest_url)
+            manifest = normalize_manifest_endpoints(manifest, manifest_url)
+            # For the built-in demo provider, use a stable receiver id.
+            receiver_id = "service:mrpd"
+        else:
+            client = RegistryClient(base_url=registry) if registry else RegistryClient(base_url=MRP_DEFAULT_REGISTRY_BASE)
+            typer.echo("Querying registry...")
+            res = await client.query(capability=capability, policy=policy, limit=25)
+
+            ranked = rank_entries(res.results, capability=capability, policy=policy)
+            satisfying = [r for r in ranked if r.satisfied]
+            if not ranked:
+                typer.echo("No registry entries matched (requires manifest_url entries).")
+                typer.echo("Tip: use --manifest-url http://host/mrp/manifest for local testing.")
+                return 1
+            if not satisfying:
+                typer.echo("No registry entries satisfied required capability/policy.")
+                for r in ranked[:5]:
+                    missing = ", ".join(r.missing) if r.missing else "none"
+                    typer.echo(f"- score={r.score:.2f} id={r.entry.id} missing: {missing}")
+                return 1
+
+            # Pick top
+            entry = satisfying[0].entry
+            receiver_id = entry.id
+            typer.echo(f"Selected entry: {entry.id} ({entry.name})")
+            typer.echo("Fetching manifest...")
+            manifest = await fetch_manifest(entry.manifest_url)
+            manifest = normalize_manifest_endpoints(manifest, entry.manifest_url)
+
+        endpoints = manifest.get("endpoints") or {}
+        discover_url = endpoints.get("discover")
+        execute_url = endpoints.get("execute")
+        if not discover_url or not execute_url:
+            typer.echo("Selected manifest is missing endpoints.discover/execute")
+            return 1
+
+        # DISCOVER
+        typer.echo("Sending DISCOVER...")
+        discover_payload: dict = {
+            "intent": intent,
+            "inputs": [{"type": "url", "value": url}],
+            "constraints": {},
+        }
+        if max_cost is not None:
+            discover_payload["constraints"]["max_cost"] = max_cost
+        if policy:
+            discover_payload["constraints"]["policy"] = [policy]
+        # token budget is not in the core schema yet; put it in constraints extension
+        if max_tokens is not None:
+            discover_payload["constraints"]["max_context_tokens"] = max_tokens
+
+        discover_env = mk_envelope("DISCOVER", discover_payload, receiver_id=receiver_id)
+
+        async with httpx.AsyncClient(timeout=20.0, follow_redirects=False) as http:
+            r = await http.post(discover_url, json=discover_env, headers={"Content-Type": "application/mrp+json"})
+            r.raise_for_status()
+            offer_env = r.json()
+
+        offers = (offer_env.get("payload") or {}).get("offers") or []
+        if not offers:
+            typer.echo("No offers returned.")
+            typer.echo(json.dumps(offer_env, indent=2))
+            return 1
+
+        offer = offers[0]
+        route_id = offer.get("route_id")
+        if not route_id:
+            typer.echo("Offer missing route_id")
+            return 1
+
+        # EXECUTE
+        typer.echo("Sending EXECUTE...")
+        job_id = str(uuid.uuid4())
+        exec_payload = {
+            "route_id": route_id,
+            "inputs": [{"type": "url", "value": url}],
+            "output_format": "markdown",
+            "job": {"id": job_id, "intent": intent},
+        }
+        exec_env = mk_envelope("EXECUTE", exec_payload, receiver_id=receiver_id)
+
+        async with httpx.AsyncClient(timeout=60.0, follow_redirects=False) as http:
+            r = await http.post(execute_url, json=exec_env, headers={"Content-Type": "application/mrp+json"})
+            r.raise_for_status()
+            out = r.json()
+
+        typer.echo("Received evidence.")
+
+        payload = out.get("payload") or {}
+        response_job_id = payload.get("job_id") or job_id
+        outputs = payload.get("outputs") or []
+        artifact_refs = [o for o in outputs if isinstance(o, dict) and o.get("type") == "artifact"]
+
+        def envelope_meta(env: dict) -> dict:
+            return {
+                "msg_id": env.get("msg_id"),
+                "msg_type": env.get("msg_type"),
+                "timestamp": env.get("timestamp"),
+                "sender": env.get("sender"),
+                "receiver": env.get("receiver"),
+                "in_reply_to": env.get("in_reply_to"),
+            }
+
+        bundle = {
+            "job_id": response_job_id,
+            "created_at": utc_now_rfc3339(),
+            "transcript": {
+                "intent": intent,
+                "capability": capability,
+                "policy": policy,
+                "discover": {
+                    "endpoint": discover_url,
+                    "request": envelope_meta(discover_env),
+                    "response": envelope_meta(offer_env),
+                },
+                "execute": {
+                    "endpoint": execute_url,
+                    "request": envelope_meta(exec_env),
+                    "response": envelope_meta(out),
+                },
+            },
+            "artifact_refs": artifact_refs,
+            "evidence_envelope": out,
+        }
+        evidence_path = write_evidence_bundle(response_job_id, bundle)
+        typer.echo(f"Evidence bundle written: {evidence_path}")
+
+        typer.echo(json.dumps(out, indent=2, ensure_ascii=False))
+        return 0
+
+    raise typer.Exit(code=asyncio.run(_run()))

mrpd/commands/serve.py

@@ -0,0 +1,13 @@
+from __future__ import annotations
+
+import uvicorn
+
+
+def serve(host: str, port: int, reload: bool) -> None:
+    uvicorn.run(
+        "mrpd.api.app:app",
+        host=host,
+        port=port,
+        reload=reload,
+        log_level="info",
+    )

mrpd/commands/validate.py

@@ -0,0 +1,71 @@
+from __future__ import annotations
+
+import json
+import sys
+from importlib import resources
+
+import typer
+
+from mrpd.core.schema import validate_envelope
+
+
+def _validate_one(raw: str, label: str, *, quiet: bool = False) -> bool:
+    try:
+        envelope = json.loads(raw)
+    except json.JSONDecodeError as e:
+        if not quiet:
+            typer.echo(f"INVALID ({label}): invalid JSON: {e}")
+        return False
+
+    try:
+        validate_envelope(envelope)
+    except Exception as e:
+        if not quiet:
+            typer.echo(f"INVALID ({label}): {e}")
+        return False
+
+    return True
+
+
+def validate(path: str, fixtures: bool = False) -> None:
+    """Validate an envelope file or run bundled fixture validation."""
+
+    if fixtures:
+        base = resources.files("mrpd.spec").joinpath("fixtures")
+        valid_dir = base.joinpath("valid")
+        invalid_dir = base.joinpath("invalid")
+
+        ok = True
+
+        # Valid fixtures must pass
+        for p in sorted(valid_dir.glob("*.json")):
+            raw = p.read_text(encoding="utf-8")
+            if not _validate_one(raw, f"valid/{p.name}"):
+                ok = False
+
+        # Invalid fixtures must fail
+        for p in sorted(invalid_dir.glob("*.json")):
+            raw = p.read_text(encoding="utf-8")
+            if _validate_one(raw, f"invalid/{p.name}", quiet=True):
+                typer.echo(f"INVALID FIXTURE PASSED ({p.name})")
+                ok = False
+            else:
+                typer.echo(f"EXPECTED FAIL ({p.name})")
+
+        if not ok:
+            raise typer.Exit(code=1)
+
+        typer.echo("OK (fixtures)")
+        return
+
+    if path == "-":
+        raw = sys.stdin.read()
+        label = "stdin"
+    else:
+        raw = open(path, "r", encoding="utf-8").read()
+        label = path
+
+    if not _validate_one(raw, label):
+        raise typer.Exit(code=1)
+
+    typer.echo("OK")

mrpd/core/__init__.py

@@ -0,0 +1 @@
+__all__ = []

mrpd/core/artifacts.py

@@ -0,0 +1,39 @@
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+from typing import Any
+
+from mrpd.core.util import sha256_hex
+
+
+def default_artifact_dir() -> Path:
+    root = os.getenv("MRPD_ARTIFACT_DIR")
+    if root:
+        return Path(root)
+    # default under user home
+    return Path.home() / ".mrpd" / "artifacts"
+
+
+def store_bytes(data: bytes, *, mime: str, suffix: str = "") -> dict[str, Any]:
+    d = default_artifact_dir()
+    d.mkdir(parents=True, exist_ok=True)
+
+    h = sha256_hex(data)
+    name = h + (suffix if suffix else "")
+    path = d / name
+    path.write_bytes(data)
+
+    return {
+        "type": "artifact",
+        "uri": f"file://{path.as_posix()}",
+        "hash": f"sha256:{h}",
+        "size": len(data),
+        "mime": mime,
+    }
+
+
+def store_json(obj: Any, *, suffix: str = ".json") -> dict[str, Any]:
+    data = json.dumps(obj, ensure_ascii=False, indent=2).encode("utf-8")
+    return store_bytes(data, mime="application/json", suffix=suffix)

mrpd/core/config.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+import yaml
+from pydantic import BaseModel, Field
+
+
+class RegistrySource(BaseModel):
+    name: str
+    base_url: str
+
+
+class Config(BaseModel):
+    registries: list[RegistrySource] = Field(default_factory=list)
+    cache_dir: str | None = None
+    # TODO: adapters, local tools, auth keys
+
+
+def load_config(path: str | Path) -> Config:
+    p = Path(path)
+    data: Any = {}
+    if p.exists():
+        data = yaml.safe_load(p.read_text(encoding="utf-8")) or {}
+    return Config.model_validate(data)

mrpd/core/defaults.py

@@ -0,0 +1,7 @@
+# Canonical public MRP registry host (once deployed)
+MRP_DEFAULT_REGISTRY_BASE = "https://www.moltrouter.dev"
+
+# Fallback registry source (raw JSON list). Use ONLY if explicitly configured.
+# We default to the hosted registry API on https://www.moltrouter.dev.
+# Env var: MRP_BOOTSTRAP_REGISTRY_RAW (supports file:// for local testing)
+MRP_BOOTSTRAP_REGISTRY_RAW = None

mrpd/core/envelopes.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+import uuid
+from typing import Any
+
+from mrpd.core.util import utc_now_rfc3339
+
+
+def mk_envelope(
+    msg_type: str,
+    payload: dict[str, Any],
+    *,
+    sender_id: str = "agent:mrpd/client",
+    receiver_id: str | None = None,
+    in_reply_to: str | None = None,
+) -> dict[str, Any]:
+    env = {
+        "mrp_version": "0.1",
+        "msg_id": str(uuid.uuid4()),
+        "msg_type": msg_type,
+        "timestamp": utc_now_rfc3339(),
+        "sender": {"id": sender_id},
+        "payload": payload,
+    }
+    if receiver_id:
+        env["receiver"] = {"id": receiver_id}
+    if in_reply_to:
+        env["in_reply_to"] = in_reply_to
+    return env

mrpd/core/errors.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+from datetime import datetime, timezone
+from typing import Any
+
+
+def mrp_error(
+    *,
+    msg_id: str | None,
+    timestamp: str | None,
+    receiver_id: str | None = None,
+    in_reply_to: str | None = None,
+    code: str,
+    message: str,
+    retryable: bool = False,
+    retry_after_ms: int | None = None,
+    details: dict[str, Any] | None = None,
+) -> dict[str, Any]:
+    payload: dict[str, Any] = {"code": code, "message": message, "retryable": retryable}
+    if retry_after_ms is not None:
+        payload["retry_after_ms"] = retry_after_ms
+    if details is not None:
+        payload["details"] = details
+
+    env = {
+        "mrp_version": "0.1",
+        "msg_id": msg_id,
+        "msg_type": "ERROR",
+        "timestamp": timestamp or datetime.now(timezone.utc).isoformat().replace("+00:00", "Z"),
+        "sender": {"id": "service:mrpd"},
+        "payload": payload,
+    }
+    if receiver_id:
+        env["receiver"] = {"id": receiver_id}
+    if in_reply_to:
+        env["in_reply_to"] = in_reply_to
+    return env

mrpd/core/evidence.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+
+def evidence_dir() -> Path:
+    return Path.home() / ".mrpd" / "evidence"
+
+
+def write_evidence_bundle(job_id: str, bundle: dict[str, Any]) -> Path:
+    directory = evidence_dir()
+    directory.mkdir(parents=True, exist_ok=True)
+    path = directory / f"{job_id}.json"
+    path.write_text(json.dumps(bundle, indent=2), encoding="utf-8")
+    return path

mrpd/core/models.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+from typing import Any, List, Literal, Optional
+
+from pydantic import BaseModel, Field
+
+
+VerificationLevel = Literal["self_asserted", "registry_attested", "third_party_audited"]
+
+
+class TrustInfo(BaseModel):
+    score: Optional[float] = Field(default=None, ge=0.0, le=1.0)
+    proofs: List[str] = Field(default_factory=list)
+    level: Optional[VerificationLevel] = None
+
+
+class RegistryEntry(BaseModel):
+    id: str
+    name: str
+    description: Optional[str] = None
+
+    repo: Optional[str] = None
+    manifest_url: str
+
+    capabilities: List[str] = Field(default_factory=list)
+    policies: List[str] = Field(default_factory=list)
+    proofs: List[str] = Field(default_factory=list)
+
+    trust: Optional[TrustInfo] = None
+
+    metadata: dict[str, Any] = Field(default_factory=dict)
+
+
+class RegistryQueryResponse(BaseModel):
+    mrp_version: str = "0.1"
+    next_page: Optional[str] = None
+    results: List[RegistryEntry] = Field(default_factory=list)