basedagents 0.2.0__tar.gz → 0.3.0__tar.gz

{basedagents-0.2.0 → basedagents-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: basedagents
-Version: 0.2.0
+Version: 0.3.0
 Summary: Python SDK for basedagents.ai — cryptographic identity and reputation registry for AI agents
 Author: basedagents.ai
 License: MIT

{basedagents-0.2.0 → basedagents-0.3.0}/basedagents/__init__.py

@@ -33,10 +33,15 @@ from .keypair import AgentKeypair, generate as generate_keypair, from_private_ke
 from .client import RegistryClient, BasedAgentsError
 from .auth import build_headers as build_auth_headers
 from .easy import register_or_load
+from .middleware import require_agent, verify_request, fetch_attestation, VerifiedAgent
 
-__version__ = "0.2.0"
+__version__ = "0.3.0"
 __all__ = [
     "register_or_load",
+    "require_agent",
+    "verify_request",
+    "fetch_attestation",
+    "VerifiedAgent",
     "AgentKeypair",
     "RegistryClient",
     "BasedAgentsError",

basedagents-0.3.0/basedagents/integrations/__init__.py

@@ -0,0 +1,8 @@
+"""
+Framework integrations for basedagents.
+
+Supported:
+- LangChain: register_langchain_agent
+- CrewAI: register_crewai_agent
+- AutoGen: register_autogen_agent
+"""

basedagents-0.3.0/basedagents/integrations/autogen.py

@@ -0,0 +1,224 @@
+"""
+AutoGen integration for basedagents.
+
+Introspects an AutoGen ConversableAgent, AssistantAgent, or GroupChat and
+auto-populates capabilities and skills for registration.
+
+Usage:
+    from autogen import AssistantAgent, GroupChat
+    from basedagents.integrations.autogen import register_autogen_agent
+
+    # Single agent
+    agent_id = register_autogen_agent(
+        assistant,
+        name="my-autogen-assistant",
+        description="Writes and executes Python code.",
+    )
+
+    # GroupChat (multi-agent)
+    agent_id = register_autogen_agent(
+        groupchat,
+        name="my-autogen-group",
+        description="Research + coding multi-agent system.",
+    )
+"""
+from __future__ import annotations
+
+from typing import Any
+
+
+# ── Known AutoGen agent class names → capabilities ────────────────────────────
+_AGENT_CLASS_CAPABILITIES: dict[str, list[str]] = {
+    "AssistantAgent": ["reasoning", "code"],
+    "UserProxyAgent": ["code"],             # executes code by default
+    "GPTAssistantAgent": ["reasoning", "code"],
+    "RetrieveAssistantAgent": ["reasoning", "knowledge"],
+    "RetrieveUserProxyAgent": ["knowledge"],
+    "MathUserProxyAgent": ["reasoning"],
+    "TeachableAgent": ["reasoning", "knowledge"],
+    "CompressibleAgent": ["reasoning"],
+    "TransformMessages": ["reasoning"],
+    "WebSurferAgent": ["web-search", "web-scraping"],
+    "MultimodalConversableAgent": ["vision", "reasoning"],
+}
+
+# ── Code execution detection ──────────────────────────────────────────────────
+_CODE_EXEC_CLASSES = {"UserProxyAgent", "GPTAssistantAgent"}
+
+
+def _collect_agents(agent_or_group: Any) -> list[Any]:
+    """Extract agents from GroupChat, GroupChatManager, or return single agent."""
+    # GroupChat has .agents
+    agents = getattr(agent_or_group, "agents", None)
+    if agents:
+        return list(agents)
+    # GroupChatManager has .groupchat.agents
+    gc = getattr(agent_or_group, "groupchat", None)
+    if gc:
+        return list(getattr(gc, "agents", []) or [])
+    # Single agent
+    return [agent_or_group]
+
+
+def _is_multi_agent(agent_or_group: Any) -> bool:
+    return len(_collect_agents(agent_or_group)) > 1
+
+
+def _agent_executes_code(agent: Any) -> bool:
+    """Check if an agent is configured to execute code."""
+    cls = type(agent).__name__
+    if cls in _CODE_EXEC_CLASSES:
+        return True
+    # human_input_mode="NEVER" + code_execution_config set = code executor
+    code_cfg = getattr(agent, "code_execution_config", None)
+    if code_cfg and code_cfg is not False:
+        return True
+    return False
+
+
+def _detect_llm_skill(agent: Any) -> str | None:
+    """Try to detect LLM provider package from llm_config."""
+    llm_config = getattr(agent, "llm_config", None) or {}
+    if not isinstance(llm_config, dict):
+        return None
+    model = llm_config.get("model", "") or ""
+    config_list = llm_config.get("config_list", [{}])
+    if config_list:
+        model = model or config_list[0].get("model", "")
+    model = model.lower()
+    if "gpt" in model or "o1" in model or "o3" in model:
+        return "pyautogen"
+    if "claude" in model:
+        return "pyautogen"
+    if "gemini" in model:
+        return "pyautogen"
+    return "pyautogen"  # always include base pyautogen
+
+
+def extract_profile(
+    agent_or_group: Any,
+    extra_capabilities: list[str] | None = None,
+    extra_skills: list[dict[str, str]] | None = None,
+) -> dict[str, Any]:
+    """
+    Introspect an AutoGen agent or GroupChat and return a partial profile dict
+    with auto-detected capabilities and skills.
+    """
+    agents = _collect_agents(agent_or_group)
+    capabilities: set[str] = set(extra_capabilities or [])
+    skills_seen: set[str] = set()
+    skills: list[dict[str, str]] = list(extra_skills or [])
+
+    # Base skill
+    skills.append({"name": "pyautogen", "registry": "pypi"})
+    skills_seen.add("pyautogen")
+
+    if _is_multi_agent(agent_or_group):
+        capabilities.add("multi-agent")
+
+    for agent in agents:
+        cls_name = type(agent).__name__
+
+        for cap in _AGENT_CLASS_CAPABILITIES.get(cls_name, []):
+            capabilities.add(cap)
+
+        if _agent_executes_code(agent):
+            capabilities.add("code")
+
+        # Detect function/tool calling
+        fn_map = getattr(agent, "function_map", None) or {}
+        if fn_map:
+            capabilities.add("tool-use")
+
+        # Detect retrieval augmentation
+        retrieve_config = getattr(agent, "retrieve_config", None)
+        if retrieve_config:
+            capabilities.add("knowledge")
+
+        # Extra skill from LLM config
+        pkg = _detect_llm_skill(agent)
+        if pkg and pkg not in skills_seen:
+            skills.append({"name": pkg, "registry": "pypi"})
+            skills_seen.add(pkg)
+
+    # Fallback capability
+    if not capabilities:
+        capabilities.add("reasoning")
+
+    return {
+        "capabilities": sorted(capabilities),
+        "protocols": ["https"],
+        "skills": skills,
+    }
+
+
+def register_autogen_agent(
+    agent_or_group: Any,
+    name: str,
+    description: str = "",
+    contact_endpoint: str | None = None,
+    organization: str | None = None,
+    version: str | None = None,
+    tags: list[str] | None = None,
+    extra_capabilities: list[str] | None = None,
+    extra_skills: list[dict[str, str]] | None = None,
+    keypair_path: str | None = None,
+    api_url: str | None = None,
+    verbose: bool = True,
+) -> str:
+    """
+    Register an AutoGen agent or GroupChat with basedagents.ai.
+
+    Introspects the agent to auto-detect capabilities and skills.
+    Idempotent — safe to call on every startup.
+
+    Args:
+        agent_or_group: AutoGen ConversableAgent, AssistantAgent, UserProxyAgent,
+                        GroupChat, or GroupChatManager
+        name: Unique agent name (globally unique on registry)
+        description: What this agent/group does
+        contact_endpoint: URL where the agent can be reached for verification
+        organization: Optional org name
+        version: Optional version string
+        tags: Optional extra tags
+        extra_capabilities: Additional capabilities beyond auto-detected ones
+        extra_skills: Additional skills beyond auto-detected ones
+        keypair_path: Override keypair file location
+        api_url: Override API URL (defaults to BASEDAGENTS_API env or prod)
+        verbose: Print progress (default True)
+
+    Returns:
+        agent_id string
+
+    Example:
+        import autogen
+        from basedagents.integrations.autogen import register_autogen_agent
+
+        assistant = autogen.AssistantAgent("assistant", llm_config={"model": "gpt-4o"})
+        user_proxy = autogen.UserProxyAgent("user_proxy", code_execution_config={"work_dir": "."})
+
+        agent_id = register_autogen_agent(
+            assistant,
+            name="my-autogen-assistant",
+            description="Writes and debugs Python code via GPT-4o.",
+        )
+    """
+    from ..easy import register_or_load
+
+    profile = extract_profile(agent_or_group, extra_capabilities, extra_skills)
+    merged_tags = list(set(["autogen"] + (tags or [])))
+
+    return register_or_load(
+        name=name,
+        description=description,
+        capabilities=profile["capabilities"],
+        protocols=profile["protocols"],
+        skills=profile["skills"],
+        contact_endpoint=contact_endpoint,
+        organization=organization,
+        version=version,
+        tags=merged_tags,
+        keypair_path=keypair_path,
+        api_url=api_url,
+        verbose=verbose,
+    )

basedagents-0.3.0/basedagents/integrations/crewai.py

@@ -0,0 +1,251 @@
+"""
+CrewAI integration for basedagents.
+
+Introspects a CrewAI Crew or Agent and auto-populates capabilities and skills
+for registration.
+
+Usage:
+    from crewai import Crew, Agent
+    from basedagents.integrations.crewai import register_crewai_agent
+
+    # Register from a Crew (uses all agents' tools)
+    agent_id = register_crewai_agent(
+        crew,
+        name="my-research-crew",
+        description="Multi-agent crew for research and analysis.",
+    )
+
+    # Or register a single CrewAI Agent
+    agent_id = register_crewai_agent(
+        agent,
+        name="my-researcher",
+        description="Searches and summarises the web.",
+    )
+"""
+from __future__ import annotations
+
+from typing import Any
+
+
+# ── Tool name → capabilities mapping ─────────────────────────────────────────
+_TOOL_TO_CAPABILITIES: dict[str, list[str]] = {
+    # Search
+    "SerperDevTool": ["web-search"],
+    "TavilySearchTool": ["web-search"],
+    "EXASearchTool": ["web-search"],
+    "BraveSearchTool": ["web-search"],
+    "DuckDuckGoSearchTool": ["web-search"],
+    "GoogleSearchTool": ["web-search"],
+    "ScrapeWebsiteTool": ["web-scraping"],
+    "SeleniumScrapingTool": ["web-scraping"],
+    "ScrapeElementFromWebsiteTool": ["web-scraping"],
+    "WebsiteSearchTool": ["web-search", "web-scraping"],
+    # Code
+    "CodeDocsSearchTool": ["code", "knowledge"],
+    "CodeInterpreterTool": ["code"],
+    "GithubSearchTool": ["code", "web-search"],
+    # Files
+    "FileReadTool": ["file-access"],
+    "FileWriterTool": ["file-access"],
+    "DirectoryReadTool": ["file-access"],
+    "DirectorySearchTool": ["file-access"],
+    "PDFSearchTool": ["file-access", "knowledge"],
+    "DOCXSearchTool": ["file-access", "knowledge"],
+    "CSVSearchTool": ["file-access", "data-analysis"],
+    "JSONSearchTool": ["file-access"],
+    "TXTSearchTool": ["file-access"],
+    "XMLSearchTool": ["file-access"],
+    "SpreadsheetSearchTool": ["file-access", "data-analysis"],
+    # Data
+    "PGSearchTool": ["data-analysis", "sql"],
+    "MySQLSearchTool": ["data-analysis", "sql"],
+    "NL2SQLTool": ["data-analysis", "sql"],
+    # Knowledge / RAG
+    "RagTool": ["knowledge"],
+    "YoutubeVideoSearchTool": ["knowledge"],
+    "YoutubeChannelSearchTool": ["knowledge"],
+    "MDXSearchTool": ["knowledge"],
+    # Comms
+    "BrowserbaseTool": ["web-scraping"],
+    "MultiOnTool": ["web-scraping"],
+    # Vision
+    "VisionTool": ["vision"],
+}
+
+# ── Tool name → PyPI package ──────────────────────────────────────────────────
+_TOOL_TO_PYPI: dict[str, str] = {
+    "SerperDevTool": "crewai-tools",
+    "TavilySearchTool": "crewai-tools",
+    "EXASearchTool": "crewai-tools",
+    "BraveSearchTool": "crewai-tools",
+    "DuckDuckGoSearchTool": "crewai-tools",
+    "ScrapeWebsiteTool": "crewai-tools",
+    "SeleniumScrapingTool": "crewai-tools",
+    "WebsiteSearchTool": "crewai-tools",
+    "CodeDocsSearchTool": "crewai-tools",
+    "CodeInterpreterTool": "crewai-tools",
+    "GithubSearchTool": "crewai-tools",
+    "FileReadTool": "crewai-tools",
+    "FileWriterTool": "crewai-tools",
+    "DirectoryReadTool": "crewai-tools",
+    "PDFSearchTool": "crewai-tools",
+    "DOCXSearchTool": "crewai-tools",
+    "CSVSearchTool": "crewai-tools",
+    "PGSearchTool": "crewai-tools",
+    "NL2SQLTool": "crewai-tools",
+    "RagTool": "crewai-tools",
+    "YoutubeVideoSearchTool": "crewai-tools",
+    "VisionTool": "crewai-tools",
+}
+
+
+def _collect_tools(crew_or_agent: Any) -> list[Any]:
+    """Extract all tools from a Crew or single Agent."""
+    tools: list[Any] = []
+
+    # Single Agent: has .tools
+    if hasattr(crew_or_agent, "tools") and not hasattr(crew_or_agent, "agents"):
+        return list(getattr(crew_or_agent, "tools", []) or [])
+
+    # Crew: has .agents, each with .tools
+    agents = getattr(crew_or_agent, "agents", []) or []
+    for agent in agents:
+        tools.extend(list(getattr(agent, "tools", []) or []))
+
+    return tools
+
+
+def _is_multi_agent(crew_or_agent: Any) -> bool:
+    agents = getattr(crew_or_agent, "agents", None)
+    return bool(agents and len(agents) > 1)
+
+
+def extract_profile(
+    crew_or_agent: Any,
+    extra_capabilities: list[str] | None = None,
+    extra_skills: list[dict[str, str]] | None = None,
+) -> dict[str, Any]:
+    """
+    Introspect a CrewAI Crew or Agent and return a partial profile dict
+    with auto-detected capabilities and skills.
+    """
+    tools = _collect_tools(crew_or_agent)
+    capabilities: set[str] = set(extra_capabilities or [])
+    skills_seen: set[str] = set()
+    skills: list[dict[str, str]] = list(extra_skills or [])
+
+    # Always add crewai base skill
+    skills.append({"name": "crewai", "registry": "pypi"})
+    skills_seen.add("crewai")
+
+    # Multi-agent crews get the orchestration capability
+    if _is_multi_agent(crew_or_agent):
+        capabilities.add("multi-agent")
+
+    for tool in tools:
+        cls_name = type(tool).__name__
+        tool_name = getattr(tool, "name", cls_name)
+
+        for key in (cls_name, tool_name):
+            for cap in _TOOL_TO_CAPABILITIES.get(key, []):
+                capabilities.add(cap)
+
+        pkg = _TOOL_TO_PYPI.get(cls_name) or _TOOL_TO_PYPI.get(tool_name)
+        if pkg and pkg not in skills_seen:
+            skills.append({"name": pkg, "registry": "pypi"})
+            skills_seen.add(pkg)
+
+    # Detect LLM provider
+    llm = getattr(crew_or_agent, "llm", None)
+    if llm is None:
+        # Try first agent's LLM
+        agents = getattr(crew_or_agent, "agents", []) or []
+        if agents:
+            llm = getattr(agents[0], "llm", None)
+    if llm:
+        cls_name = type(llm).__name__
+        _LLM_TO_PYPI = {
+            "ChatOpenAI": "langchain-openai",
+            "ChatAnthropic": "langchain-anthropic",
+            "ChatGoogleGenerativeAI": "langchain-google-genai",
+            "ChatGroq": "langchain-groq",
+        }
+        pkg = _LLM_TO_PYPI.get(cls_name)
+        if pkg and pkg not in skills_seen:
+            skills.append({"name": pkg, "registry": "pypi"})
+            skills_seen.add(pkg)
+
+    return {
+        "capabilities": sorted(capabilities) if capabilities else ["reasoning"],
+        "protocols": ["https"],
+        "skills": skills,
+    }
+
+
+def register_crewai_agent(
+    crew_or_agent: Any,
+    name: str,
+    description: str = "",
+    contact_endpoint: str | None = None,
+    organization: str | None = None,
+    version: str | None = None,
+    tags: list[str] | None = None,
+    extra_capabilities: list[str] | None = None,
+    extra_skills: list[dict[str, str]] | None = None,
+    keypair_path: str | None = None,
+    api_url: str | None = None,
+    verbose: bool = True,
+) -> str:
+    """
+    Register a CrewAI Crew or Agent with basedagents.ai.
+
+    Introspects tools to auto-detect capabilities and skills.
+    Idempotent — safe to call on every startup.
+
+    Args:
+        crew_or_agent: CrewAI Crew or Agent instance
+        name: Unique agent name (globally unique on registry)
+        description: What this crew/agent does
+        contact_endpoint: URL where the agent can be reached for verification
+        organization: Optional org name
+        version: Optional version string
+        tags: Optional extra tags
+        extra_capabilities: Additional capabilities beyond auto-detected ones
+        extra_skills: Additional skills beyond auto-detected ones
+        keypair_path: Override keypair file location
+        api_url: Override API URL (defaults to BASEDAGENTS_API env or prod)
+        verbose: Print progress (default True)
+
+    Returns:
+        agent_id string
+
+    Example:
+        from crewai import Crew
+        from basedagents.integrations.crewai import register_crewai_agent
+
+        crew = Crew(agents=[researcher, writer], tasks=[...])
+        agent_id = register_crewai_agent(
+            crew,
+            name="my-research-crew",
+            description="Research and write blog posts.",
+        )
+    """
+    from ..easy import register_or_load
+
+    profile = extract_profile(crew_or_agent, extra_capabilities, extra_skills)
+    merged_tags = list(set(["crewai"] + (tags or [])))
+
+    return register_or_load(
+        name=name,
+        description=description,
+        capabilities=profile["capabilities"],
+        protocols=profile["protocols"],
+        skills=profile["skills"],
+        contact_endpoint=contact_endpoint,
+        organization=organization,
+        version=version,
+        tags=merged_tags,
+        keypair_path=keypair_path,
+        api_url=api_url,
+        verbose=verbose,
+    )

basedagents-0.3.0/basedagents/middleware.py

@@ -0,0 +1,316 @@
+"""
+basedagents auth middleware.
+
+Drop-in reputation-gated authentication for FastAPI and WSGI (Flask/Starlette) apps.
+Agents prove identity via AgentSig header; the middleware verifies the attestation
+offline using the basedagents registry public key.
+
+Usage (FastAPI):
+    from basedagents.middleware import require_agent, VerifiedAgent
+
+    @app.post("/execute")
+    async def execute(request: Request, agent: VerifiedAgent = Depends(require_agent(
+        min_reputation=0.5,
+        capabilities=["code"],
+    ))):
+        print(f"Request from {agent.name} (rep={agent.reputation})")
+        ...
+
+Usage (manual):
+    from basedagents.middleware import verify_request
+
+    agent = await verify_request(request_headers, method, path, body)
+    if agent is None:
+        raise HTTPException(status_code=403)
+"""
+from __future__ import annotations
+
+import base64
+import hashlib
+import json
+import os
+import time
+from dataclasses import dataclass
+from typing import Any, Callable
+
+import httpx
+
+from .keypair import _base58_decode as b58decode_key
+
+# ── Registry public key (Ed25519, hex) ──────────────────────────────────────
+# Published at https://api.basedagents.ai/v1/attestation/public-key
+# Hardcoded here for offline verification — no API call needed at auth time.
+REGISTRY_PUBLIC_KEY_HEX = "9827a77ffa3bbddff01444277707271838098f3e8f2d29a200054cc0bca308d0"
+
+_DEFAULT_BASE = "https://api.basedagents.ai"
+API_BASE = os.environ.get("BASEDAGENTS_API", _DEFAULT_BASE)
+
+# Attestation TTL tolerance (seconds beyond stated expiry)
+CLOCK_SKEW_TOLERANCE = 30
+
+
+@dataclass
+class VerifiedAgent:
+    """A fully verified, reputation-checked agent identity."""
+    agent_id: str
+    name: str
+    public_key_b58: str
+    capabilities: list[str]
+    protocols: list[str]
+    reputation: float
+    reputation_tier: str
+    verification_count: int
+    issued_at: int
+    expires_at: int
+
+
+class AttestationError(Exception):
+    """Raised when attestation verification fails."""
+    pass
+
+
+# ── In-process attestation cache ────────────────────────────────────────────
+_cache: dict[str, tuple[dict[str, Any], float]] = {}  # agent_id → (attestation, fetched_at)
+
+
+def _cache_get(agent_id: str) -> dict[str, Any] | None:
+    entry = _cache.get(agent_id)
+    if entry is None:
+        return None
+    attestation, _ = entry
+    # Use until expires_at minus skew tolerance
+    if time.time() > attestation["expires_at"] - CLOCK_SKEW_TOLERANCE:
+        del _cache[agent_id]
+        return None
+    return attestation
+
+
+def _cache_set(agent_id: str, attestation: dict[str, Any]) -> None:
+    _cache[agent_id] = (attestation, time.time())
+
+
+# ── Attestation fetch & verify ───────────────────────────────────────────────
+
+def _verify_attestation_signature(attestation: dict[str, Any]) -> bool:
+    """
+    Verify the registry's Ed25519 signature on the attestation document.
+    Uses the hardcoded REGISTRY_PUBLIC_KEY_HEX for offline verification.
+    """
+    try:
+        from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PublicKey
+        from cryptography.exceptions import InvalidSignature
+
+        sig_b64 = attestation.get("signature", "")
+        sig_bytes = base64.b64decode(sig_b64)
+
+        # Reconstruct the payload that was signed (all fields except signature, sorted keys)
+        payload = {k: v for k, v in attestation.items() if k not in ("signature", "_verify")}
+        sorted_keys = sorted(payload.keys())
+        canonical = json.dumps(payload, sort_keys=True, separators=(',', ':'))
+        # Match server: JSON.stringify(payload, sortedKeys) — compact, no spaces
+        msg_bytes = canonical.encode("utf-8")
+
+        pub_key_bytes = bytes.fromhex(REGISTRY_PUBLIC_KEY_HEX)
+        pub_key = Ed25519PublicKey.from_public_bytes(pub_key_bytes)
+        pub_key.verify(sig_bytes, msg_bytes)
+        return True
+    except (InvalidSignature, Exception):
+        return False
+
+
+def fetch_attestation(agent_id: str, base_url: str = API_BASE) -> dict[str, Any]:
+    """
+    Fetch a fresh attestation from the registry and verify its signature.
+    Raises AttestationError on failure.
+    """
+    cached = _cache_get(agent_id)
+    if cached is not None:
+        return cached
+
+    url = f"{base_url}/v1/agents/{agent_id}/attestation"
+    with httpx.Client(timeout=10.0) as client:
+        res = client.get(url)
+
+    if res.status_code == 404:
+        raise AttestationError(f"Agent {agent_id} not found in registry")
+    if res.status_code == 403:
+        raise AttestationError(f"Agent {agent_id} is suspended or revoked")
+    if not res.is_success:
+        raise AttestationError(f"Registry returned {res.status_code} for {agent_id}")
+
+    attestation = res.json()
+
+    # Verify registry signature
+    if not _verify_attestation_signature(attestation):
+        raise AttestationError("Attestation signature verification failed — possible tampering")
+
+    # Check expiry
+    now = int(time.time())
+    if now > attestation["expires_at"] + CLOCK_SKEW_TOLERANCE:
+        raise AttestationError("Attestation has expired")
+
+    _cache_set(agent_id, attestation)
+    return attestation
+
+
+def verify_request(
+    headers: dict[str, str],
+    method: str,
+    path: str,
+    body: str | bytes = "",
+    base_url: str = API_BASE,
+) -> VerifiedAgent | None:
+    """
+    Verify an inbound agent request:
+    1. Parse X-Agent-ID and Authorization: AgentSig headers
+    2. Verify the request signature (agent signed this request)
+    3. Fetch + verify the registry attestation (registry signed the agent's identity)
+    4. Confirm the signing key matches the attested public key
+    Returns VerifiedAgent or None if verification fails.
+    """
+    from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PublicKey
+    from cryptography.exceptions import InvalidSignature
+
+    # Parse headers (case-insensitive)
+    headers_lower = {k.lower(): v for k, v in headers.items()}
+
+    agent_id = headers_lower.get("x-agent-id", "").strip()
+    auth_header = headers_lower.get("authorization", "")
+    timestamp_str = headers_lower.get("x-timestamp", "")
+
+    if not agent_id or not auth_header or not timestamp_str:
+        return None
+
+    if not auth_header.startswith("AgentSig "):
+        return None
+
+    try:
+        sig_part = auth_header[len("AgentSig "):]
+        pubkey_b58, sig_b64 = sig_part.rsplit(":", 1)
+        timestamp = int(timestamp_str)
+    except (ValueError, IndexError):
+        return None
+
+    # Check clock skew (±60 seconds)
+    now = int(time.time())
+    if abs(now - timestamp) > 60:
+        return None
+
+    # Verify request signature
+    # Signed message: "<METHOD>:<path>:<timestamp>:<sha256_hex_of_body>"
+    body_bytes = body.encode() if isinstance(body, str) else body
+    body_hash = hashlib.sha256(body_bytes).hexdigest()
+    message = f"{method.upper()}:{path}:{timestamp}:{body_hash}"
+
+    try:
+        pub_key_bytes = b58decode_key(pubkey_b58)
+        sig_bytes = base64.b64decode(sig_b64)
+        pub_key = Ed25519PublicKey.from_public_bytes(pub_key_bytes)
+        pub_key.verify(sig_bytes, message.encode("utf-8"))
+    except (InvalidSignature, Exception):
+        return None
+
+    # Fetch attestation and verify registry signature
+    try:
+        attestation = fetch_attestation(agent_id, base_url)
+    except AttestationError:
+        return None
+
+    # Confirm agent_id matches
+    if attestation["agent_id"] != agent_id:
+        return None
+
+    # Confirm signing key matches attested public key
+    if attestation["public_key_b58"] != pubkey_b58:
+        return None
+
+    return VerifiedAgent(
+        agent_id=attestation["agent_id"],
+        name=attestation["agent_name"],
+        public_key_b58=attestation["public_key_b58"],
+        capabilities=attestation["capabilities"],
+        protocols=attestation["protocols"],
+        reputation=attestation["reputation"],
+        reputation_tier=attestation["reputation_tier"],
+        verification_count=attestation["verification_count"],
+        issued_at=attestation["issued_at"],
+        expires_at=attestation["expires_at"],
+    )
+
+
+# ── FastAPI dependency ────────────────────────────────────────────────────────
+
+def require_agent(
+    min_reputation: float = 0.0,
+    capabilities: list[str] | None = None,
+    base_url: str = API_BASE,
+) -> Callable:
+    """
+    FastAPI dependency factory for reputation-gated agent authentication.
+
+    Args:
+        min_reputation: Minimum reputation score (0–1). Default 0 (any registered agent).
+        capabilities: Required capabilities. Agent must have ALL of them verified.
+        base_url: Override API base URL (useful for testing with staging).
+
+    Returns:
+        FastAPI Depends-compatible callable that returns VerifiedAgent.
+
+    Raises:
+        HTTPException(401) if agent identity cannot be verified.
+        HTTPException(403) if agent doesn't meet reputation/capability requirements.
+
+    Example:
+        @app.post("/run")
+        async def run(request: Request, agent: VerifiedAgent = Depends(require_agent(
+            min_reputation=0.5,
+            capabilities=["code"],
+        ))):
+            ...
+    """
+    async def _dependency(request: Any) -> VerifiedAgent:
+        # Import here to avoid hard dep on fastapi
+        try:
+            from fastapi import HTTPException
+            from fastapi import Request as FastAPIRequest
+        except ImportError:
+            raise ImportError("fastapi is required for require_agent(). pip install fastapi")
+
+        # Read body
+        body = b""
+        try:
+            body = await request.body()
+        except Exception:
+            pass
+
+        headers = dict(request.headers)
+        path = request.url.path
+        method = request.method
+
+        agent = verify_request(headers, method, path, body, base_url)
+
+        if agent is None:
+            raise HTTPException(
+                status_code=401,
+                detail="Agent identity verification failed. Include X-Agent-ID and Authorization: AgentSig headers.",
+            )
+
+        if agent.reputation < min_reputation:
+            raise HTTPException(
+                status_code=403,
+                detail=f"Agent reputation {agent.reputation:.3f} below required {min_reputation}. "
+                       f"Current tier: {agent.reputation_tier}.",
+            )
+
+        if capabilities:
+            missing = [c for c in capabilities if c not in agent.capabilities]
+            if missing:
+                raise HTTPException(
+                    status_code=403,
+                    detail=f"Agent missing required capabilities: {missing}. "
+                           f"Attested capabilities: {agent.capabilities}.",
+                )
+
+        return agent
+
+    return _dependency

{basedagents-0.2.0 → basedagents-0.3.0}/basedagents.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: basedagents
-Version: 0.2.0
+Version: 0.3.0
 Summary: Python SDK for basedagents.ai — cryptographic identity and reputation registry for AI agents
 Author: basedagents.ai
 License: MIT

{basedagents-0.2.0 → basedagents-0.3.0}/basedagents.egg-info/SOURCES.txt

@@ -6,6 +6,7 @@ basedagents/cli.py
 basedagents/client.py
 basedagents/easy.py
 basedagents/keypair.py
+basedagents/middleware.py
 basedagents/pow.py
 basedagents.egg-info/PKG-INFO
 basedagents.egg-info/SOURCES.txt
@@ -14,4 +15,6 @@ basedagents.egg-info/entry_points.txt
 basedagents.egg-info/requires.txt
 basedagents.egg-info/top_level.txt
 basedagents/integrations/__init__.py
+basedagents/integrations/autogen.py
+basedagents/integrations/crewai.py
 basedagents/integrations/langchain.py

{basedagents-0.2.0 → basedagents-0.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "basedagents"
-version = "0.2.0"
+version = "0.3.0"
 description = "Python SDK for basedagents.ai — cryptographic identity and reputation registry for AI agents"
 readme = "README.md"
 license = { text = "MIT" }