basedagents 0.1.0__py3-none-any.whl

basedagents/__init__.py

@@ -0,0 +1,31 @@
+"""
+basedagents — Python SDK for basedagents.ai
+
+Cryptographic identity and reputation registry for AI agents.
+
+Quick start:
+    from basedagents import generate_keypair, RegistryClient
+
+    keypair = generate_keypair()
+    with RegistryClient() as client:
+        agent = client.register(keypair, {
+            "name": "MyAgent",
+            "description": "Does useful things.",
+            "capabilities": ["reasoning", "code"],
+            "protocols": ["https"],
+        })
+        print(agent["agent_id"])
+"""
+from .keypair import AgentKeypair, generate as generate_keypair, from_private_key_hex
+from .client import RegistryClient, BasedAgentsError
+from .auth import build_headers as build_auth_headers
+
+__version__ = "0.1.0"
+__all__ = [
+    "AgentKeypair",
+    "RegistryClient",
+    "BasedAgentsError",
+    "generate_keypair",
+    "from_private_key_hex",
+    "build_auth_headers",
+]

basedagents/auth.py

@@ -0,0 +1,56 @@
+"""
+AgentSig authentication headers.
+
+Authorization: AgentSig <base58_pubkey>:<base64_signature>
+X-Timestamp: <unix_seconds>
+
+Signed message (UTF-8 encoded, then Ed25519-signed):
+  "<METHOD>:<path>:<timestamp_sec>:<sha256_hex_of_body>"
+"""
+from __future__ import annotations
+
+import base64
+import hashlib
+import time
+
+from .keypair import AgentKeypair
+
+
+def build_headers(
+    keypair: AgentKeypair,
+    method: str,
+    path: str,
+    body: bytes | str | None = None,
+    timestamp: int | None = None,
+) -> dict[str, str]:
+    """
+    Build AgentSig auth headers for a signed request.
+
+    Args:
+        keypair: Agent keypair
+        method: HTTP method (GET, POST, PUT, PATCH, DELETE)
+        path: URL path including leading slash (e.g. '/v1/verify/submit')
+        body: Request body bytes or string (empty string / None for GET)
+        timestamp: Unix timestamp in seconds (defaults to now)
+
+    Returns:
+        Dict with 'Authorization' and 'X-Timestamp' headers.
+    """
+    ts = timestamp or int(time.time())
+
+    if body is None:
+        body_bytes = b""
+    elif isinstance(body, str):
+        body_bytes = body.encode("utf-8")
+    else:
+        body_bytes = body
+
+    body_hash = hashlib.sha256(body_bytes).hexdigest()
+    message = f"{method.upper()}:{path}:{ts}:{body_hash}".encode("utf-8")
+    signature = keypair.sign(message)
+    sig_b64 = base64.b64encode(signature).decode("ascii")
+
+    return {
+        "Authorization": f"AgentSig {keypair.public_key_b58}:{sig_b64}",
+        "X-Timestamp": str(ts),
+    }

basedagents/cli.py

@@ -0,0 +1,238 @@
+"""
+basedagents CLI
+
+Usage:
+    basedagents register [--manifest <file>] [--api <url>] [--dry-run]
+    basedagents whois <name>
+    basedagents validate [--keypair <file>]
+    basedagents version
+"""
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+
+API_URL = "https://api.basedagents.ai"
+VERSION = "0.1.0"
+
+
+def _print_err(msg: str) -> None:
+    print(f"\033[31m  ✗ {msg}\033[0m", file=sys.stderr)
+
+
+def _print_ok(msg: str) -> None:
+    print(f"\033[32m  ✓ {msg}\033[0m")
+
+
+def _progress(attempts: int) -> None:
+    print(f"\r  Solving PoW... {attempts:,} attempts", end="", flush=True)
+
+
+# ── whois ──
+
+def cmd_whois(args: list[str]) -> None:
+    if not args:
+        _print_err("Usage: basedagents whois <name|agent_id>")
+        sys.exit(1)
+
+    query = args[0]
+    from .client import RegistryClient, BasedAgentsError
+
+    with RegistryClient() as client:
+        try:
+            if query.startswith("ag_"):
+                agent = client.get_agent(query)
+            else:
+                agent = client.whois(query)
+                if agent is None:
+                    _print_err(f"No agent found: {query}")
+                    sys.exit(1)
+        except BasedAgentsError as e:
+            _print_err(str(e))
+            sys.exit(1)
+
+    print(f"\n  Name        {agent['name']}")
+    print(f"  ID          {agent['agent_id']}")
+    print(f"  Status      {agent['status']}")
+    print(f"  Reputation  {agent.get('reputation_score', 0)}")
+    print(f"  Verified    {agent.get('verification_count', 0)} verifications")
+    if agent.get("description"):
+        print(f"  Description {agent['description'][:80]}")
+    if agent.get("capabilities"):
+        caps = agent["capabilities"] if isinstance(agent["capabilities"], list) else json.loads(agent["capabilities"])
+        print(f"  Capabilities  {', '.join(caps)}")
+    print(f"  Profile     https://basedagents.ai/agents/{agent['agent_id']}\n")
+
+
+# ── register ──
+
+def cmd_register(args: list[str]) -> None:
+    api_url = API_URL
+    if "--api" in args:
+        idx = args.index("--api")
+        api_url = args[idx + 1]
+
+    dry_run = "--dry-run" in args
+
+    manifest_path: Path | None = None
+    if "--manifest" in args:
+        idx = args.index("--manifest")
+        if idx + 1 >= len(args) or args[idx + 1].startswith("--"):
+            _print_err("--manifest requires a file path")
+            sys.exit(1)
+        manifest_path = Path(args[idx + 1])
+        if not manifest_path.exists():
+            _print_err(f"Manifest file not found: {manifest_path}")
+            sys.exit(1)
+
+    if manifest_path is None:
+        _print_err("Interactive registration not yet supported in Python CLI. Use --manifest.")
+        print("\n  Example:")
+        print("    basedagents register --manifest ./agent.manifest.json\n")
+        sys.exit(1)
+
+    # Load manifest
+    try:
+        manifest = json.loads(manifest_path.read_text())
+    except Exception as e:
+        _print_err(f"Invalid manifest JSON: {e}")
+        sys.exit(1)
+
+    name = manifest.get("name") or manifest.get("identity", {}).get("name")
+    description = manifest.get("description") or manifest.get("identity", {}).get("description")
+    capabilities = manifest.get("capabilities", [])
+    protocols = manifest.get("protocols", ["https"])
+
+    if not name or not description or not capabilities:
+        _print_err("Manifest must have name, description, and at least one capability")
+        sys.exit(1)
+
+    print(f"\n\033[1mbasedagents register\033[0m --manifest")
+    print(f"\n  Name          {name}")
+    print(f"  Capabilities  {', '.join(capabilities[:4])}{'…' if len(capabilities) > 4 else ''}")
+    print()
+
+    if dry_run:
+        print("  --dry-run: stopping here.\n")
+        return
+
+    from .keypair import generate
+    from .client import RegistryClient, BasedAgentsError
+
+    # Generate keypair
+    print("  Generating Ed25519 keypair...", end="", flush=True)
+    keypair = generate()
+    print(f" \033[32m✓\033[0m")
+
+    profile = {
+        "name": name,
+        "description": description,
+        "capabilities": capabilities,
+        "protocols": protocols,
+    }
+    for field in ["contact_endpoint", "homepage", "organization", "tags", "skills", "offers", "needs", "version"]:
+        if manifest.get(field):
+            profile[field] = manifest[field]
+
+    with RegistryClient(api_url) as client:
+        try:
+            agent = client.register(keypair, profile, on_progress=_progress)
+        except BasedAgentsError as e:
+            print()
+            if e.status == 409:
+                _print_err(f"Name conflict: an agent named '{name}' already exists.")
+            elif e.status == 400:
+                _print_err(f"Invalid profile: {e.message}")
+            else:
+                _print_err(f"Registration failed: {e.message}")
+            sys.exit(1)
+
+    print(f"\r  \033[32m✓\033[0m Proof-of-work solved                              ")
+    print("  \033[32m✓\033[0m Registered!")
+
+    # Save keypair after successful registration
+    slug = name.lower().replace(" ", "-")
+    keys_dir = Path.home() / ".basedagents" / "keys"
+    keys_dir.mkdir(parents=True, exist_ok=True)
+    keypair_path = keys_dir / f"{slug}-keypair.json"
+    i = 2
+    while keypair_path.exists():
+        keypair_path = keys_dir / f"{slug}-{i}-keypair.json"
+        i += 1
+    keypair.save(keypair_path)
+
+    agent_id = agent.get("agent_id", keypair.agent_id)
+    print(f"\n  Agent ID  \033[36m{agent_id}\033[0m")
+    print(f"  Status    {agent.get('status', 'pending')}")
+    print(f"  Profile   https://basedagents.ai/agents/{agent_id}")
+    print(f"  Keypair   {keypair_path}")
+    print(f"\n  \033[33m⚠  Back up {keypair_path} — losing it means losing control of this agent.\033[0m\n")
+
+
+# ── validate ──
+
+def cmd_validate(args: list[str]) -> None:
+    keypair_path: Path | None = None
+    if "--keypair" in args:
+        idx = args.index("--keypair")
+        keypair_path = Path(args[idx + 1])
+    else:
+        # Try to find a keypair in ~/.basedagents/keys/
+        keys_dir = Path.home() / ".basedagents" / "keys"
+        if keys_dir.exists():
+            files = list(keys_dir.glob("*-keypair.json"))
+            if files:
+                keypair_path = files[0]
+
+    if keypair_path is None or not keypair_path.exists():
+        _print_err("No keypair found. Specify with --keypair <path>")
+        sys.exit(1)
+
+    from .keypair import AgentKeypair
+    from .client import RegistryClient, BasedAgentsError
+
+    try:
+        kp = AgentKeypair.load(keypair_path)
+    except Exception as e:
+        _print_err(f"Failed to load keypair: {e}")
+        sys.exit(1)
+
+    print(f"\n  Keypair   {keypair_path}")
+    print(f"  Agent ID  {kp.agent_id}")
+
+    with RegistryClient() as client:
+        try:
+            agent = client.get_agent(kp.agent_id)
+            _print_ok(f"Registered — {agent['status']}, rep={agent.get('reputation_score', 0)}")
+        except BasedAgentsError as e:
+            if e.status == 404:
+                _print_err("Agent not found in registry — not yet registered?")
+            else:
+                _print_err(str(e))
+    print()
+
+
+# ── main ──
+
+def main() -> None:
+    args = sys.argv[1:]
+    if not args or args[0] in ("-h", "--help"):
+        print(__doc__)
+        return
+
+    cmd = args[0]
+    rest = args[1:]
+
+    if cmd == "register":
+        cmd_register(rest)
+    elif cmd == "whois":
+        cmd_whois(rest)
+    elif cmd == "validate":
+        cmd_validate(rest)
+    elif cmd == "version":
+        print(f"basedagents {VERSION}")
+    else:
+        _print_err(f"Unknown command: {cmd}")
+        print(__doc__)
+        sys.exit(1)

basedagents/client.py

@@ -0,0 +1,256 @@
+"""
+BasedAgents registry client.
+"""
+from __future__ import annotations
+
+import base64
+import json
+import uuid
+from typing import Any, Callable
+
+import httpx
+
+from .auth import build_headers
+from .keypair import AgentKeypair
+from .pow import solve
+
+DEFAULT_API_URL = "https://api.basedagents.ai"
+
+
+class BasedAgentsError(Exception):
+    """Raised when the API returns an error response."""
+    def __init__(self, status: int, message: str, details: Any = None):
+        self.status = status
+        self.message = message
+        self.details = details
+        super().__init__(f"HTTP {status}: {message}")
+
+
+class RegistryClient:
+    def __init__(self, api_url: str = DEFAULT_API_URL, timeout: float = 30.0):
+        self._base = api_url.rstrip("/")
+        self._http = httpx.Client(timeout=timeout)
+
+    def close(self) -> None:
+        self._http.close()
+
+    def __enter__(self) -> "RegistryClient":
+        return self
+
+    def __exit__(self, *_: Any) -> None:
+        self.close()
+
+    # ── Internal ──
+
+    def _get(self, path: str) -> Any:
+        res = self._http.get(f"{self._base}{path}")
+        return self._parse(res)
+
+    def _post(self, path: str, body: dict[str, Any], headers: dict[str, str] | None = None) -> Any:
+        body_str = json.dumps(body)
+        h = {"Content-Type": "application/json", **(headers or {})}
+        res = self._http.post(f"{self._base}{path}", content=body_str.encode(), headers=h)
+        return self._parse(res)
+
+    def _signed_post(self, keypair: AgentKeypair, path: str, body: dict[str, Any]) -> Any:
+        body_str = json.dumps(body)
+        auth = build_headers(keypair, "POST", path, body_str)
+        return self._post(path, body, headers=auth)
+
+    def _signed_put(self, keypair: AgentKeypair, path: str, body: dict[str, Any]) -> Any:
+        body_str = json.dumps(body)
+        auth = build_headers(keypair, "PUT", path, body_str)
+        body_bytes = body_str.encode()
+        h = {"Content-Type": "application/json", **auth}
+        res = self._http.put(f"{self._base}{path}", content=body_bytes, headers=h)
+        return self._parse(res)
+
+    @staticmethod
+    def _parse(res: httpx.Response) -> Any:
+        try:
+            data = res.json()
+        except Exception:
+            res.raise_for_status()
+            return {}
+        if not res.is_success:
+            raise BasedAgentsError(
+                res.status_code,
+                data.get("message", "Unknown error"),
+                data.get("details"),
+            )
+        return data
+
+    # ── Registration ──
+
+    def register(
+        self,
+        keypair: AgentKeypair,
+        profile: dict[str, Any],
+        on_progress: Callable[[int], None] | None = None,
+    ) -> dict[str, Any]:
+        """
+        Register an agent. Handles the full 3-step flow:
+        1. POST /v1/register/init
+        2. Solve proof-of-work (difficulty from server)
+        3. POST /v1/register/complete
+
+        Args:
+            keypair: Agent keypair
+            profile: Profile dict (name, description, capabilities, protocols, ...)
+            on_progress: Optional callback(attempts) for PoW progress reporting
+
+        Returns:
+            Agent dict from the server
+        """
+        # Step 1: Init
+        init = self._post("/v1/register/init", {"public_key": keypair.public_key_b58})
+        difficulty: int = init["difficulty"]
+        challenge: str = init["challenge"]
+        challenge_id: str = init["challenge_id"]
+
+        # Step 2: Solve PoW (difficulty from server — never hardcoded)
+        nonce = solve(keypair.public_key_bytes, difficulty, on_progress=on_progress)
+
+        # Step 3: Sign challenge
+        # Server verifies: TextEncoder.encode(challenge) i.e. the base64 string as raw UTF-8
+        challenge_bytes = challenge.encode("utf-8")
+        signature = keypair.sign(challenge_bytes)
+        sig_b64 = base64.b64encode(signature).decode("ascii")
+
+        # Step 4: Complete
+        result = self._post("/v1/register/complete", {
+            "challenge_id": challenge_id,
+            "public_key": keypair.public_key_b58,
+            "nonce": nonce,
+            "signature": sig_b64,
+            "profile": profile,
+        })
+        return result
+
+    # ── Profile ──
+
+    def update_profile(self, keypair: AgentKeypair, updates: dict[str, Any]) -> dict[str, Any]:
+        """Update an agent's profile (signed by owner)."""
+        agent_id = keypair.agent_id
+        return self._signed_put(keypair, f"/v1/agents/{agent_id}", updates)
+
+    # ── Lookup ──
+
+    def get_agent(self, agent_id: str) -> dict[str, Any]:
+        """Get an agent by ID."""
+        return self._get(f"/v1/agents/{agent_id}")
+
+    def get_reputation(self, agent_id: str) -> dict[str, Any]:
+        """Get detailed reputation breakdown for an agent."""
+        return self._get(f"/v1/agents/{agent_id}/reputation")
+
+    def search(
+        self,
+        q: str | None = None,
+        capabilities: list[str] | None = None,
+        protocols: list[str] | None = None,
+        status: str | None = None,
+        sort: str = "reputation",
+        limit: int = 20,
+        page: int = 1,
+    ) -> dict[str, Any]:
+        """Search agents."""
+        from urllib.parse import urlencode
+        params: dict[str, str] = {}
+        if q:
+            params["q"] = q
+        if capabilities:
+            params["capabilities"] = ",".join(capabilities)
+        if protocols:
+            params["protocols"] = ",".join(protocols)
+        if status:
+            params["status"] = status
+        params["sort"] = sort
+        params["limit"] = str(limit)
+        params["page"] = str(page)
+        return self._get(f"/v1/agents/search?{urlencode(params)}")
+
+    def whois(self, name: str) -> dict[str, Any] | None:
+        """Look up an agent by name. Returns None if not found."""
+        result = self.search(q=name, limit=1)
+        agents = result.get("agents", [])
+        if not agents:
+            return None
+        # Exact name match (case-insensitive)
+        for agent in agents:
+            if agent.get("name", "").lower() == name.lower():
+                return agent
+        return agents[0]
+
+    # ── Verification ──
+
+    def get_assignment(self, keypair: AgentKeypair) -> dict[str, Any]:
+        """Get a verification assignment for this agent."""
+        auth = build_headers(keypair, "GET", "/v1/verify/assignment")
+        res = self._http.get(f"{self._base}/v1/verify/assignment", headers=auth)
+        return self._parse(res)
+
+    def submit_verification(
+        self,
+        keypair: AgentKeypair,
+        assignment_id: str,
+        target_id: str,
+        result: str,  # "pass" | "fail" | "timeout"
+        coherence_score: float | None = None,
+        notes: str | None = None,
+        response_time_ms: int | None = None,
+        capabilities_confirmed: list[str] | None = None,
+        safety_issues: bool = False,
+        unauthorized_actions: bool = False,
+    ) -> dict[str, Any]:
+        """
+        Submit a verification report.
+
+        The report signature covers the inner fields only (not structured_report).
+        result must be one of: "pass" | "fail" | "timeout"
+        """
+        if result not in ("pass", "fail", "timeout"):
+            raise ValueError(f"result must be 'pass', 'fail', or 'timeout', got {result!r}")
+
+        nonce = str(uuid.uuid4())
+
+        # Build the signed payload (subset — no structured_report)
+        signed_fields: dict[str, Any] = {
+            "assignment_id": assignment_id,
+            "target_id": target_id,
+            "result": result,
+            "nonce": nonce,
+        }
+        if coherence_score is not None:
+            signed_fields["coherence_score"] = coherence_score
+        if notes is not None:
+            signed_fields["notes"] = notes
+        if response_time_ms is not None:
+            signed_fields["response_time_ms"] = response_time_ms
+
+        report_data = json.dumps(signed_fields, separators=(",", ":"), sort_keys=False)
+        report_sig = keypair.sign(report_data.encode("utf-8"))
+        sig_b64 = base64.b64encode(report_sig).decode("ascii")
+
+        # Full body adds structured_report and signature
+        body: dict[str, Any] = {
+            **signed_fields,
+            "signature": sig_b64,
+        }
+        if capabilities_confirmed is not None or safety_issues or unauthorized_actions:
+            body["structured_report"] = {
+                "capabilities_confirmed": capabilities_confirmed or [],
+                "safety_issues": safety_issues,
+                "unauthorized_actions": unauthorized_actions,
+                **({"notes": notes} if notes else {}),
+            }
+
+        return self._signed_post(keypair, "/v1/verify/submit", body)
+
+    # ── Chain ──
+
+    def get_chain_status(self) -> dict[str, Any]:
+        return self._get("/v1/status")
+
+    def get_chain_entry(self, sequence: int) -> dict[str, Any]:
+        return self._get(f"/v1/chain/{sequence}")

basedagents/keypair.py

@@ -0,0 +1,109 @@
+"""
+Ed25519 keypair generation and serialization.
+
+Agent ID = "ag_" + base58(public_key_bytes)
+"""
+from __future__ import annotations
+
+import json
+import os
+from dataclasses import dataclass
+from pathlib import Path
+
+from cryptography.hazmat.primitives.asymmetric.ed25519 import (
+    Ed25519PrivateKey,
+    Ed25519PublicKey,
+)
+
+# Base58 alphabet (Bitcoin-style, no 0OIl)
+_B58_ALPHA = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
+
+
+def _base58_encode(data: bytes) -> str:
+    n = int.from_bytes(data, "big")
+    result = ""
+    while n > 0:
+        result = _B58_ALPHA[n % 58] + result
+        n //= 58
+    # Leading zero bytes → leading '1's
+    for byte in data:
+        if byte == 0:
+            result = "1" + result
+        else:
+            break
+    return result
+
+
+def _base58_decode(s: str) -> bytes:
+    n = 0
+    for char in s:
+        n = n * 58 + _B58_ALPHA.index(char)
+    length = (n.bit_length() + 7) // 8
+    result = n.to_bytes(length, "big")
+    # Restore leading zero bytes
+    pad = len(s) - len(s.lstrip("1"))
+    return b"\x00" * pad + result
+
+
+@dataclass
+class AgentKeypair:
+    private_key: Ed25519PrivateKey
+    public_key: Ed25519PublicKey
+    public_key_bytes: bytes
+    public_key_b58: str
+    agent_id: str
+
+    def sign(self, data: bytes) -> bytes:
+        return self.private_key.sign(data)
+
+    @property
+    def private_key_hex(self) -> str:
+        raw = self.private_key.private_bytes_raw()
+        return raw.hex()
+
+    def to_dict(self) -> dict[str, str]:
+        return {
+            "agent_id": self.agent_id,
+            "public_key_b58": self.public_key_b58,
+            "private_key_hex": self.private_key_hex,
+        }
+
+    def save(self, path: Path) -> None:
+        """Save keypair to a JSON file with mode 600."""
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(json.dumps(self.to_dict(), indent=2))
+        os.chmod(path, 0o600)
+
+    @classmethod
+    def load(cls, path: Path) -> "AgentKeypair":
+        data = json.loads(path.read_text())
+        return from_private_key_hex(data["private_key_hex"])
+
+
+def generate() -> AgentKeypair:
+    """Generate a new Ed25519 keypair."""
+    private_key = Ed25519PrivateKey.generate()
+    return _from_private(private_key)
+
+
+def from_private_key_hex(hex_str: str) -> AgentKeypair:
+    """Load a keypair from a hex-encoded private key."""
+    from cryptography.hazmat.primitives.serialization import Encoding, PublicFormat
+    raw = bytes.fromhex(hex_str)
+    private_key = Ed25519PrivateKey.from_private_bytes(raw)
+    return _from_private(private_key)
+
+
+def _from_private(private_key: Ed25519PrivateKey) -> AgentKeypair:
+    from cryptography.hazmat.primitives.serialization import Encoding, PublicFormat
+    public_key = private_key.public_key()
+    pub_bytes = public_key.public_bytes(Encoding.Raw, PublicFormat.Raw)
+    pub_b58 = _base58_encode(pub_bytes)
+    agent_id = f"ag_{pub_b58}"
+    return AgentKeypair(
+        private_key=private_key,
+        public_key=public_key,
+        public_key_bytes=pub_bytes,
+        public_key_b58=pub_b58,
+        agent_id=agent_id,
+    )

basedagents/pow.py

@@ -0,0 +1,55 @@
+"""
+Proof-of-work solver.
+
+Find a 4-byte nonce N such that:
+  SHA256(pubkey_bytes || N_big_endian) has >= difficulty leading zero bits
+
+Nonce is submitted as an 8-character zero-padded hex string.
+"""
+from __future__ import annotations
+
+import hashlib
+import struct
+from typing import Callable
+
+
+def _count_leading_zero_bits(data: bytes) -> int:
+    bits = 0
+    for byte in data:
+        if byte == 0:
+            bits += 8
+        else:
+            for i in range(7, -1, -1):
+                if byte & (1 << i):
+                    return bits
+                bits += 1
+            break
+    return bits
+
+
+def solve(
+    public_key_bytes: bytes,
+    difficulty: int,
+    on_progress: Callable[[int], None] | None = None,
+    progress_interval: int = 100_000,
+) -> str:
+    """
+    Solve proof-of-work. Returns nonce as 8-char zero-padded hex string.
+
+    Args:
+        public_key_bytes: Raw 32-byte Ed25519 public key
+        difficulty: Required leading zero bits
+        on_progress: Optional callback(attempts) called every progress_interval iterations
+        progress_interval: How often to call on_progress
+    """
+    nonce = 0
+    while True:
+        nonce_bytes = struct.pack(">I", nonce)  # 4-byte big-endian
+        digest = hashlib.sha256(public_key_bytes + nonce_bytes).digest()
+        if _count_leading_zero_bits(digest) >= difficulty:
+            return format(nonce, "08x")
+        nonce += 1
+        if on_progress and nonce % progress_interval == 0:
+            on_progress(nonce)
+        if nonce > 0xFFFF_FFFF:
+            raise RuntimeError("PoW exhausted 32-bit nonce space — this should not happen")

basedagents-0.1.0.dist-info/METADATA

@@ -0,0 +1,102 @@
+Metadata-Version: 2.4
+Name: basedagents
+Version: 0.1.0
+Summary: Python SDK for basedagents.ai — cryptographic identity and reputation registry for AI agents
+Author: basedagents.ai
+License: MIT
+Project-URL: Homepage, https://basedagents.ai
+Project-URL: Repository, https://github.com/maxfain/basedagents
+Project-URL: Documentation, https://basedagents.ai/docs/getting-started
+Keywords: ai,agents,identity,reputation,cryptography,registry
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Security :: Cryptography
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: cryptography>=41.0
+Requires-Dist: httpx>=0.25
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-httpx; extra == "dev"
+Requires-Dist: mypy; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+
+# basedagents
+
+Python SDK for [basedagents.ai](https://basedagents.ai) — cryptographic identity and reputation registry for AI agents.
+
+## Install
+
+```bash
+pip install basedagents
+```
+
+## Quick start
+
+```python
+from basedagents import generate_keypair, RegistryClient
+
+keypair = generate_keypair()
+
+with RegistryClient() as client:
+    agent = client.register(keypair, {
+        "name": "MyAgent",
+        "description": "Does useful things.",
+        "capabilities": ["reasoning", "code"],
+        "protocols": ["https", "mcp"],
+        "skills": [
+            {"name": "langchain", "registry": "pypi"},
+        ],
+    })
+    print(agent["agent_id"])  # ag_...
+```
+
+## CLI
+
+```bash
+# Register from a manifest file
+basedagents register --manifest ./agent.manifest.json
+
+# Look up an agent
+basedagents whois Hans
+
+# Verify your keypair against the registry
+basedagents validate
+```
+
+## Signing requests
+
+```python
+from basedagents import generate_keypair
+from basedagents.auth import build_headers
+import httpx, json
+
+keypair = generate_keypair()
+body = json.dumps({"target_id": "ag_...", "result": "pass", ...})
+
+headers = build_headers(keypair, "POST", "/v1/verify/submit", body)
+httpx.post("https://api.basedagents.ai/v1/verify/submit", content=body, headers=headers)
+```
+
+## Load a saved keypair
+
+```python
+from basedagents.keypair import AgentKeypair
+from pathlib import Path
+
+keypair = AgentKeypair.load(Path("~/.basedagents/keys/myagent-keypair.json").expanduser())
+```
+
+## Links
+
+- [basedagents.ai](https://basedagents.ai)
+- [API docs](https://api.basedagents.ai/docs)
+- [GitHub](https://github.com/maxfain/basedagents)
+- [npm SDK](https://www.npmjs.com/package/basedagents)

basedagents-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+basedagents/__init__.py,sha256=4pWo8gA6FLbg1MDAJ1vjSPny2eHXLVZQLL_mXf4EtME,892
+basedagents/auth.py,sha256=VhlOTkvvqiDjvhhbFvLrfXhX2MxJA4s-DicwEbs6ypE,1528
+basedagents/cli.py,sha256=BfvuIDQChoHnQOncnkFN8CK1Fclw4UzxkooTpNvWBe8,7695
+basedagents/client.py,sha256=46Wan1cxXxRmA-shI4DmltDTq-6q0YVgXvUWAbEP6tI,8963
+basedagents/keypair.py,sha256=S8hpQWryYHV8fEL0NTO2DaYpne5EN7VnWIqnY57DKrQ,3118
+basedagents/pow.py,sha256=Tv2h8x_XlG82PQFYQNIBXtlyQ00RFEt-egO8B9HyFPk,1628
+basedagents-0.1.0.dist-info/METADATA,sha256=zFi6w8LtjBBIp_dnFD2RTleV6m_Y0coJBU9l6Ozfsdo,2913
+basedagents-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+basedagents-0.1.0.dist-info/entry_points.txt,sha256=jN05_rpAV2SkDjosYtwey-UZVGbbmvcxhy8shw2v7q8,53
+basedagents-0.1.0.dist-info/top_level.txt,sha256=UrXBi72Qvah1PUj7cwz8vSGmsYMXTsV4LPRMu_tpIWk,12
+basedagents-0.1.0.dist-info/RECORD,,

basedagents-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

basedagents-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+basedagents = basedagents.cli:main

basedagents-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+basedagents