mrpd 0.1.0__py3-none-any.whl

mrpd/core/provider.py

@@ -0,0 +1,100 @@
+from __future__ import annotations
+
+from typing import Any
+
+import httpx
+
+from mrpd.core.artifacts import store_bytes
+from mrpd.core.util import approx_tokens, strip_html, utc_now_rfc3339
+
+
+SERVICE_ID = "service:mrpd"
+
+
+def provider_manifest(base_url: str) -> dict[str, Any]:
+    # base_url should be full origin, e.g. http://127.0.0.1:8787
+    return {
+        "capability_id": "capability:mrp/summarize_url",
+        "capability": "summarize_url",
+        "version": "0.1",
+        "tags": ["mrp", "summarize", "web"],
+        "inputs": [{"type": "url"}],
+        "outputs": [{"type": "markdown"}, {"type": "artifact"}],
+        "constraints": {"policy": ["no_pii"]},
+        "cost": {"unit": "usd", "estimate": 0.0},
+        "latency": {"p50": "200ms"},
+        "proofs_required": [],
+        "endpoints": {
+            "discover": f"{base_url}/mrp/discover",
+            "negotiate": f"{base_url}/mrp/negotiate",
+            "execute": f"{base_url}/mrp/execute",
+        },
+    }
+
+
+def offers_for_discover(_discover_payload: dict[str, Any]) -> list[dict[str, Any]]:
+    return [
+        {
+            "route_id": "route:mrpd/summarize_url@0.1",
+            "capability": "summarize_url",
+            "confidence": 0.9,
+            "cost": {"unit": "usd", "estimate": 0.0},
+            "latency": {"p50": "200ms"},
+            "proofs": [],
+            "policy": ["no_pii"],
+            "risk": {"data_retention_days": 0, "training_use": "none", "subprocessors": []},
+            "endpoint": "/mrp/execute",
+        }
+    ]
+
+
+async def execute_summarize_url(inputs: list[dict[str, Any]]) -> dict[str, Any]:
+    url = None
+    for item in inputs:
+        if item.get("type") == "url":
+            url = item.get("value")
+            break
+    if not url:
+        raise ValueError("missing url input")
+
+    async with httpx.AsyncClient(timeout=30.0, follow_redirects=True) as client:
+        r = await client.get(url, headers={"User-Agent": "mrpd/0.1"})
+        r.raise_for_status()
+        ct = r.headers.get("content-type", "")
+        raw_bytes = r.content
+
+    text = ""
+    if "text/html" in ct:
+        text = strip_html(raw_bytes.decode("utf-8", "replace"))
+    else:
+        # best effort
+        text = raw_bytes.decode("utf-8", "replace")
+
+    # store artifact of extracted text
+    artifact = store_bytes(text.encode("utf-8"), mime="text/plain", suffix=".txt")
+
+    # crude summary: first ~1200 chars
+    summary = text[:1200]
+    if len(text) > 1200:
+        summary += "\n\n…"
+
+    tokens_in = approx_tokens(text)
+    tokens_out = approx_tokens(summary)
+
+    return {
+        "outputs": [
+            {"type": "markdown", "value": f"## Summary\n\n{summary}\n"},
+            artifact,
+        ],
+        "provenance": {
+            "citations": [url],
+            "timestamp": utc_now_rfc3339(),
+            "source_hashes": [artifact["hash"]],
+        },
+        "usage": {
+            "tokens_in_est": tokens_in,
+            "tokens_out_est": tokens_out,
+            "bytes_in": len(raw_bytes),
+            "bytes_text": len(text.encode("utf-8")),
+        },
+    }

mrpd/core/registry.py

@@ -0,0 +1,115 @@
+from __future__ import annotations
+
+import json
+import os
+from typing import Optional
+from urllib.parse import urlparse
+
+import httpx
+
+from mrpd.core.defaults import MRP_BOOTSTRAP_REGISTRY_RAW, MRP_DEFAULT_REGISTRY_BASE
+from mrpd.core.models import RegistryEntry, RegistryQueryResponse
+
+
+def normalize_manifest_endpoints(manifest: dict, manifest_url: str) -> dict:
+    """Ensure manifest.endpoints contain absolute URLs.
+
+    If endpoints are relative ("/mrp/execute"), prefix with the origin of manifest_url.
+    """
+
+    out = dict(manifest)
+    endpoints = dict(out.get("endpoints") or {})
+
+    parsed = urlparse(manifest_url)
+    origin = f"{parsed.scheme}://{parsed.netloc}" if parsed.scheme and parsed.netloc else ""
+
+    for k, v in list(endpoints.items()):
+        if isinstance(v, str) and v.startswith("/") and origin:
+            endpoints[k] = origin + v
+
+    out["endpoints"] = endpoints
+    return out
+
+
+class RegistryClient:
+    def __init__(self, base_url: str = MRP_DEFAULT_REGISTRY_BASE, timeout: float = 10.0) -> None:
+        self.base_url = base_url.rstrip("/")
+        self.timeout = timeout
+
+    async def query(
+        self,
+        *,
+        capability: Optional[str] = None,
+        policy: Optional[str] = None,
+        limit: int = 50,
+        cursor: Optional[str] = None,
+    ) -> RegistryQueryResponse:
+        """Query the MRP registry API. Falls back to raw GitHub JSON if API is unavailable."""
+
+        url = f"{self.base_url}/mrp/registry/query"
+        params = {"limit": str(limit)}
+        if capability:
+            params["capability"] = capability
+        if policy:
+            params["policy"] = policy
+        if cursor:
+            params["cursor"] = cursor
+
+        try:
+            async with httpx.AsyncClient(timeout=self.timeout, follow_redirects=False) as client:
+                r = await client.get(url, params=params, headers={"Accept": "application/json"})
+                r.raise_for_status()
+                return RegistryQueryResponse.model_validate(r.json())
+        except Exception:
+            entries = await self._fetch_raw_entries()
+            if capability:
+                entries = [e for e in entries if capability in e.capabilities]
+            if policy:
+                entries = [e for e in entries if policy in e.policies]
+            return RegistryQueryResponse(results=entries)
+
+    async def _fetch_raw_entries(self) -> list[RegistryEntry]:
+        raw_url = os.getenv("MRP_BOOTSTRAP_REGISTRY_RAW") or MRP_BOOTSTRAP_REGISTRY_RAW
+        if not raw_url:
+            # No bootstrap configured; callers should rely on the hosted registry API.
+            return []
+
+        if raw_url.startswith("file://"):
+            path = raw_url[len("file://") :]
+            # Windows file URLs sometimes come through as /C:/...
+            if len(path) >= 3 and path[0] == "/" and path[2] == ":":
+                path = path[1:]
+            payload = json.loads(open(path, "r", encoding="utf-8").read())
+        else:
+            async with httpx.AsyncClient(timeout=self.timeout, follow_redirects=False) as client:
+                r = await client.get(raw_url, headers={"Accept": "application/json"})
+                r.raise_for_status()
+                payload = r.json()
+
+        if not isinstance(payload, list):
+            raise ValueError("bootstrap registry did not return a list")
+
+        entries: list[RegistryEntry] = []
+        for item in payload:
+            if not isinstance(item, dict) or not item.get("manifest_url"):
+                continue
+            entries.append(RegistryEntry.model_validate(item))
+
+        dedup: dict[str, RegistryEntry] = {}
+        for e in entries:
+            if e.id not in dedup:
+                dedup[e.id] = e
+        return list(dedup.values())
+
+
+async def fetch_manifest(manifest_url: str, timeout: float = 10.0) -> dict:
+    if manifest_url.startswith("file://"):
+        path = manifest_url[len("file://") :]
+        if len(path) >= 3 and path[0] == "/" and path[2] == ":":
+            path = path[1:]
+        return json.loads(open(path, "r", encoding="utf-8").read())
+
+    async with httpx.AsyncClient(timeout=timeout, follow_redirects=False) as client:
+        r = await client.get(manifest_url, headers={"Accept": "application/mrp-manifest+json, application/json"})
+        r.raise_for_status()
+        return r.json()

mrpd/core/schema.py

@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+import json
+from importlib import resources
+from typing import Any
+
+import jsonschema
+
+
+def load_schema_text(rel_path: str) -> str:
+    """Load a schema file shipped inside mrpd (package data)."""
+    # rel_path like: "schemas/envelope.schema.json"
+    return resources.files("mrpd.spec").joinpath(rel_path).read_text(encoding="utf-8")
+
+
+def load_schema(rel_path: str) -> dict[str, Any]:
+    return json.loads(load_schema_text(rel_path))
+
+
+def validate_envelope(envelope: dict[str, Any]) -> None:
+    schema = load_schema("schemas/envelope.schema.json")
+
+    # Resolve local $refs inside the shipped schema folder.
+    base = resources.files("mrpd.spec").joinpath("schemas")
+
+    def _load_by_rel(rel: str) -> dict[str, Any]:
+        p = rel
+        if p.startswith("./"):
+            p = p[2:]
+        text = base.joinpath(p).read_text(encoding="utf-8")
+        return json.loads(text)
+
+    def _https_handler(uri: str) -> Any:
+        """Map https://moltrouter.dev/schemas/mrp/0.1/... to bundled files.
+
+        jsonschema will resolve relative refs against the envelope $id (https://moltrouter.dev/...).
+        Without this handler, it tries to fetch over the network.
+        """
+
+        marker = "/schemas/mrp/0.1/"
+        if marker in uri:
+            rel = uri.split(marker, 1)[1]
+            return _load_by_rel(rel)
+        # Back-compat for older ids that used moltrouter.dev without the /schemas/mrp/0.1 prefix
+        uri2 = uri.replace("https://moltrouter.dev/", "https://www.moltrouter.dev/")
+        if marker in uri2:
+            rel = uri2.split(marker, 1)[1]
+            return _load_by_rel(rel)
+        # Fallback: try to treat the URL path as a relative file
+        # e.g. https://example/x/y.json -> y.json
+        rel = uri.rsplit("/", 1)[-1]
+        return _load_by_rel(rel)
+
+    # Handlers are selected by URI scheme.
+    resolver = jsonschema.RefResolver.from_schema(
+        schema,
+        handlers={
+            "": _load_by_rel,  # relative refs
+            "https": _https_handler,
+            "http": _https_handler,
+        },
+    )
+
+    jsonschema.validate(instance=envelope, schema=schema, resolver=resolver)

mrpd/core/scoring.py

@@ -0,0 +1,92 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Iterable
+
+from mrpd.core.models import RegistryEntry
+
+
+@dataclass(frozen=True)
+class ScoreResult:
+    entry: RegistryEntry
+    score: float
+    required_matches: int
+    trust_score: float
+    proofs_count: int
+    reasons: tuple[str, ...]
+    missing: tuple[str, ...]
+
+    @property
+    def satisfied(self) -> bool:
+        return len(self.missing) == 0
+
+    def rank_key(self) -> tuple:
+        # Deterministic ordering: score, required matches, trust, proofs, name, id.
+        return (
+            -self.score,
+            -self.required_matches,
+            -self.trust_score,
+            -self.proofs_count,
+            (self.entry.name or "").lower(),
+            self.entry.id,
+        )
+
+
+def score_entry(entry: RegistryEntry, *, capability: str | None, policy: str | None) -> ScoreResult:
+    """Deterministic scoring with explicit tie-breakers.
+
+    Score weights are simple and predictable; ties break by required matches,
+    trust score, proof count, then stable name/id ordering.
+    """
+
+    score = 0.0
+    reasons: list[str] = []
+    missing: list[str] = []
+    required_matches = 0
+
+    if capability:
+        if capability in entry.capabilities:
+            score += 50.0
+            required_matches += 1
+            reasons.append(f"capability match: {capability}")
+        else:
+            missing.append(f"capability:{capability}")
+
+    if policy:
+        if policy in entry.policies:
+            score += 20.0
+            required_matches += 1
+            reasons.append(f"policy match: {policy}")
+        else:
+            missing.append(f"policy:{policy}")
+
+    trust_score = 0.0
+    if entry.trust and entry.trust.score is not None:
+        trust_score = float(entry.trust.score)
+        score += 10.0 * trust_score
+        reasons.append(f"trust score: {trust_score:.2f}")
+
+    proofs_count = len(entry.proofs)
+    if proofs_count:
+        reasons.append(f"proofs: {proofs_count}")
+
+    if capability and policy and (capability in entry.capabilities) and (policy in entry.policies):
+        score += 5.0
+        reasons.append("capability+policy bonus")
+
+    return ScoreResult(
+        entry=entry,
+        score=score,
+        required_matches=required_matches,
+        trust_score=trust_score,
+        proofs_count=proofs_count,
+        reasons=tuple(reasons),
+        missing=tuple(missing),
+    )
+
+
+def rank_entries(
+    entries: Iterable[RegistryEntry], *, capability: str | None, policy: str | None
+) -> list[ScoreResult]:
+    scored = [score_entry(e, capability=capability, policy=policy) for e in entries]
+    return sorted(scored, key=lambda r: r.rank_key())

mrpd/core/util.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+import hashlib
+import re
+from datetime import datetime, timezone
+
+
+def utc_now_rfc3339() -> str:
+    return datetime.now(timezone.utc).isoformat().replace("+00:00", "Z")
+
+
+def sha256_hex(data: bytes) -> str:
+    return hashlib.sha256(data).hexdigest()
+
+
+def approx_tokens(text: str) -> int:
+    # rough heuristic: ~4 chars/token for English-ish text
+    return max(1, len(text) // 4)
+
+
+def strip_html(html: str) -> str:
+    # extremely simple tag stripper for v0 (good enough for demo)
+    html = re.sub(r"<script[\s\S]*?</script>", " ", html, flags=re.IGNORECASE)
+    html = re.sub(r"<style[\s\S]*?</style>", " ", html, flags=re.IGNORECASE)
+    text = re.sub(r"<[^>]+>", " ", html)
+    text = re.sub(r"\s+", " ", text).strip()
+    return text

mrpd/spec/__init__.py

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

mrpd/spec/fixtures/README.md

@@ -0,0 +1,8 @@
+# MRP Fixtures
+
+These fixtures are intended for interoperability testing.
+
+- `valid/` should validate against `schemas/envelope.schema.json`
+- `invalid/` should fail validation
+
+Use them to build a conformance test suite in any language.

mrpd/spec/fixtures/invalid/bad_msg_type.json

@@ -0,0 +1,8 @@
+{
+  "mrp_version": "0.1",
+  "msg_id": "00000000-0000-0000-0000-000000000004",
+  "msg_type": "NOT_A_REAL_TYPE",
+  "timestamp": "2025-01-01T00:00:00Z",
+  "sender": {"id": "agent:moltbots/alpha"},
+  "payload": {}
+}

mrpd/spec/fixtures/invalid/missing_required_fields.json

@@ -0,0 +1,7 @@
+{
+  "mrp_version": "0.1",
+  "msg_type": "DISCOVER",
+  "timestamp": "2025-01-01T00:00:00Z",
+  "sender": {"id": "agent:moltbots/alpha"},
+  "payload": {"intent": "x"}
+}

mrpd/spec/fixtures/valid/discover.json

@@ -0,0 +1,13 @@
+{
+  "mrp_version": "0.1",
+  "msg_id": "00000000-0000-0000-0000-000000000001",
+  "msg_type": "DISCOVER",
+  "timestamp": "2025-01-01T00:00:00Z",
+  "sender": {"id": "agent:moltbots/alpha"},
+  "payload": {
+    "intent": "extract pricing from vendor docs",
+    "inputs": [{"type": "url", "value": "https://example.com/pricing"}],
+    "constraints": {"max_cost": 0.05, "policy": ["no_pii"]},
+    "proofs_required": ["attestation"]
+  }
+}

mrpd/spec/fixtures/valid/error.json

@@ -0,0 +1,13 @@
+{
+  "mrp_version": "0.1",
+  "msg_id": "00000000-0000-0000-0000-000000000003",
+  "msg_type": "ERROR",
+  "timestamp": "2025-01-01T00:00:02Z",
+  "sender": {"id": "service:clawdbots/summarize"},
+  "payload": {
+    "code": "MRP_RATE_LIMITED",
+    "message": "Rate limit exceeded",
+    "retryable": true,
+    "retry_after_ms": 5000
+  }
+}

mrpd/spec/fixtures/valid/offer.json

@@ -0,0 +1,20 @@
+{
+  "mrp_version": "0.1",
+  "msg_id": "00000000-0000-0000-0000-000000000002",
+  "msg_type": "OFFER",
+  "timestamp": "2025-01-01T00:00:01Z",
+  "sender": {"id": "service:clawdbots/summarize"},
+  "receiver": {"id": "agent:moltbots/alpha"},
+  "payload": {
+    "offers": [
+      {
+        "route_id": "route-123",
+        "capability": "summarize",
+        "confidence": 0.9,
+        "policy": ["no_pii"],
+        "risk": {"data_retention_days": 0, "training_use": "none", "subprocessors": []},
+        "endpoint": "/mrp/negotiate"
+      }
+    ]
+  }
+}

mrpd/spec/schemas/envelope.schema.json

@@ -0,0 +1,102 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://www.moltrouter.dev/schemas/mrp/0.1/envelope.schema.json",
+  "title": "MRP Envelope (0.1)",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["mrp_version", "msg_id", "msg_type", "timestamp", "sender", "payload"],
+  "properties": {
+    "mrp_version": {"type": "string", "pattern": "^[0-9]+\\.[0-9]+$"},
+    "msg_id": {"type": "string", "minLength": 8},
+    "msg_type": {
+      "type": "string",
+      "enum": [
+        "HELLO",
+        "DISCOVER",
+        "OFFER",
+        "NEGOTIATE",
+        "EXECUTE",
+        "EVIDENCE",
+        "JOB_ACCEPTED",
+        "JOB_STATUS",
+        "STREAM_CHUNK",
+        "ERROR"
+      ]
+    },
+    "timestamp": {"type": "string", "format": "date-time"},
+    "sender": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["id"],
+      "properties": {
+        "id": {"type": "string", "minLength": 3},
+        "proofs": {"type": "array", "items": {"type": "string"}}
+      }
+    },
+    "receiver": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["id"],
+      "properties": {"id": {"type": "string", "minLength": 3}}
+    },
+    "in_reply_to": {"type": "string", "minLength": 8},
+    "trace": {
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "root": {"type": "string"},
+        "parent": {"type": "string"}
+      }
+    },
+    "auth": {
+      "type": "object",
+      "additionalProperties": true,
+      "properties": {
+        "type": {"type": "string", "enum": ["bearer", "mTLS", "signed"]},
+        "token": {"type": "string"},
+        "scopes": {"type": "array", "items": {"type": "string"}},
+        "issuer": {"type": "string"},
+        "signature": {
+          "type": "object",
+          "additionalProperties": false,
+          "required": ["alg", "key_id", "value"],
+          "properties": {
+            "alg": {"type": "string"},
+            "key_id": {"type": "string"},
+            "value": {"type": "string"}
+          }
+        }
+      }
+    },
+    "nonce": {"type": "string"},
+    "expires_at": {"type": "string", "format": "date-time"},
+    "idempotency_key": {"type": "string"},
+    "payload": {"type": "object"}
+  },
+  "allOf": [
+    {
+      "if": {"properties": {"msg_type": {"const": "DISCOVER"}}},
+      "then": {"properties": {"payload": {"$ref": "./payloads/discover.schema.json"}}}
+    },
+    {
+      "if": {"properties": {"msg_type": {"const": "OFFER"}}},
+      "then": {"properties": {"payload": {"$ref": "./payloads/offer.schema.json"}}}
+    },
+    {
+      "if": {"properties": {"msg_type": {"const": "NEGOTIATE"}}},
+      "then": {"properties": {"payload": {"$ref": "./payloads/negotiate.schema.json"}}}
+    },
+    {
+      "if": {"properties": {"msg_type": {"const": "EXECUTE"}}},
+      "then": {"properties": {"payload": {"$ref": "./payloads/execute.schema.json"}}}
+    },
+    {
+      "if": {"properties": {"msg_type": {"const": "EVIDENCE"}}},
+      "then": {"properties": {"payload": {"$ref": "./payloads/evidence.schema.json"}}}
+    },
+    {
+      "if": {"properties": {"msg_type": {"const": "ERROR"}}},
+      "then": {"properties": {"payload": {"$ref": "./payloads/error.schema.json"}}}
+    }
+  ]
+}

mrpd/spec/schemas/manifest.schema.json

@@ -0,0 +1,52 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://www.moltrouter.dev/schemas/mrp/0.1/manifest.schema.json",
+  "title": "MRP Capability Manifest (0.1)",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["capability_id", "capability", "version", "inputs", "outputs", "endpoints"],
+  "properties": {
+    "capability_id": {"type": "string"},
+    "capability": {"type": "string"},
+    "version": {"type": "string"},
+    "tags": {"type": "array", "items": {"type": "string"}},
+    "inputs": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": ["type"],
+        "properties": {
+          "type": {"type": "string"},
+          "schema_ref": {"type": "string"}
+        }
+      }
+    },
+    "outputs": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": ["type"],
+        "properties": {
+          "type": {"type": "string"},
+          "schema_ref": {"type": "string"}
+        }
+      }
+    },
+    "constraints": {"type": "object", "additionalProperties": true},
+    "cost": {"type": "object"},
+    "latency": {"type": "object"},
+    "proofs_required": {"type": "array", "items": {"type": "string"}},
+    "endpoints": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["discover", "negotiate", "execute"],
+      "properties": {
+        "discover": {"type": "string"},
+        "negotiate": {"type": "string"},
+        "execute": {"type": "string"}
+      }
+    }
+  }
+}

mrpd/spec/schemas/payloads/discover.schema.json

@@ -0,0 +1,23 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://www.moltrouter.dev/schemas/mrp/0.1/payloads/discover.schema.json",
+  "title": "MRP DISCOVER Payload",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["intent"],
+  "properties": {
+    "intent": {"type": "string", "minLength": 1},
+    "inputs": {"type": "array", "items": {"$ref": "../types/input.schema.json"}},
+    "constraints": {
+      "type": "object",
+      "additionalProperties": true,
+      "properties": {
+        "max_cost": {"type": "number", "minimum": 0},
+        "max_latency_ms": {"type": "integer", "minimum": 0},
+        "data_residency": {"type": "string"},
+        "policy": {"type": "array", "items": {"type": "string"}}
+      }
+    },
+    "proofs_required": {"type": "array", "items": {"type": "string"}}
+  }
+}