nodeproxy-tools 0.1.0__py3-none-any.whl

nodeproxy_tools/__init__.py

@@ -0,0 +1,21 @@
+"""NodeProxy client + framework integrations for upstream agent packages."""
+
+from nodeproxy_tools.client import NodeProxyClient, NodeProxyError, ParseResult
+from nodeproxy_tools.constants import DEFAULT_API_URL, TOOL_DESCRIPTION, TOOL_NAME
+
+try:
+    from nodeproxy_tools.langchain import NodeProxyMarkdownTool as LangChainNodeProxyTool
+except ImportError:
+    LangChainNodeProxyTool = None  # type: ignore[misc, assignment]
+
+__all__ = [
+    "DEFAULT_API_URL",
+    "LangChainNodeProxyTool",
+    "NodeProxyClient",
+    "NodeProxyError",
+    "ParseResult",
+    "TOOL_DESCRIPTION",
+    "TOOL_NAME",
+]
+
+__version__ = "0.1.0"

nodeproxy_tools/cli.py

@@ -0,0 +1,29 @@
+"""CLI entrypoint for quick NodeProxy smoke tests."""
+
+from __future__ import annotations
+
+import sys
+
+from nodeproxy_tools.client import NodeProxyClient, NodeProxyError
+
+
+def main() -> None:
+    if len(sys.argv) < 2:
+        print("Usage: nodeproxy-parse <url>", file=sys.stderr)
+        raise SystemExit(2)
+
+    url = sys.argv[1]
+    client = NodeProxyClient()
+    try:
+        result = client.parse_url(url)
+    except NodeProxyError as exc:
+        print(f"Error: {exc}", file=sys.stderr)
+        raise SystemExit(1) from exc
+
+    if result.transaction:
+        print(f"# settled: {result.transaction} ({result.network})", file=sys.stderr)
+    print(result.markdown)
+
+
+if __name__ == "__main__":
+    main()

nodeproxy_tools/client.py

@@ -0,0 +1,123 @@
+"""x402-aware HTTP client for the NodeProxy surface markdown parser."""
+
+from __future__ import annotations
+
+import json
+import os
+from dataclasses import dataclass
+from typing import Any, Optional
+
+from nodeproxy_tools.constants import DEFAULT_API_URL, TOOL_NAME
+
+
+class NodeProxyError(Exception):
+    """Raised when NodeProxy returns a non-success response."""
+
+
+@dataclass
+class ParseResult:
+    """Successful parse payload."""
+
+    markdown: str
+    transaction: Optional[str] = None
+    network: Optional[str] = None
+    raw: Optional[dict[str, Any]] = None
+
+
+class NodeProxyClient:
+    """
+    Calls NodeProxy ``POST /mcp/execute`` with automatic x402 payment handling.
+
+    Requires ``EVM_PRIVATE_KEY`` (or pass ``evm_private_key=``) with USDC on the
+    network your NodeProxy deployment uses (Base Sepolia testnet or Base mainnet).
+    """
+
+    def __init__(
+        self,
+        *,
+        api_url: str = DEFAULT_API_URL,
+        evm_private_key: Optional[str] = None,
+        max_price_usdc: float = 0.05,
+    ) -> None:
+        self.api_url = api_url.rstrip("/")
+        self.evm_private_key = evm_private_key or os.getenv("EVM_PRIVATE_KEY")
+        self.max_price_usdc = max_price_usdc
+        self._session = None
+        self._x402_client = None
+
+    def _ensure_x402(self) -> None:
+        if self._x402_client is not None:
+            return
+        if not self.evm_private_key:
+            raise NodeProxyError(
+                "EVM_PRIVATE_KEY is required for paid NodeProxy calls. "
+                "Set the env var or pass evm_private_key= to NodeProxyClient()."
+            )
+
+        try:
+            from eth_account import Account
+            from x402 import x402ClientSync
+            from x402.http.clients import x402_requests
+            from x402.mechanisms.evm import EthAccountSigner
+            from x402.mechanisms.evm.exact.register import register_exact_evm_client
+        except ImportError as exc:
+            raise NodeProxyError(
+                'Install x402 extras: pip install "nodeproxy-tools[x402]"'
+            ) from exc
+
+        client = x402ClientSync()
+        account = Account.from_key(self.evm_private_key)
+        register_exact_evm_client(client, EthAccountSigner(account))
+        self._x402_client = client
+        self._session = x402_requests(client)
+
+    def parse_url(self, url: str) -> ParseResult:
+        """Fetch *url* via NodeProxy and return cleaned Markdown."""
+        self._ensure_x402()
+        assert self._session is not None
+
+        payload = {"tool": TOOL_NAME, "arguments": {"url": url}}
+
+        with self._session as session:
+            response = session.post(
+                self.api_url,
+                json=payload,
+                headers={"Content-Type": "application/json"},
+                timeout=120,
+            )
+
+        if response.status_code != 200:
+            detail = response.text[:500]
+            try:
+                detail = response.json().get("error", detail)
+            except json.JSONDecodeError:
+                pass
+            raise NodeProxyError(f"NodeProxy HTTP {response.status_code}: {detail}")
+
+        data = response.json()
+        content = data.get("content") or []
+        if not content or not content[0].get("text"):
+            raise NodeProxyError(f"Unexpected NodeProxy response shape: {data!r}")
+
+        settlement = data.get("settlement") or {}
+        return ParseResult(
+            markdown=content[0]["text"],
+            transaction=settlement.get("transaction"),
+            network=settlement.get("network"),
+            raw=data,
+        )
+
+    def parse_url_text(self, url: str) -> str:
+        """Convenience wrapper returning Markdown string only."""
+        return self.parse_url(url).markdown
+
+    def close(self) -> None:
+        """Release underlying HTTP session if held."""
+        self._session = None
+        self._x402_client = None
+
+    def __enter__(self) -> "NodeProxyClient":
+        return self
+
+    def __exit__(self, *args: object) -> None:
+        self.close()

nodeproxy_tools/constants.py

@@ -0,0 +1,9 @@
+DEFAULT_API_URL = "https://nodeproxy-production.up.railway.app/mcp/execute"
+
+TOOL_NAME = "surface_markdown_parser"
+
+TOOL_DESCRIPTION = (
+    "Executes fetch on any public URL, strips scripts/ads/nav noise, and returns "
+    "compressed semantic Markdown optimized for LLM token ingestion. "
+    "Paid per request via x402 USDC micropayment."
+)

nodeproxy_tools/crewai.py

@@ -0,0 +1,34 @@
+"""CrewAI ``BaseTool`` wrapper for NodeProxy."""
+
+from __future__ import annotations
+
+from typing import Type
+
+from crewai.tools import BaseTool
+from pydantic import BaseModel, ConfigDict, Field
+
+from nodeproxy_tools.client import NodeProxyClient, NodeProxyError
+from nodeproxy_tools.constants import TOOL_DESCRIPTION, TOOL_NAME
+
+
+class NodeProxyInput(BaseModel):
+    """Input schema for the NodeProxy markdown parser."""
+
+    url: str = Field(..., description="Public website URL to parse into LLM-ready Markdown.")
+
+
+class NodeProxyMarkdownTool(BaseTool):
+    """CrewAI tool for the NodeProxy x402-gated web surface parser."""
+
+    name: str = TOOL_NAME
+    description: str = TOOL_DESCRIPTION
+    args_schema: Type[BaseModel] = NodeProxyInput
+
+    client: NodeProxyClient = Field(default_factory=NodeProxyClient)
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    def _run(self, url: str) -> str:
+        try:
+            return self.client.parse_url_text(url)
+        except NodeProxyError as exc:
+            return f"NodeProxy error: {exc}"

nodeproxy_tools/langchain.py

@@ -0,0 +1,43 @@
+"""LangChain ``BaseTool`` wrapper for NodeProxy."""
+
+from __future__ import annotations
+
+from typing import Optional, Type
+
+from langchain_core.callbacks import CallbackManagerForToolRun
+from langchain_core.tools import BaseTool
+from pydantic import BaseModel, ConfigDict, Field
+
+from nodeproxy_tools.client import NodeProxyClient, NodeProxyError
+from nodeproxy_tools.constants import TOOL_DESCRIPTION, TOOL_NAME
+
+
+class NodeProxyInput(BaseModel):
+    """Input schema for the NodeProxy markdown parser."""
+
+    url: str = Field(description="Public website URL to parse into LLM-ready Markdown.")
+
+
+class NodeProxyMarkdownTool(BaseTool):
+    """
+    LangChain tool that calls the NodeProxy x402-gated web surface parser.
+
+    .. versionadded:: 0.1.0
+    """
+
+    name: str = TOOL_NAME
+    description: str = TOOL_DESCRIPTION
+    args_schema: Type[BaseModel] = NodeProxyInput
+
+    client: NodeProxyClient = Field(default_factory=NodeProxyClient)
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    def _run(
+        self,
+        url: str,
+        run_manager: Optional[CallbackManagerForToolRun] = None,
+    ) -> str:
+        try:
+            return self.client.parse_url_text(url)
+        except NodeProxyError as exc:
+            return f"NodeProxy error: {exc}"

nodeproxy_tools-0.1.0.dist-info/METADATA

@@ -0,0 +1,66 @@
+Metadata-Version: 2.4
+Name: nodeproxy-tools
+Version: 0.1.0
+Summary: LangChain/CrewAI integrations for the NodeProxy x402 web surface markdown parser
+Author-email: pgalyen1987 <pgalyen87@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/pgalyen1987/NodeProxy
+Project-URL: Documentation, https://github.com/pgalyen1987/NodeProxy/tree/main/integrations
+Project-URL: Repository, https://github.com/pgalyen1987/NodeProxy
+Keywords: langchain,crewai,mcp,x402,web-scraping,markdown,agents
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: pydantic>=2.0
+Requires-Dist: requests>=2.31
+Provides-Extra: x402
+Requires-Dist: x402[evm,requests]>=2.0; extra == "x402"
+Requires-Dist: eth-account>=0.10; extra == "x402"
+Provides-Extra: langchain
+Requires-Dist: langchain-core>=0.2; extra == "langchain"
+Requires-Dist: x402[evm,requests]>=2.0; extra == "langchain"
+Requires-Dist: eth-account>=0.10; extra == "langchain"
+Provides-Extra: crewai
+Requires-Dist: crewai>=0.80; extra == "crewai"
+Requires-Dist: x402[evm,requests]>=2.0; extra == "crewai"
+Requires-Dist: eth-account>=0.10; extra == "crewai"
+Provides-Extra: all
+Requires-Dist: nodeproxy-tools[crewai,langchain]; extra == "all"
+
+# nodeproxy-tools
+
+Python client and framework wrappers for [NodeProxy](https://github.com/pgalyen1987/NodeProxy).
+
+## Install
+
+```bash
+pip install "nodeproxy-tools[x402,langchain]"
+export EVM_PRIVATE_KEY=0x...
+```
+
+## LangChain
+
+```python
+from nodeproxy_tools.langchain import NodeProxyMarkdownTool
+
+tool = NodeProxyMarkdownTool()
+print(tool.invoke({"url": "https://example.com"}))
+```
+
+## CrewAI
+
+```python
+from nodeproxy_tools.crewai import NodeProxyMarkdownTool
+
+tool = NodeProxyMarkdownTool()
+print(tool._run("https://example.com"))
+```
+
+## CLI
+
+```bash
+nodeproxy-parse https://example.com
+```

nodeproxy_tools-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+nodeproxy_tools/__init__.py,sha256=ijJwzcsRbjGY6tKBtMyaPAntHfF2yHXgKKPEHAFPtjQ,621
+nodeproxy_tools/cli.py,sha256=2SBTzLK_aWSHSupluxDetpMBImkHskkmc9ST7AKDbzo,711
+nodeproxy_tools/client.py,sha256=-2MeQgzIkAnTIui9TgW9yJSHFOi7gVoCsjn2I3NPhJI,4025
+nodeproxy_tools/constants.py,sha256=IDCXtkpKDG2QblgxGtPFEgQk8Jc4TMcbxnojcYh0nrw,344
+nodeproxy_tools/crewai.py,sha256=7XEm---47oSOfLA6SJpIBDPZQwk2yW9GMdBXWNDTHY4,1061
+nodeproxy_tools/langchain.py,sha256=R4sQ6uvWb6eELVVw-ExenWwmhcad0nHpcK94t5gA5Qw,1277
+nodeproxy_tools-0.1.0.dist-info/METADATA,sha256=MmCCZrRKLbKZ30E3M9x7bmshNTLkAMtDDRliuZ-FTtc,2012
+nodeproxy_tools-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+nodeproxy_tools-0.1.0.dist-info/entry_points.txt,sha256=AbGnGzuqm87ARxarLlVNtKN2nKG1fHsUKHdKa_0BwIA,61
+nodeproxy_tools-0.1.0.dist-info/top_level.txt,sha256=VjbAFlZTJNnHwIcsTkXQYyZVV6xnsoX_dSbZuDFZT_Y,16
+nodeproxy_tools-0.1.0.dist-info/RECORD,,

nodeproxy_tools-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
+

nodeproxy_tools-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+nodeproxy-parse = nodeproxy_tools.cli:main

nodeproxy_tools-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+nodeproxy_tools