langchain-quantumscan 0.1.0__tar.gz

langchain_quantumscan-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 QuantumScan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

langchain_quantumscan-0.1.0/PKG-INFO

@@ -0,0 +1,90 @@
+Metadata-Version: 2.4
+Name: langchain-quantumscan
+Version: 0.1.0
+Summary: QuantumScan tools for LangChain, LangGraph, CrewAI, and AutoGen — pre-transaction safety checks and post-quantum cryptography scanning for autonomous agents.
+Author-email: QuantumScan <hello@quantumscan.io>
+License: MIT
+Project-URL: Homepage, https://quantumscan.io
+Project-URL: Repository, https://github.com/quantumscan-io/langchain-quantumscan
+Project-URL: Issues, https://github.com/quantumscan-io/langchain-quantumscan/issues
+Keywords: langchain,langgraph,crewai,autogen,ai-agent,blockchain-security,post-quantum-cryptography,quantumscan,mcp
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: langchain
+Requires-Dist: langchain>=0.1; extra == "langchain"
+Requires-Dist: pydantic>=2.0; extra == "langchain"
+Provides-Extra: crewai
+Requires-Dist: crewai>=0.1; python_version >= "3.10" and extra == "crewai"
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Dynamic: license-file
+
+# langchain-quantumscan
+
+QuantumScan tools for **LangChain**, **LangGraph**, **CrewAI**, and **AutoGen** — pre-transaction
+safety checks (honeypot/drainer detection, contract risk scoring) and post-quantum cryptography
+vulnerability scanning, ready to drop into an agent's toolset.
+
+No server to run — every tool calls the hosted QuantumScan MCP endpoint
+(`https://quantumscan.io/api/mcp`) directly. Free tier: 10 scans/day per IP, no signup.
+
+## Install
+
+```bash
+pip install langchain-quantumscan
+```
+
+## LangChain / LangGraph
+
+```python
+from langchain_quantumscan import get_quantumscan_tools
+from langgraph.prebuilt import create_react_agent
+
+tools = get_quantumscan_tools()
+agent = create_react_agent(llm, tools)
+```
+
+Individual tools: `QuantumScanTool` (scan a repo), `GetScanResultTool` (poll for results),
+`CheckPqcRiskTool` (instant algorithm check, no scan), `ScanContractTool` (verify a contract
+is safe **before** signing a transaction with it).
+
+## CrewAI
+
+```python
+from crewai import Agent
+from langchain_quantumscan import QuantumScanCrewTool
+
+auditor = Agent(
+    role="Security Auditor",
+    goal="Verify contracts and repos are safe before the crew interacts with them",
+    tools=[QuantumScanCrewTool()],
+)
+```
+
+## AutoGen
+
+```python
+from langchain_quantumscan import quantumscan_scan_contract, AUTOGEN_TOOLS
+```
+
+## Why this exists
+
+Autonomous agents that sign transactions or install dependencies are the highest-value target
+for honeypots, drainers, and rug pulls — and by construction they can't "notice" a scam the way
+a human would. `ScanContractTool` / `quantumscan_scan_contract` gives an agent a way to check
+**before** signing, not just discover the loss after.
+
+## Optional: higher rate limits
+
+```bash
+export QUANTUMSCAN_API_KEY=qs_...   # get one free at quantumscan.io
+```
+
+## License
+
+MIT

langchain_quantumscan-0.1.0/README.md

@@ -0,0 +1,64 @@
+# langchain-quantumscan
+
+QuantumScan tools for **LangChain**, **LangGraph**, **CrewAI**, and **AutoGen** — pre-transaction
+safety checks (honeypot/drainer detection, contract risk scoring) and post-quantum cryptography
+vulnerability scanning, ready to drop into an agent's toolset.
+
+No server to run — every tool calls the hosted QuantumScan MCP endpoint
+(`https://quantumscan.io/api/mcp`) directly. Free tier: 10 scans/day per IP, no signup.
+
+## Install
+
+```bash
+pip install langchain-quantumscan
+```
+
+## LangChain / LangGraph
+
+```python
+from langchain_quantumscan import get_quantumscan_tools
+from langgraph.prebuilt import create_react_agent
+
+tools = get_quantumscan_tools()
+agent = create_react_agent(llm, tools)
+```
+
+Individual tools: `QuantumScanTool` (scan a repo), `GetScanResultTool` (poll for results),
+`CheckPqcRiskTool` (instant algorithm check, no scan), `ScanContractTool` (verify a contract
+is safe **before** signing a transaction with it).
+
+## CrewAI
+
+```python
+from crewai import Agent
+from langchain_quantumscan import QuantumScanCrewTool
+
+auditor = Agent(
+    role="Security Auditor",
+    goal="Verify contracts and repos are safe before the crew interacts with them",
+    tools=[QuantumScanCrewTool()],
+)
+```
+
+## AutoGen
+
+```python
+from langchain_quantumscan import quantumscan_scan_contract, AUTOGEN_TOOLS
+```
+
+## Why this exists
+
+Autonomous agents that sign transactions or install dependencies are the highest-value target
+for honeypots, drainers, and rug pulls — and by construction they can't "notice" a scam the way
+a human would. `ScanContractTool` / `quantumscan_scan_contract` gives an agent a way to check
+**before** signing, not just discover the loss after.
+
+## Optional: higher rate limits
+
+```bash
+export QUANTUMSCAN_API_KEY=qs_...   # get one free at quantumscan.io
+```
+
+## License
+
+MIT

langchain_quantumscan-0.1.0/langchain_quantumscan/__init__.py

@@ -0,0 +1,305 @@
+"""
+QuantumScan tools for LangChain, LangGraph, CrewAI, and AutoGen.
+
+Pre-transaction safety checks (honeypot/drainer detection, contract risk
+scoring) and post-quantum cryptography vulnerability scanning, exposed as
+ready-to-use agent tools — no server to run, calls the hosted QuantumScan
+MCP endpoint directly.
+
+Works with:
+  - LangChain / LangGraph: use the BaseTool subclasses below
+  - CrewAI: see QuantumScanCrewTool
+  - AutoGen: see quantumscan_scan / quantumscan_result / quantumscan_check
+    and AUTOGEN_TOOLS
+
+No API key required for the free tier (10 scans/day per IP).
+Optional: QUANTUMSCAN_API_KEY env var for higher limits.
+
+Example (LangChain / LangGraph):
+    from langchain_quantumscan import get_quantumscan_tools
+    from langgraph.prebuilt import create_react_agent
+
+    tools = get_quantumscan_tools()
+    agent = create_react_agent(llm, tools)
+
+Example (CrewAI):
+    from langchain_quantumscan import QuantumScanCrewTool
+    agent = Agent(role="Security Auditor", tools=[QuantumScanCrewTool()], ...)
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import urllib.error
+import urllib.request
+from typing import Optional, Type
+
+__version__ = "0.1.0"
+
+try:
+    from langchain.tools import BaseTool
+    from pydantic import BaseModel, Field
+
+    HAS_LANGCHAIN = True
+except ImportError:
+    HAS_LANGCHAIN = False
+
+QUANTUMSCAN_URL = os.environ.get("QUANTUMSCAN_API_URL", "https://quantumscan.io")
+QUANTUMSCAN_API_KEY = os.environ.get("QUANTUMSCAN_API_KEY", "")
+
+
+# ── HTTP helper ─────────────────────────────────────────────────────────────
+
+
+def _mcp_call(tool_name: str, arguments: dict) -> str:
+    """Call a QuantumScan MCP tool. Returns tool result text."""
+    headers = {"Content-Type": "application/json", "User-Agent": f"langchain-quantumscan/{__version__}"}
+    if QUANTUMSCAN_API_KEY:
+        headers["X-API-Key"] = QUANTUMSCAN_API_KEY
+
+    payload = json.dumps(
+        {
+            "jsonrpc": "2.0",
+            "id": 1,
+            "method": "tools/call",
+            "params": {"name": tool_name, "arguments": arguments},
+        }
+    ).encode()
+
+    req = urllib.request.Request(
+        f"{QUANTUMSCAN_URL}/api/mcp",
+        data=payload,
+        headers=headers,
+        method="POST",
+    )
+    try:
+        with urllib.request.urlopen(req, timeout=30) as resp:
+            data = json.loads(resp.read().decode())
+            content = data.get("result", {}).get("content", [])
+            return "\n".join(c.get("text", "") for c in content if c.get("type") == "text")
+    except urllib.error.HTTPError as e:
+        return f"Error {e.code}: {e.read().decode()}"
+    except Exception as e:  # noqa: BLE001 — agent tools must return text, never raise
+        return f"Request failed: {e}"
+
+
+# ── Pydantic schemas (for LangChain) ────────────────────────────────────────
+
+if HAS_LANGCHAIN:
+
+    class ScanRepositoryInput(BaseModel):
+        repo_url: str = Field(description="GitHub, GitLab, or Bitbucket URL to scan")
+
+    class GetScanResultInput(BaseModel):
+        scan_id: str = Field(description="Scan UUID returned by scan_repository")
+
+    class CheckPqcRiskInput(BaseModel):
+        algorithms: list[str] = Field(
+            description='Algorithm names to check, e.g. ["ECDSA", "RSA-2048", "ML-KEM-768"]'
+        )
+
+    class ScanContractInput(BaseModel):
+        contract_address: str = Field(description="Ethereum contract address (0x...)")
+        network: Optional[int] = Field(
+            default=1, description="Chain ID (1=Ethereum, 137=Polygon, 42161=Arbitrum, 8453=Base)"
+        )
+
+
+# ── LangChain / LangGraph Tools ──────────────────────────────────────────────
+
+if HAS_LANGCHAIN:
+
+    class QuantumScanTool(BaseTool):
+        name: str = "scan_repository"
+        description: str = (
+            "Submit a GitHub, GitLab, or Bitbucket repository for post-quantum cryptography "
+            "vulnerability scanning. Returns a scan_id. Poll with get_scan_result after ~60s."
+        )
+        args_schema: Type[BaseModel] = ScanRepositoryInput
+
+        def _run(self, repo_url: str) -> str:
+            return _mcp_call("scan_repository", {"repo_url": repo_url})
+
+        async def _arun(self, repo_url: str) -> str:
+            return self._run(repo_url)
+
+    class GetScanResultTool(BaseTool):
+        name: str = "get_scan_result"
+        description: str = (
+            "Get results of a PQC scan by scan_id. "
+            "Returns risk score (0-100), vulnerable algorithms, and CBOM. "
+            "If status is 'working', wait 15s and retry."
+        )
+        args_schema: Type[BaseModel] = GetScanResultInput
+
+        def _run(self, scan_id: str) -> str:
+            return _mcp_call("get_scan_result", {"scan_id": scan_id})
+
+        async def _arun(self, scan_id: str) -> str:
+            return self._run(scan_id)
+
+    class CheckPqcRiskTool(BaseTool):
+        name: str = "check_pqc_risk"
+        description: str = (
+            "Instantly check if cryptographic algorithms are quantum-vulnerable. "
+            "No scan needed. Supports ECDSA, RSA, Ed25519, AES-128, SHA-1, BLS12, ML-KEM, etc."
+        )
+        args_schema: Type[BaseModel] = CheckPqcRiskInput
+
+        def _run(self, algorithms: list[str]) -> str:
+            return _mcp_call("check_pqc_risk", {"algorithms": algorithms})
+
+        async def _arun(self, algorithms: list[str]) -> str:
+            return self._run(algorithms)
+
+    class ScanContractTool(BaseTool):
+        name: str = "scan_contract"
+        description: str = (
+            "Verify a smart contract is safe BEFORE an agent signs a transaction with it. "
+            "Detects honeypots, drainers, rug pulls, uncapped mints, and PQC-vulnerable crypto. "
+            "Returns risk score 0-100 and a signing recommendation."
+        )
+        args_schema: Type[BaseModel] = ScanContractInput
+
+        def _run(self, contract_address: str, network: int = 1) -> str:
+            return _mcp_call("scan_contract", {"contract_address": contract_address, "network": network})
+
+        async def _arun(self, contract_address: str, network: int = 1) -> str:
+            return self._run(contract_address, network)
+
+    def get_quantumscan_tools() -> list:
+        """Return all 4 QuantumScan LangChain tools, ready to pass to any agent."""
+        return [QuantumScanTool(), GetScanResultTool(), CheckPqcRiskTool(), ScanContractTool()]
+
+
+# ── CrewAI Tool ──────────────────────────────────────────────────────────────
+
+try:
+    from crewai.tools import BaseTool as CrewBaseTool
+
+    class QuantumScanCrewTool(CrewBaseTool):
+        name: str = "QuantumScan Security Check"
+        description: str = (
+            "Verifies a smart contract before signing, or scans a repo/algorithm for post-quantum risk. "
+            "Input: a contract address (0x...) to verify before signing, a repo URL to scan, "
+            "a scan UUID to get results, or an algorithm name to check."
+        )
+
+        def _run(self, input_text: str) -> str:
+            import re
+
+            eth_addr_m = re.search(r"\b0x[0-9a-fA-F]{40}\b", input_text)
+            url_m = re.search(r"https?://(?:github|gitlab|bitbucket)\.(?:com|org)/\S+", input_text)
+            uuid_m = re.search(
+                r"[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}", input_text, re.I
+            )
+            algo_m = re.search(r"\b(ECDSA|RSA|ECDH|Ed25519|AES-?128|SHA-?1|MD5|ML-KEM|ML-DSA)\b", input_text, re.I)
+
+            if eth_addr_m:
+                return _mcp_call("scan_contract", {"contract_address": eth_addr_m.group(0)})
+            elif url_m:
+                return _mcp_call("scan_repository", {"repo_url": url_m.group(0).rstrip("/")})
+            elif uuid_m:
+                return _mcp_call("get_scan_result", {"scan_id": uuid_m.group(0)})
+            elif algo_m:
+                return _mcp_call("check_pqc_risk", {"algorithms": [algo_m.group(0)]})
+            else:
+                return (
+                    "Send a contract address (0x...) to verify before signing, a GitHub URL to scan, "
+                    "a scan UUID to get results, or an algorithm name to check risk."
+                )
+
+except ImportError:
+    pass
+
+
+# ── AutoGen Function Tools ───────────────────────────────────────────────────
+
+
+def quantumscan_scan(repo_url: str) -> str:
+    """Submit a GitHub/GitLab/Bitbucket repo for PQC vulnerability scanning. Returns scan_id."""
+    return _mcp_call("scan_repository", {"repo_url": repo_url})
+
+
+def quantumscan_result(scan_id: str) -> str:
+    """Get PQC scan result by scan_id. Returns risk score + vulnerable algorithms."""
+    return _mcp_call("get_scan_result", {"scan_id": scan_id})
+
+
+def quantumscan_check(algorithms: list) -> str:
+    """Instantly check if algorithms are quantum-vulnerable. No scan needed."""
+    return _mcp_call("check_pqc_risk", {"algorithms": algorithms})
+
+
+def quantumscan_scan_contract(contract_address: str, network: int = 1) -> str:
+    """Verify a smart contract is safe to sign a transaction with. Returns risk score + recommendation."""
+    return _mcp_call("scan_contract", {"contract_address": contract_address, "network": network})
+
+
+AUTOGEN_TOOLS = [
+    {
+        "type": "function",
+        "function": {
+            "name": "quantumscan_scan",
+            "description": "Submit a GitHub/GitLab/Bitbucket repository for PQC vulnerability scanning.",
+            "parameters": {
+                "type": "object",
+                "properties": {"repo_url": {"type": "string", "description": "Full repository URL"}},
+                "required": ["repo_url"],
+            },
+        },
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "quantumscan_result",
+            "description": "Get PQC scan results by scan_id.",
+            "parameters": {
+                "type": "object",
+                "properties": {"scan_id": {"type": "string", "description": "UUID from quantumscan_scan"}},
+                "required": ["scan_id"],
+            },
+        },
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "quantumscan_check",
+            "description": "Instantly check if cryptographic algorithms are quantum-vulnerable.",
+            "parameters": {
+                "type": "object",
+                "properties": {"algorithms": {"type": "array", "items": {"type": "string"}}},
+                "required": ["algorithms"],
+            },
+        },
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "quantumscan_scan_contract",
+            "description": "Verify a smart contract is safe to sign a transaction with before doing so.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "contract_address": {"type": "string", "description": "0x... Ethereum contract address"},
+                    "network": {"type": "integer", "description": "Chain ID, default 1 (Ethereum)"},
+                },
+                "required": ["contract_address"],
+            },
+        },
+    },
+]
+
+
+# ── Claude Desktop / MCP client config snippet ───────────────────────────────
+
+CLAUDE_DESKTOP_CONFIG = {
+    "mcpServers": {
+        "quantumscan": {
+            "command": "npx",
+            "args": ["-y", "mcp-remote", "https://quantumscan.io/api/mcp"],
+            "env": {"QUANTUMSCAN_API_KEY": "optional — get a free key at quantumscan.io"},
+        }
+    }
+}

langchain_quantumscan-0.1.0/langchain_quantumscan.egg-info/PKG-INFO

@@ -0,0 +1,90 @@
+Metadata-Version: 2.4
+Name: langchain-quantumscan
+Version: 0.1.0
+Summary: QuantumScan tools for LangChain, LangGraph, CrewAI, and AutoGen — pre-transaction safety checks and post-quantum cryptography scanning for autonomous agents.
+Author-email: QuantumScan <hello@quantumscan.io>
+License: MIT
+Project-URL: Homepage, https://quantumscan.io
+Project-URL: Repository, https://github.com/quantumscan-io/langchain-quantumscan
+Project-URL: Issues, https://github.com/quantumscan-io/langchain-quantumscan/issues
+Keywords: langchain,langgraph,crewai,autogen,ai-agent,blockchain-security,post-quantum-cryptography,quantumscan,mcp
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: langchain
+Requires-Dist: langchain>=0.1; extra == "langchain"
+Requires-Dist: pydantic>=2.0; extra == "langchain"
+Provides-Extra: crewai
+Requires-Dist: crewai>=0.1; python_version >= "3.10" and extra == "crewai"
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Dynamic: license-file
+
+# langchain-quantumscan
+
+QuantumScan tools for **LangChain**, **LangGraph**, **CrewAI**, and **AutoGen** — pre-transaction
+safety checks (honeypot/drainer detection, contract risk scoring) and post-quantum cryptography
+vulnerability scanning, ready to drop into an agent's toolset.
+
+No server to run — every tool calls the hosted QuantumScan MCP endpoint
+(`https://quantumscan.io/api/mcp`) directly. Free tier: 10 scans/day per IP, no signup.
+
+## Install
+
+```bash
+pip install langchain-quantumscan
+```
+
+## LangChain / LangGraph
+
+```python
+from langchain_quantumscan import get_quantumscan_tools
+from langgraph.prebuilt import create_react_agent
+
+tools = get_quantumscan_tools()
+agent = create_react_agent(llm, tools)
+```
+
+Individual tools: `QuantumScanTool` (scan a repo), `GetScanResultTool` (poll for results),
+`CheckPqcRiskTool` (instant algorithm check, no scan), `ScanContractTool` (verify a contract
+is safe **before** signing a transaction with it).
+
+## CrewAI
+
+```python
+from crewai import Agent
+from langchain_quantumscan import QuantumScanCrewTool
+
+auditor = Agent(
+    role="Security Auditor",
+    goal="Verify contracts and repos are safe before the crew interacts with them",
+    tools=[QuantumScanCrewTool()],
+)
+```
+
+## AutoGen
+
+```python
+from langchain_quantumscan import quantumscan_scan_contract, AUTOGEN_TOOLS
+```
+
+## Why this exists
+
+Autonomous agents that sign transactions or install dependencies are the highest-value target
+for honeypots, drainers, and rug pulls — and by construction they can't "notice" a scam the way
+a human would. `ScanContractTool` / `quantumscan_scan_contract` gives an agent a way to check
+**before** signing, not just discover the loss after.
+
+## Optional: higher rate limits
+
+```bash
+export QUANTUMSCAN_API_KEY=qs_...   # get one free at quantumscan.io
+```
+
+## License
+
+MIT

langchain_quantumscan-0.1.0/langchain_quantumscan.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+LICENSE
+README.md
+pyproject.toml
+langchain_quantumscan/__init__.py
+langchain_quantumscan.egg-info/PKG-INFO
+langchain_quantumscan.egg-info/SOURCES.txt
+langchain_quantumscan.egg-info/dependency_links.txt
+langchain_quantumscan.egg-info/requires.txt
+langchain_quantumscan.egg-info/top_level.txt
+tests/test_tools.py

langchain_quantumscan-0.1.0/langchain_quantumscan.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

langchain_quantumscan-0.1.0/langchain_quantumscan.egg-info/requires.txt

@@ -0,0 +1,12 @@
+
+[crewai]
+
+[crewai:python_version >= "3.10"]
+crewai>=0.1
+
+[dev]
+pytest>=8.0
+
+[langchain]
+langchain>=0.1
+pydantic>=2.0

langchain_quantumscan-0.1.0/langchain_quantumscan.egg-info/top_level.txt

@@ -0,0 +1 @@
+langchain_quantumscan

langchain_quantumscan-0.1.0/pyproject.toml

@@ -0,0 +1,36 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "langchain-quantumscan"
+version = "0.1.0"
+description = "QuantumScan tools for LangChain, LangGraph, CrewAI, and AutoGen — pre-transaction safety checks and post-quantum cryptography scanning for autonomous agents."
+readme = "README.md"
+license = { text = "MIT" }
+authors = [{ name = "QuantumScan", email = "hello@quantumscan.io" }]
+requires-python = ">=3.9"
+keywords = ["langchain", "langgraph", "crewai", "autogen", "ai-agent", "blockchain-security", "post-quantum-cryptography", "quantumscan", "mcp"]
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Intended Audience :: Developers",
+  "License :: OSI Approved :: MIT License",
+  "Programming Language :: Python :: 3",
+]
+dependencies = []
+
+[project.optional-dependencies]
+langchain = ["langchain>=0.1", "pydantic>=2.0"]
+# crewai itself requires Python >=3.10 (PEP 604 `X | None` syntax internally);
+# the marker keeps `pip install langchain-quantumscan[crewai]` resolvable
+# instead of crashing on import for 3.9 users.
+crewai = ["crewai>=0.1; python_version >= '3.10'"]
+dev = ["pytest>=8.0"]
+
+[project.urls]
+Homepage = "https://quantumscan.io"
+Repository = "https://github.com/quantumscan-io/langchain-quantumscan"
+Issues = "https://github.com/quantumscan-io/langchain-quantumscan/issues"
+
+[tool.setuptools]
+packages = ["langchain_quantumscan"]

langchain_quantumscan-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

langchain_quantumscan-0.1.0/tests/test_tools.py

@@ -0,0 +1,42 @@
+"""Smoke tests — import and shape checks only, no network calls."""
+
+import langchain_quantumscan as qs
+
+
+def test_module_imports():
+    assert qs.__version__
+
+
+def test_mcp_call_helper_exists():
+    assert callable(qs._mcp_call)
+
+
+def test_autogen_functions_exist():
+    assert callable(qs.quantumscan_scan)
+    assert callable(qs.quantumscan_result)
+    assert callable(qs.quantumscan_check)
+    assert callable(qs.quantumscan_scan_contract)
+
+
+def test_autogen_tools_schema():
+    names = {t["function"]["name"] for t in qs.AUTOGEN_TOOLS}
+    assert names == {
+        "quantumscan_scan",
+        "quantumscan_result",
+        "quantumscan_check",
+        "quantumscan_scan_contract",
+    }
+
+
+def test_claude_desktop_config_shape():
+    cfg = qs.CLAUDE_DESKTOP_CONFIG
+    assert cfg["mcpServers"]["quantumscan"]["args"][-1] == "https://quantumscan.io/api/mcp"
+
+
+def test_langchain_tools_if_available():
+    if not qs.HAS_LANGCHAIN:
+        return
+    tools = qs.get_quantumscan_tools()
+    assert len(tools) == 4
+    names = {t.name for t in tools}
+    assert names == {"scan_repository", "get_scan_result", "check_pqc_risk", "scan_contract"}