mrpd 0.1.0__py3-none-any.whl

mrpd/__init__.py

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

mrpd/adapters/__init__.py

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

mrpd/api/app.py

@@ -0,0 +1,8 @@
+from __future__ import annotations
+
+from fastapi import FastAPI
+
+from mrpd.api.routes import router
+
+app = FastAPI(title="mrpd (Moltrouter Protocol Daemon)")
+app.include_router(router)

mrpd/api/routes.py

@@ -0,0 +1,200 @@
+from __future__ import annotations
+
+from fastapi import APIRouter
+
+from mrpd.core.errors import mrp_error
+from mrpd.core.schema import validate_envelope
+
+router = APIRouter()
+
+
+def response_envelope(envelope: dict, *, msg_type: str, payload: dict) -> dict:
+    """Build a response envelope.
+
+    IMPORTANT: response message ids must be new, and in_reply_to must reference
+    the triggering request msg_id.
+    """
+
+    from mrpd.core.util import utc_now_rfc3339
+    import uuid
+
+    sender_id = (envelope.get("sender") or {}).get("id")
+    req_msg_id = envelope.get("msg_id")
+
+    resp = {
+        "mrp_version": envelope.get("mrp_version", "0.1"),
+        "msg_id": str(uuid.uuid4()),
+        "msg_type": msg_type,
+        "timestamp": utc_now_rfc3339(),
+        "sender": {"id": "service:mrpd"},
+        "payload": payload,
+    }
+    if sender_id:
+        resp["receiver"] = {"id": sender_id}
+    if req_msg_id:
+        resp["in_reply_to"] = req_msg_id
+    return resp
+
+
+@router.get("/.well-known/mrp.json")
+async def well_known() -> dict:
+    return {
+        "mrp_version": "0.1",
+        "capabilities": ["summarize_url"],
+        "manifest_url": "/mrp/manifest",
+    }
+
+
+@router.get("/mrp/manifest")
+async def manifest() -> dict:
+    # Provider manifest for the built-in demo capability.
+    # NOTE: this endpoint returns relative URLs; clients may prefer absolute.
+    # Our `mrpd run` prefers manifests from registry entries (absolute endpoints).
+    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"]},
+        "proofs_required": [],
+        "endpoints": {
+            "discover": "/mrp/discover",
+            "negotiate": "/mrp/negotiate",
+            "execute": "/mrp/execute",
+        },
+    }
+
+
+@router.post("/mrp/hello")
+async def hello(envelope: dict) -> dict:
+    try:
+        validate_envelope(envelope)
+    except Exception as e:
+        sender_id = (envelope.get("sender") or {}).get("id")
+        msg_id = envelope.get("msg_id")
+        return mrp_error(
+            msg_id=msg_id,
+            timestamp=envelope.get("timestamp"),
+            receiver_id=sender_id,
+            in_reply_to=msg_id,
+            code="MRP_INVALID_REQUEST",
+            message=str(e),
+            retryable=False,
+        )
+
+    return response_envelope(
+        envelope,
+        msg_type="HELLO",
+        payload={"ok": True, "schemas": ["0.1"]},
+    )
+
+
+@router.post("/mrp/discover")
+async def discover(envelope: dict) -> dict:
+    try:
+        validate_envelope(envelope)
+    except Exception as e:
+        sender_id = (envelope.get("sender") or {}).get("id")
+        msg_id = envelope.get("msg_id")
+        return mrp_error(
+            msg_id=msg_id,
+            timestamp=envelope.get("timestamp"),
+            receiver_id=sender_id,
+            in_reply_to=msg_id,
+            code="MRP_INVALID_REQUEST",
+            message=str(e),
+            retryable=False,
+        )
+
+    from mrpd.core.provider import offers_for_discover
+
+    offers = offers_for_discover(envelope.get("payload") or {})
+    return response_envelope(
+        envelope,
+        msg_type="OFFER",
+        payload={"offers": offers},
+    )
+
+
+@router.post("/mrp/negotiate")
+async def negotiate(envelope: dict) -> dict:
+    try:
+        validate_envelope(envelope)
+    except Exception as e:
+        sender_id = (envelope.get("sender") or {}).get("id")
+        msg_id = envelope.get("msg_id")
+        return mrp_error(
+            msg_id=msg_id,
+            timestamp=envelope.get("timestamp"),
+            receiver_id=sender_id,
+            in_reply_to=msg_id,
+            code="MRP_INVALID_REQUEST",
+            message=str(e),
+            retryable=False,
+        )
+
+    return response_envelope(
+        envelope,
+        msg_type="NEGOTIATE",
+        payload={"accepted": False, "reason": "not implemented"},
+    )
+
+
+@router.post("/mrp/execute")
+async def execute(envelope: dict) -> dict:
+    try:
+        validate_envelope(envelope)
+    except Exception as e:
+        sender_id = (envelope.get("sender") or {}).get("id")
+        msg_id = envelope.get("msg_id")
+        return mrp_error(
+            msg_id=msg_id,
+            timestamp=envelope.get("timestamp"),
+            receiver_id=sender_id,
+            in_reply_to=msg_id,
+            code="MRP_INVALID_REQUEST",
+            message=str(e),
+            retryable=False,
+        )
+
+    from mrpd.core.provider import execute_summarize_url
+
+    payload = envelope.get("payload") or {}
+    route_id = payload.get("route_id")
+    inputs = payload.get("inputs") or []
+    job_id = (payload.get("job") or {}).get("id")
+
+    try:
+        if route_id == "route:mrpd/summarize_url@0.1":
+            evidence = await execute_summarize_url(inputs)
+        else:
+            sender_id = (envelope.get("sender") or {}).get("id")
+            msg_id = envelope.get("msg_id")
+            return mrp_error(
+                msg_id=msg_id,
+                timestamp=envelope.get("timestamp"),
+                receiver_id=sender_id,
+                in_reply_to=msg_id,
+                code="MRP_INVALID_REQUEST",
+                message=f"Unknown route_id: {route_id}",
+                retryable=False,
+            )
+    except Exception as e:
+        sender_id = (envelope.get("sender") or {}).get("id")
+        msg_id = envelope.get("msg_id")
+        return mrp_error(
+            msg_id=msg_id,
+            timestamp=envelope.get("timestamp"),
+            receiver_id=sender_id,
+            in_reply_to=msg_id,
+            code="MRP_INTERNAL_ERROR",
+            message=str(e),
+            retryable=False,
+        )
+
+    response_payload = {"route_id": route_id, **evidence}
+    if job_id:
+        response_payload["job_id"] = job_id
+    return response_envelope(envelope, msg_type="EVIDENCE", payload=response_payload)

mrpd/cli.py

@@ -0,0 +1,182 @@
+from __future__ import annotations
+
+import typer
+
+from mrpd.commands.bridge_mcp import bridge_mcp
+from mrpd.commands.bridge_openapi import bridge_openapi
+from mrpd.commands.init_provider import init_provider
+from mrpd.commands.mrpify_mcp import mrpify_mcp
+from mrpd.commands.mrpify_openapi import mrpify_openapi
+from mrpd.commands.publish import publish
+from mrpd.commands.route import route
+from mrpd.commands.run import run
+from mrpd.commands.serve import serve
+from mrpd.commands.validate import validate
+
+app = typer.Typer(add_completion=False)
+
+bridge_app = typer.Typer(help="Generate MRP provider wrappers (bridges)")
+app.add_typer(bridge_app, name="bridge")
+
+mrpify_app = typer.Typer(help="MRP-ify existing systems with a guided flow")
+app.add_typer(mrpify_app, name="mrpify")
+
+
+@app.command()
+def version() -> None:
+    """Print version."""
+    typer.echo("mrpd 0.1.0")
+
+
+@app.command(name="serve")
+def serve_cmd(
+    host: str = typer.Option("127.0.0.1", "--host"),
+    port: int = typer.Option(8787, "--port"),
+    reload: bool = typer.Option(False, "--reload"),
+) -> None:
+    """Run the MRP HTTP server."""
+    serve(host=host, port=port, reload=reload)
+
+
+@app.command(name="validate")
+def validate_cmd(
+    path: str = typer.Option("-", "--path", help="JSON file path or '-' for stdin"),
+    fixtures: bool = typer.Option(False, "--fixtures", help="Validate bundled fixtures (valid must pass, invalid must fail)"),
+) -> None:
+    """Validate an MRP envelope against the bundled JSON Schemas."""
+    validate(path, fixtures=fixtures)
+
+
+@app.command(name="route")
+def route_cmd(
+    intent: str = typer.Argument(..., help="High-level intent (human text)"),
+    capability: str | None = typer.Option(None, "--capability", help="Capability filter"),
+    policy: str | None = typer.Option(None, "--policy", help="Policy filter"),
+    registry: str | None = typer.Option(None, "--registry", help="Registry base URL (default: https://www.moltrouter.dev)"),
+    bootstrap_raw: str | None = typer.Option(None, "--bootstrap-raw", help="Override fallback raw registry JSON (URL or file://path)"),
+    limit: int = typer.Option(10, "--limit", min=1, max=50),
+) -> None:
+    """Query registry + rank candidates for an intent."""
+    route(intent=intent, capability=capability, policy=policy, registry=registry, limit=limit, bootstrap_raw=bootstrap_raw)
+
+
+@app.command(name="run")
+def run_cmd(
+    intent: str = typer.Argument(..., help="High-level intent (human text)"),
+    url: str = typer.Option(..., "--url", help="URL input"),
+    capability: str = typer.Option("summarize_url", "--capability", help="Capability to request"),
+    policy: str | None = typer.Option(None, "--policy", help="Policy requirement"),
+    registry: str | None = typer.Option(None, "--registry", help="Registry base URL (default: https://www.moltrouter.dev)"),
+    manifest_url: str | None = typer.Option(None, "--manifest-url", help="Skip registry and use this provider manifest URL (useful for local testing)"),
+    max_tokens: int | None = typer.Option(None, "--max-tokens", help="Soft max context tokens (constraint hint)"),
+    max_cost: float | None = typer.Option(None, "--max-cost", help="Max cost (constraint hint)"),
+) -> None:
+    """End-to-end: DISCOVER -> EXECUTE against the best matching provider."""
+    run(intent=intent, url=url, capability=capability, policy=policy, registry=registry, manifest_url=manifest_url, max_tokens=max_tokens, max_cost=max_cost)
+
+
+@app.command(name="publish")
+def publish_cmd(
+    manifest_url: str = typer.Option(..., "--manifest-url", help="Provider manifest URL to self-register"),
+    registry: str | None = typer.Option(None, "--registry", help="Registry base URL (default: https://www.moltrouter.dev)"),
+    poll_seconds: float = typer.Option(5.0, "--poll-seconds", min=1.0, max=60.0),
+) -> None:
+    """Self-register a provider in the public registry using HTTP-01 challenge."""
+    publish(manifest_url=manifest_url, registry=registry, poll_seconds=poll_seconds)
+
+
+@app.command(name="init-provider")
+def init_provider_cmd(
+    out_dir: str = typer.Option("./mrp-provider", "--out-dir", help="Output directory"),
+    capability: str = typer.Option(..., "--capability", help="Capability name (e.g. summarize_url)"),
+    provider_id: str = typer.Option("service:example/provider", "--provider-id", help="Provider sender id"),
+    name: str = typer.Option("MRP Provider", "--name"),
+    description: str = typer.Option("", "--description"),
+    policy: list[str] = typer.Option([], "--policy", help="Policy strings (repeatable)")
+) -> None:
+    """Scaffold a minimal FastAPI MRP provider wrapper."""
+    init_provider(out_dir=out_dir, capability=capability, provider_id=provider_id, name=name, description=description, policy=policy)
+
+
+@bridge_app.command(name="openapi")
+def bridge_openapi_cmd(
+    spec: str = typer.Option(..., "--spec", help="Path to OpenAPI spec (json/yaml)"),
+    out_dir: str = typer.Option("./mrp-openapi-bridge", "--out-dir", help="Output directory"),
+    provider_id: str = typer.Option("service:openapi/bridge", "--provider-id", help="Provider sender id"),
+    backend_base_url: str | None = typer.Option(None, "--backend-base-url", help="Override OpenAPI servers[0].url"),
+    capability_prefix: str | None = typer.Option(None, "--capability-prefix", help="Prefix for generated capabilities (e.g. svc_)"),
+) -> None:
+    """Generate an MRP provider wrapper from an OpenAPI spec."""
+    bridge_openapi(spec=spec, out_dir=out_dir, provider_id=provider_id, backend_base_url=backend_base_url, capability_prefix=capability_prefix)
+
+
+@bridge_app.command(name="mcp")
+def bridge_mcp_cmd(
+    tools_json: str = typer.Option(..., "--tools-json", help="Path to MCP tools list JSON"),
+    out_dir: str = typer.Option("./mrp-mcp-bridge", "--out-dir", help="Output directory"),
+    provider_id: str = typer.Option("service:mcp/bridge", "--provider-id", help="Provider sender id"),
+    mcp_command: str = typer.Option(..., "--mcp-command", help="MCP server command (stdio)"),
+    mcp_args: list[str] = typer.Option([], "--mcp-arg", help="MCP server argument (repeatable)"),
+) -> None:
+    """Generate an MRP provider wrapper scaffold from an MCP tool list."""
+    bridge_mcp(tools_json=tools_json, out_dir=out_dir, provider_id=provider_id, mcp_command=mcp_command, mcp_args=mcp_args)
+
+
+@mrpify_app.command(name="openapi")
+def mrpify_openapi_cmd(
+    spec: str = typer.Option(..., "--spec", help="Path to OpenAPI spec (json/yaml)"),
+    out_dir: str = typer.Option("./mrp-openapi-bridge", "--out-dir", help="Output directory"),
+    provider_id: str = typer.Option("service:openapi/bridge", "--provider-id", help="Provider sender id"),
+    backend_base_url: str | None = typer.Option(None, "--backend-base-url", help="Override OpenAPI servers[0].url"),
+    capability_prefix: str | None = typer.Option(None, "--capability-prefix", help="Prefix for generated capabilities (e.g. svc_)"),
+    public_base_url: str | None = typer.Option(None, "--public-base-url", help="Deployed public base URL, e.g. https://api.example.com"),
+    publish_now: bool = typer.Option(False, "--publish", help="Run mrpd publish for each generated manifest URL (requires public HTTPS)"),
+    yes: bool = typer.Option(False, "--yes", help="Skip confirmation prompts"),
+    registry: str | None = typer.Option(None, "--registry", help="Registry base URL (default: https://www.moltrouter.dev)"),
+    poll_seconds: float = typer.Option(5.0, "--poll-seconds", min=1.0, max=60.0),
+) -> None:
+    """Guided flow: OpenAPI -> MRP bridge -> (optional) publish commands."""
+    mrpify_openapi(
+        spec=spec,
+        out_dir=out_dir,
+        provider_id=provider_id,
+        backend_base_url=backend_base_url,
+        capability_prefix=capability_prefix,
+        public_base_url=public_base_url,
+        do_publish=publish_now,
+        yes=yes,
+        registry=registry,
+        poll_seconds=poll_seconds,
+    )
+
+
+@mrpify_app.command(name="mcp")
+def mrpify_mcp_cmd(
+    tools_json: str = typer.Option(..., "--tools-json", help="Path to MCP tools list JSON"),
+    out_dir: str = typer.Option("./mrp-mcp-bridge", "--out-dir", help="Output directory"),
+    provider_id: str = typer.Option("service:mcp/bridge", "--provider-id", help="Provider sender id"),
+    mcp_command: str = typer.Option(..., "--mcp-command", help="MCP server command (stdio)"),
+    mcp_args: list[str] = typer.Option([], "--mcp-arg", help="MCP server argument (repeatable)"),
+    public_base_url: str | None = typer.Option(None, "--public-base-url", help="Deployed public base URL, e.g. https://api.example.com"),
+    publish_now: bool = typer.Option(False, "--publish", help="Run mrpd publish for each generated manifest URL (requires public HTTPS)"),
+    yes: bool = typer.Option(False, "--yes", help="Skip confirmation prompts"),
+    registry: str | None = typer.Option(None, "--registry", help="Registry base URL (default: https://www.moltrouter.dev)"),
+    poll_seconds: float = typer.Option(5.0, "--poll-seconds", min=1.0, max=60.0),
+) -> None:
+    """Guided flow: MCP -> MRP bridge -> (optional) publish commands."""
+    mrpify_mcp(
+        tools_json=tools_json,
+        out_dir=out_dir,
+        provider_id=provider_id,
+        mcp_command=mcp_command,
+        mcp_args=mcp_args,
+        public_base_url=public_base_url,
+        do_publish=publish_now,
+        yes=yes,
+        registry=registry,
+        poll_seconds=poll_seconds,
+    )
+
+
+if __name__ == "__main__":
+    app()

mrpd/commands/__init__.py

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

mrpd/commands/bridge_mcp.py

@@ -0,0 +1,189 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import typer
+
+
+def bridge_mcp(
+    tools_json: str,
+    out_dir: str,
+    provider_id: str,
+    mcp_command: str,
+    mcp_args: list[str],
+) -> None:
+    """Generate an MRP provider wrapper from an MCP tool list.
+
+    v0 behavior:
+    - one MRP capability per MCP tool name
+    - generates per-tool manifests served at /mrp/manifest/<tool>
+
+    NOTE: This is a scaffold only. You must implement the actual MCP execution
+    (stdio) inside the generated app.
+    """
+
+    tools = json.loads(Path(tools_json).read_text(encoding="utf-8"))
+    if not isinstance(tools, list) or not tools:
+        raise typer.Exit(code=2)
+
+    out = Path(out_dir).resolve()
+    out.mkdir(parents=True, exist_ok=True)
+    (out / "mrp_manifests").mkdir(exist_ok=True)
+
+    for t in tools:
+        name = t.get("name") if isinstance(t, dict) else None
+        if not name or not isinstance(name, str):
+            continue
+        route_id = f"route:mcp/{name}@0.1"
+        manifest = {
+            "capability_id": f"capability:mcp/{name}",
+            "capability": name,
+            "version": "0.1",
+            "tags": ["mrp", "mcp"],
+            "inputs": [{"type": "json"}],
+            "outputs": [{"type": "json"}],
+            "constraints": {"policy": []},
+            "proofs_required": [],
+            "endpoints": {"discover": "/mrp/discover", "execute": "/mrp/execute"},
+            "metadata": {
+                "mcp": {
+                    "tool": name,
+                    "route_id": route_id,
+                    "stdio": {"command": mcp_command, "args": mcp_args},
+                }
+            },
+        }
+        (out / "mrp_manifests" / f"{name}.json").write_text(json.dumps(manifest, indent=2), encoding="utf-8")
+
+    app_py = '''from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from fastapi import FastAPI
+
+APP_DIR = Path(__file__).resolve().parent
+MANIFEST_DIR = APP_DIR / "mrp_manifests"
+MCP_COMMAND = ''' + json.dumps(mcp_command) + '''
+MCP_ARGS = ''' + json.dumps(mcp_args) + '''
+
+app = FastAPI(title="MRP MCP Bridge")
+
+
+def _load_manifest(name: str) -> dict:
+    fp = MANIFEST_DIR / f"{name}.json"
+    return json.loads(fp.read_text(encoding="utf-8"))
+
+
+def _tool_from_route_id(route_id: str) -> str:
+    # route:mcp/<tool>@0.1
+    if not route_id.startswith("route:mcp/"):
+        raise ValueError("invalid route_id")
+    rest = route_id[len("route:mcp/"):]
+    tool = rest.split("@", 1)[0]
+    return tool
+
+
+@app.get("/.well-known/mrp.json")
+def well_known() -> dict:
+    caps = []
+    for fp in sorted(MANIFEST_DIR.glob("*.json")):
+        try:
+            m = json.loads(fp.read_text(encoding="utf-8"))
+            c = m.get("capability")
+            if isinstance(c, str):
+                caps.append(c)
+        except Exception:
+            continue
+
+    return {
+        "mrp_version": "0.1",
+        "id": "''' + provider_id + '''",
+        "name": "MRP MCP Bridge",
+        "manifest_url": "/mrp/manifest/" + (caps[0] if caps else ""),
+        "capabilities": caps,
+    }
+
+
+@app.get("/mrp/manifest/{capability}")
+def mrp_manifest(capability: str) -> dict:
+    return _load_manifest(capability)
+
+
+@app.post("/mrp/discover")
+def mrp_discover(envelope: dict) -> dict:
+    req_id = envelope.get("msg_id")
+    sender = (envelope.get("sender") or {}).get("id")
+    constraints = (envelope.get("payload") or {}).get("constraints") or {}
+    wanted = constraints.get("capability")
+
+    offers = []
+    for fp in sorted(MANIFEST_DIR.glob("*.json")):
+        m = json.loads(fp.read_text(encoding="utf-8"))
+        cap = m.get("capability")
+        meta = (m.get("metadata") or {}).get("mcp") or {}
+        route_id = meta.get("route_id")
+        if wanted and cap != wanted:
+            continue
+        offers.append({
+            "route_id": route_id,
+            "capability": cap,
+            "constraints": m.get("constraints") or {},
+            "cost": {"unit": "usd", "estimate": 0},
+            "latency_ms": 0,
+            "proofs": [],
+        })
+
+    return {
+        "mrp_version": "0.1",
+        "msg_id": str(__import__("uuid").uuid4()),
+        "msg_type": "OFFER",
+        "timestamp": __import__("datetime").datetime.utcnow().isoformat() + "Z",
+        "sender": {"id": "''' + provider_id + '''"},
+        "receiver": {"id": sender} if sender else None,
+        "in_reply_to": req_id,
+        "payload": {"offers": offers[:25]},
+    }
+
+
+@app.post("/mrp/execute")
+def mrp_execute(envelope: dict) -> dict:
+    # TODO: implement MCP execution using MCP_COMMAND + MCP_ARGS (stdio).
+    req_id = envelope.get("msg_id")
+    sender = (envelope.get("sender") or {}).get("id")
+
+    payload = envelope.get("payload") or {}
+    tool = _tool_from_route_id(payload.get("route_id"))
+
+    return {
+        "mrp_version": "0.1",
+        "msg_id": str(__import__("uuid").uuid4()),
+        "msg_type": "ERROR",
+        "timestamp": __import__("datetime").datetime.utcnow().isoformat() + "Z",
+        "sender": {"id": "''' + provider_id + '''"},
+        "receiver": {"id": sender} if sender else None,
+        "in_reply_to": req_id,
+        "payload": {
+            "code": "MRP_NOT_IMPLEMENTED",
+            "message": f"MCP execution not implemented for tool: {tool}",
+            "retryable": False,
+        },
+    }
+'''
+
+    (out / "app.py").write_text(app_py, encoding="utf-8")
+    (out / "README.md").write_text(
+        "# MRP MCP Bridge (scaffold)\n\n"
+        "Generated by `mrpd bridge mcp`.\n\n"
+        "This is a scaffold: you still need to implement the actual MCP connection\n"
+        "(stdio) in `app.py` /mrp/execute.\n\n"
+        "## Publish\n\n"
+        "After deploying, publish each manifest you want discoverable:\n\n"
+        "```bash\n"
+        "mrpd publish --manifest-url https://YOUR_DOMAIN/mrp/manifest/<tool>\n"
+        "```\n",
+        encoding="utf-8",
+    )
+
+    typer.echo(f"Generated MCP bridge scaffold in: {out}")