basedagents 0.1.2__tar.gz → 0.2.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: basedagents
-Version: 0.1.2
+Version: 0.2.0
 Summary: Python SDK for basedagents.ai — cryptographic identity and reputation registry for AI agents
 Author: basedagents.ai
 License: MIT
@@ -40,22 +40,47 @@ pip install basedagents
 
 ## Quick start
 
+One call. Idempotent. Safe to run on every startup.
+
 ```python
-from basedagents import generate_keypair, RegistryClient
+from basedagents import register_or_load
+
+agent_id = register_or_load(
+    name="my-research-agent",
+    description="Searches the web and summarizes findings.",
+    capabilities=["reasoning", "web-search"],
+    skills=[{"name": "langchain", "registry": "pypi"}],
+    contact_endpoint="https://my-agent.example.com",  # optional
+)
+print(agent_id)  # ag_...
+```
 
-keypair = generate_keypair()
+- First run: generates a keypair, solves proof-of-work, registers.
+- Every run after: loads the keypair, verifies registration, returns `agent_id` immediately.
+- Keypair saved at `~/.basedagents/keys/<name>-keypair.json`.
 
-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_...
+## LangChain
+
+Auto-detects capabilities and skills from your agent's tools:
+
+```python
+from langchain.agents import AgentExecutor, create_react_agent
+from langchain_openai import ChatOpenAI
+from langchain_community.tools.tavily_search import TavilySearchResults
+from basedagents.integrations.langchain import register_langchain_agent
+
+llm = ChatOpenAI(model="gpt-4o")
+tools = [TavilySearchResults(max_results=3)]
+agent = AgentExecutor(agent=create_react_agent(llm, tools, prompt), tools=tools)
+
+agent_id = register_langchain_agent(
+    agent,
+    name="my-research-agent",
+    description="Searches the web and summarizes findings.",
+    contact_endpoint="https://my-agent.example.com",
+)
+# → detects skills: langchain, langchain-openai, langchain-community
+# → detects capabilities: web-search
 ```
 
 ## CLI
@@ -71,27 +96,36 @@ basedagents whois Hans
 basedagents validate
 ```
 
-## Signing requests
+## Low-level API
 
 ```python
-from basedagents import generate_keypair
-from basedagents.auth import build_headers
-import httpx, json
+from basedagents import generate_keypair, RegistryClient
 
 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)
+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_...
 ```
 
-## Load a saved keypair
+## Signing requests manually
 
 ```python
+from basedagents.auth import build_headers
 from basedagents.keypair import AgentKeypair
 from pathlib import Path
+import httpx, json
 
 keypair = AgentKeypair.load(Path("~/.basedagents/keys/myagent-keypair.json").expanduser())
+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)
 ```
 
 ## Links

basedagents-0.2.0/README.md

@@ -0,0 +1,106 @@
+# basedagents
+
+Python SDK for [basedagents.ai](https://basedagents.ai) — cryptographic identity and reputation registry for AI agents.
+
+## Install
+
+```bash
+pip install basedagents
+```
+
+## Quick start
+
+One call. Idempotent. Safe to run on every startup.
+
+```python
+from basedagents import register_or_load
+
+agent_id = register_or_load(
+    name="my-research-agent",
+    description="Searches the web and summarizes findings.",
+    capabilities=["reasoning", "web-search"],
+    skills=[{"name": "langchain", "registry": "pypi"}],
+    contact_endpoint="https://my-agent.example.com",  # optional
+)
+print(agent_id)  # ag_...
+```
+
+- First run: generates a keypair, solves proof-of-work, registers.
+- Every run after: loads the keypair, verifies registration, returns `agent_id` immediately.
+- Keypair saved at `~/.basedagents/keys/<name>-keypair.json`.
+
+## LangChain
+
+Auto-detects capabilities and skills from your agent's tools:
+
+```python
+from langchain.agents import AgentExecutor, create_react_agent
+from langchain_openai import ChatOpenAI
+from langchain_community.tools.tavily_search import TavilySearchResults
+from basedagents.integrations.langchain import register_langchain_agent
+
+llm = ChatOpenAI(model="gpt-4o")
+tools = [TavilySearchResults(max_results=3)]
+agent = AgentExecutor(agent=create_react_agent(llm, tools, prompt), tools=tools)
+
+agent_id = register_langchain_agent(
+    agent,
+    name="my-research-agent",
+    description="Searches the web and summarizes findings.",
+    contact_endpoint="https://my-agent.example.com",
+)
+# → detects skills: langchain, langchain-openai, langchain-community
+# → detects capabilities: web-search
+```
+
+## 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
+```
+
+## Low-level API
+
+```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_...
+```
+
+## Signing requests manually
+
+```python
+from basedagents.auth import build_headers
+from basedagents.keypair import AgentKeypair
+from pathlib import Path
+import httpx, json
+
+keypair = AgentKeypair.load(Path("~/.basedagents/keys/myagent-keypair.json").expanduser())
+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)
+```
+
+## 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.2.0/basedagents/__init__.py

@@ -0,0 +1,46 @@
+"""
+basedagents — Python SDK for basedagents.ai
+
+Cryptographic identity and reputation registry for AI agents.
+
+Quick start (idiomatic):
+    from basedagents import register_or_load
+
+    agent_id = register_or_load(
+        name="MyAgent",
+        description="Does useful things.",
+        capabilities=["reasoning", "code"],
+    )
+
+LangChain:
+    from basedagents.integrations.langchain import register_langchain_agent
+
+    agent_id = register_langchain_agent(
+        executor,           # AgentExecutor or list of BaseTool
+        name="MyAgent",
+        description="Researches topics and writes reports.",
+    )
+
+Low-level:
+    from basedagents import generate_keypair, RegistryClient
+
+    keypair = generate_keypair()
+    with RegistryClient() as client:
+        agent = client.register(keypair, {"name": "MyAgent", ...})
+        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
+from .easy import register_or_load
+
+__version__ = "0.2.0"
+__all__ = [
+    "register_or_load",
+    "AgentKeypair",
+    "RegistryClient",
+    "BasedAgentsError",
+    "generate_keypair",
+    "from_private_key_hex",
+    "build_auth_headers",
+]

{basedagents-0.1.2 → basedagents-0.2.0}/basedagents/cli.py

@@ -14,7 +14,7 @@ import sys
 from pathlib import Path
 
 API_URL = "https://api.basedagents.ai"
-VERSION = "0.1.2"
+VERSION = "0.2.0"
 
 
 def _print_err(msg: str) -> None:

basedagents-0.2.0/basedagents/easy.py

@@ -0,0 +1,142 @@
+"""
+Ergonomic one-call registration for agents that don't want the ceremony.
+
+Usage:
+    from basedagents import register_or_load
+
+    agent_id = register_or_load(
+        name="my-trading-agent",
+        description="Analyzes stock trends.",
+        capabilities=["reasoning", "data-analysis"],
+        skills=[{"name": "langchain", "registry": "pypi"}],
+        contact_endpoint="https://my-agent.example.com",
+    )
+"""
+from __future__ import annotations
+
+import re
+import sys
+from pathlib import Path
+from typing import Any
+
+from .client import RegistryClient, BasedAgentsError
+from .keypair import AgentKeypair, generate as generate_keypair
+
+_DEFAULT_KEYS_DIR = Path.home() / ".basedagents" / "keys"
+
+
+def _slug(name: str) -> str:
+    """Convert agent name to a safe filename slug."""
+    return re.sub(r"[^a-z0-9]+", "-", name.lower()).strip("-")
+
+
+def register_or_load(
+    name: str,
+    description: str = "",
+    capabilities: list[str] | None = None,
+    protocols: list[str] | None = None,
+    skills: list[dict[str, str]] | None = None,
+    contact_endpoint: str | None = None,
+    organization: str | None = None,
+    version: str | None = None,
+    tags: list[str] | None = None,
+    keypair_path: Path | str | None = None,
+    api_url: str | None = None,
+    verbose: bool = True,
+) -> str:
+    """
+    Idempotent agent registration. Safe to call on every startup.
+
+    - If the keypair file already exists AND the agent is registered: returns agent_id immediately.
+    - If keypair exists but agent is not registered (e.g. first run after keypair creation): registers.
+    - If no keypair file: generates one, registers, saves it.
+
+    Args:
+        name: Unique agent name (globally unique on basedagents.ai)
+        description: What the agent does
+        capabilities: List of capability strings (e.g. ["reasoning", "code"])
+        protocols: Supported protocols (e.g. ["https", "mcp"]). Defaults to ["https"]
+        skills: Declared tool dependencies e.g. [{"name": "langchain", "registry": "pypi"}]
+        contact_endpoint: HTTP(S) URL where this agent can be reached for verification probes
+        organization: Optional org name
+        version: Optional version string
+        tags: Optional tags for discovery
+        keypair_path: Override path for the keypair JSON file.
+                      Defaults to ~/.basedagents/keys/<name-slug>-keypair.json
+        api_url: Override API base URL. Defaults to BASEDAGENTS_API env var or api.basedagents.ai
+        verbose: Print progress to stderr (default True)
+
+    Returns:
+        agent_id string (e.g. "ag_...")
+    """
+    def _log(msg: str) -> None:
+        if verbose:
+            print(f"[basedagents] {msg}", file=sys.stderr)
+
+    slug = _slug(name)
+    path = Path(keypair_path).expanduser() if keypair_path else _DEFAULT_KEYS_DIR / f"{slug}-keypair.json"
+
+    from .client import DEFAULT_API_URL
+    base_url = api_url or DEFAULT_API_URL
+
+    with RegistryClient(api_url=base_url) as client:
+        # Load or generate keypair
+        if path.exists():
+            keypair = AgentKeypair.load(path)
+            _log(f"Loaded keypair from {path}")
+
+            # Check if already registered
+            if keypair.agent_id:
+                try:
+                    agent = client.get_agent(keypair.agent_id)
+                    _log(f"Already registered: {agent['name']} ({keypair.agent_id})")
+                    return keypair.agent_id
+                except BasedAgentsError as e:
+                    if e.status == 404:
+                        _log("Keypair found but agent not in registry — registering...")
+                    else:
+                        raise
+        else:
+            _log("No keypair found — generating...")
+            keypair = generate_keypair()
+            _log(f"Generated keypair (public key: {keypair.public_key_b58[:16]}...)")
+
+        # Build profile
+        profile: dict[str, Any] = {
+            "name": name,
+            "description": description,
+            "capabilities": capabilities or [],
+            "protocols": protocols or ["https"],
+        }
+        if skills:
+            profile["skills"] = skills
+        if contact_endpoint:
+            profile["contact_endpoint"] = contact_endpoint
+        if organization:
+            profile["organization"] = organization
+        if version:
+            profile["version"] = version
+        if tags:
+            profile["tags"] = tags
+
+        # Register with progress reporting
+        _log("Solving proof-of-work...")
+        last_reported = [0]
+
+        def on_progress(attempts: int) -> None:
+            if attempts - last_reported[0] >= 500_000:
+                _log(f"  {attempts:,} attempts...")
+                last_reported[0] = attempts
+
+        result = client.register(keypair, profile, on_progress=on_progress)
+        agent_id: str = result["agent_id"]
+
+        # Persist keypair with agent_id stamped in
+        from .keypair import from_private_key_hex as _from_hex
+        import dataclasses
+        keypair = dataclasses.replace(keypair, agent_id=agent_id)
+        keypair.save(path)
+        _log(f"Registered! agent_id={agent_id}")
+        _log(f"Keypair saved to {path}")
+
+        return agent_id

basedagents-0.2.0/basedagents/integrations/langchain.py

@@ -0,0 +1,224 @@
+"""
+LangChain integration for basedagents.
+
+Introspects a LangChain AgentExecutor (or tool list) and auto-populates
+the capabilities and skills fields for registration.
+
+Usage:
+    from langchain.agents import AgentExecutor
+    from basedagents.integrations.langchain import register_langchain_agent
+
+    agent_id = register_langchain_agent(
+        executor,
+        name="my-research-agent",
+        description="Searches the web and summarizes findings.",
+        contact_endpoint="https://my-agent.example.com",
+    )
+"""
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    # Avoid hard dep on langchain at import time
+    try:
+        from langchain.agents import AgentExecutor
+        from langchain_core.tools import BaseTool
+    except ImportError:
+        AgentExecutor = Any  # type: ignore
+        BaseTool = Any  # type: ignore
+
+
+# ── Tool name → PyPI package mapping ──────────────────────────────────────────
+# Maps LangChain tool class names and common tool names to their PyPI packages.
+_TOOL_TO_PYPI: dict[str, str] = {
+    # LangChain core
+    "langchain": "langchain",
+    "langchainhub": "langchainhub",
+    # LLM providers
+    "ChatOpenAI": "langchain-openai",
+    "OpenAI": "langchain-openai",
+    "ChatAnthropic": "langchain-anthropic",
+    "ChatGoogleGenerativeAI": "langchain-google-genai",
+    "ChatMistralAI": "langchain-mistralai",
+    "ChatGroq": "langchain-groq",
+    "ChatOllama": "langchain-ollama",
+    "ChatCohere": "langchain-cohere",
+    # Search tools
+    "TavilySearchResults": "langchain-community",
+    "DuckDuckGoSearchRun": "langchain-community",
+    "GoogleSearchAPIWrapper": "langchain-community",
+    "SerpAPIWrapper": "langchain-community",
+    "BingSearchAPIWrapper": "langchain-community",
+    "BraveSearch": "langchain-community",
+    # Code tools
+    "PythonREPLTool": "langchain-experimental",
+    "ShellTool": "langchain-community",
+    # Data / DB
+    "SQLDatabaseToolkit": "langchain-community",
+    "PandasDataFrameAgent": "langchain-experimental",
+    "SparkDataFrameAgent": "langchain-experimental",
+    # File tools
+    "ReadFileTool": "langchain-community",
+    "WriteFileTool": "langchain-community",
+    # Vector stores
+    "Chroma": "langchain-chroma",
+    "FAISS": "langchain-community",
+    "Pinecone": "langchain-pinecone",
+    "Weaviate": "langchain-weaviate",
+    # Memory
+    "ConversationBufferMemory": "langchain",
+    "ConversationSummaryMemory": "langchain",
+    # Agents SDK
+    "create_react_agent": "langchain",
+    "create_openai_tools_agent": "langchain",
+    "AgentExecutor": "langchain",
+}
+
+# ── Tool name → capabilities mapping ─────────────────────────────────────────
+_TOOL_TO_CAPABILITIES: dict[str, list[str]] = {
+    "TavilySearchResults": ["web-search"],
+    "DuckDuckGoSearchRun": ["web-search"],
+    "GoogleSearchAPIWrapper": ["web-search"],
+    "SerpAPIWrapper": ["web-search"],
+    "BingSearchAPIWrapper": ["web-search"],
+    "BraveSearch": ["web-search"],
+    "PythonREPLTool": ["code"],
+    "ShellTool": ["code", "system"],
+    "SQLDatabaseToolkit": ["data-analysis", "sql"],
+    "PandasDataFrameAgent": ["data-analysis"],
+    "ReadFileTool": ["file-access"],
+    "WriteFileTool": ["file-access"],
+    "WikipediaQueryRun": ["web-search", "knowledge"],
+    "ArxivQueryRun": ["web-search", "knowledge"],
+    "HumanInputRun": ["human-in-the-loop"],
+    "RequestsGetTool": ["http"],
+    "RequestsPostTool": ["http"],
+}
+
+
+def _extract_tools(agent_or_tools: Any) -> list[Any]:
+    """Extract tool list from AgentExecutor or raw list."""
+    if isinstance(agent_or_tools, list):
+        return agent_or_tools
+    # AgentExecutor has .tools attribute
+    tools = getattr(agent_or_tools, "tools", None)
+    if tools is not None:
+        return list(tools)
+    return []
+
+
+def extract_profile(
+    agent_or_tools: Any,
+    extra_capabilities: list[str] | None = None,
+    extra_skills: list[dict[str, str]] | None = None,
+) -> dict[str, Any]:
+    """
+    Introspect a LangChain AgentExecutor or tool list and return a partial
+    profile dict with auto-detected capabilities and skills.
+
+    You can merge this with your own fields:
+        profile = extract_profile(agent, extra_capabilities=["reasoning"])
+        profile.update({"name": "MyAgent", "description": "..."})
+    """
+    tools = _extract_tools(agent_or_tools)
+    capabilities: set[str] = set(extra_capabilities or [])
+    skills_seen: set[str] = set()
+    skills: list[dict[str, str]] = list(extra_skills or [])
+
+    # Always include base langchain skill
+    if tools and "langchain" not in skills_seen:
+        skills.append({"name": "langchain", "registry": "pypi"})
+        skills_seen.add("langchain")
+
+    for tool in tools:
+        cls_name = type(tool).__name__
+        tool_name = getattr(tool, "name", cls_name)
+
+        # Capabilities
+        for key in (cls_name, tool_name):
+            for cap in _TOOL_TO_CAPABILITIES.get(key, []):
+                capabilities.add(cap)
+
+        # Skills — prefer class name lookup, fall back to tool name
+        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 package from agent if available
+    llm = getattr(agent_or_tools, "agent", None)
+    if llm:
+        llm_obj = getattr(llm, "llm", None) or getattr(llm, "llm_chain", None)
+        if llm_obj:
+            llm_cls = type(llm_obj).__name__
+            pkg = _TOOL_TO_PYPI.get(llm_cls)
+            if pkg and pkg not in skills_seen:
+                skills.append({"name": pkg, "registry": "pypi"})
+                skills_seen.add(pkg)
+
+    return {
+        "capabilities": sorted(capabilities),
+        "protocols": ["https"],
+        "skills": skills,
+    }
+
+
+def register_langchain_agent(
+    agent_or_tools: 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 LangChain agent with basedagents.ai.
+
+    Introspects the agent's tools to auto-detect capabilities and skills.
+    Idempotent — safe to call on every startup.
+
+    Args:
+        agent_or_tools: LangChain AgentExecutor or list of BaseTool
+        name: Unique agent name
+        description: What the agent does
+        contact_endpoint: URL where the agent can be reached for verification
+        organization: Optional org name
+        version: Optional version string
+        tags: Optional tags (e.g. ["langchain", "research"])
+        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
+    """
+    from ..easy import register_or_load
+
+    profile = extract_profile(agent_or_tools, extra_capabilities, extra_skills)
+
+    # Add "langchain" tag automatically
+    merged_tags = list(set(["langchain"] + (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.1.2 → basedagents-0.2.0}/basedagents/keypair.py

@@ -88,8 +88,15 @@ class AgentKeypair:
 
     @classmethod
     def load(cls, path: Path) -> "AgentKeypair":
+        import dataclasses
         data = json.loads(path.read_text())
-        return from_private_key_hex(data["private_key_hex"])
+        kp = from_private_key_hex(data["private_key_hex"])
+        # Restore the saved agent_id (may differ from computed ag_<pubkey>
+        # only if the server assigned a different format — currently they match,
+        # but we preserve it explicitly for forward compatibility)
+        if "agent_id" in data:
+            kp = dataclasses.replace(kp, agent_id=data["agent_id"])
+        return kp
 
 
 def generate() -> AgentKeypair:

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: basedagents
-Version: 0.1.2
+Version: 0.2.0
 Summary: Python SDK for basedagents.ai — cryptographic identity and reputation registry for AI agents
 Author: basedagents.ai
 License: MIT
@@ -40,22 +40,47 @@ pip install basedagents
 
 ## Quick start
 
+One call. Idempotent. Safe to run on every startup.
+
 ```python
-from basedagents import generate_keypair, RegistryClient
+from basedagents import register_or_load
+
+agent_id = register_or_load(
+    name="my-research-agent",
+    description="Searches the web and summarizes findings.",
+    capabilities=["reasoning", "web-search"],
+    skills=[{"name": "langchain", "registry": "pypi"}],
+    contact_endpoint="https://my-agent.example.com",  # optional
+)
+print(agent_id)  # ag_...
+```
 
-keypair = generate_keypair()
+- First run: generates a keypair, solves proof-of-work, registers.
+- Every run after: loads the keypair, verifies registration, returns `agent_id` immediately.
+- Keypair saved at `~/.basedagents/keys/<name>-keypair.json`.
 
-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_...
+## LangChain
+
+Auto-detects capabilities and skills from your agent's tools:
+
+```python
+from langchain.agents import AgentExecutor, create_react_agent
+from langchain_openai import ChatOpenAI
+from langchain_community.tools.tavily_search import TavilySearchResults
+from basedagents.integrations.langchain import register_langchain_agent
+
+llm = ChatOpenAI(model="gpt-4o")
+tools = [TavilySearchResults(max_results=3)]
+agent = AgentExecutor(agent=create_react_agent(llm, tools, prompt), tools=tools)
+
+agent_id = register_langchain_agent(
+    agent,
+    name="my-research-agent",
+    description="Searches the web and summarizes findings.",
+    contact_endpoint="https://my-agent.example.com",
+)
+# → detects skills: langchain, langchain-openai, langchain-community
+# → detects capabilities: web-search
 ```
 
 ## CLI
@@ -71,27 +96,36 @@ basedagents whois Hans
 basedagents validate
 ```
 
-## Signing requests
+## Low-level API
 
 ```python
-from basedagents import generate_keypair
-from basedagents.auth import build_headers
-import httpx, json
+from basedagents import generate_keypair, RegistryClient
 
 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)
+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_...
 ```
 
-## Load a saved keypair
+## Signing requests manually
 
 ```python
+from basedagents.auth import build_headers
 from basedagents.keypair import AgentKeypair
 from pathlib import Path
+import httpx, json
 
 keypair = AgentKeypair.load(Path("~/.basedagents/keys/myagent-keypair.json").expanduser())
+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)
 ```
 
 ## Links

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

@@ -4,6 +4,7 @@ basedagents/__init__.py
 basedagents/auth.py
 basedagents/cli.py
 basedagents/client.py
+basedagents/easy.py
 basedagents/keypair.py
 basedagents/pow.py
 basedagents.egg-info/PKG-INFO
@@ -11,4 +12,6 @@ basedagents.egg-info/SOURCES.txt
 basedagents.egg-info/dependency_links.txt
 basedagents.egg-info/entry_points.txt
 basedagents.egg-info/requires.txt
-basedagents.egg-info/top_level.txt
+basedagents.egg-info/top_level.txt
+basedagents/integrations/__init__.py
+basedagents/integrations/langchain.py

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

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

basedagents-0.1.2/README.md

@@ -1,72 +0,0 @@
-# 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.2/basedagents/__init__.py

@@ -1,31 +0,0 @@
-"""
-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.2"
-__all__ = [
-    "AgentKeypair",
-    "RegistryClient",
-    "BasedAgentsError",
-    "generate_keypair",
-    "from_private_key_hex",
-    "build_auth_headers",
-]