bidda-shield 0.1.0__py3-none-any.whl

bidda_shield-0.1.0.dist-info/METADATA

@@ -0,0 +1,282 @@
+Metadata-Version: 2.4
+Name: bidda-shield
+Version: 0.1.0
+Summary: Bidda Compliance Intelligence SDK — LangChain, AutoGen, CrewAI integration
+Home-page: https://bidda.com
+Author: Bidda Intelligence
+Author-email: api@bidda.com
+Project-URL: Homepage, https://bidda.com
+Project-URL: Documentation, https://bidda.com/developers
+Project-URL: Source, https://git.bidda.com/Bidda-Ai/bidda-shield
+Project-URL: Registry, https://bidda.com/intelligence
+Project-URL: MCP Server, https://bidda.com/mcp
+Keywords: compliance,GDPR,EU AI Act,LangChain,AutoGen,CrewAI,regulatory,legal,AI safety
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Office/Business :: Financial :: Accounting
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: httpx>=0.24.0
+Provides-Extra: langchain
+Requires-Dist: langchain>=0.1.0; extra == "langchain"
+Requires-Dist: langchain-core>=0.1.0; extra == "langchain"
+Requires-Dist: pydantic>=2.0; extra == "langchain"
+Provides-Extra: autogen
+Requires-Dist: pyautogen>=0.2.0; extra == "autogen"
+Provides-Extra: crewai
+Requires-Dist: crewai>=0.28.0; extra == "crewai"
+Requires-Dist: crewai-tools>=0.1.0; extra == "crewai"
+Provides-Extra: all
+Requires-Dist: langchain>=0.1.0; extra == "all"
+Requires-Dist: langchain-core>=0.1.0; extra == "all"
+Requires-Dist: pydantic>=2.0; extra == "all"
+Requires-Dist: pyautogen>=0.2.0; extra == "all"
+Requires-Dist: crewai>=0.28.0; extra == "all"
+Requires-Dist: crewai-tools>=0.1.0; extra == "all"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license-file
+Dynamic: project-url
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# bidda-shield
+
+**Verified compliance intelligence for AI agents.** Stop your LangChain, AutoGen, and CrewAI agents from hallucinating legal requirements.
+
+```bash
+pip install bidda-shield
+```
+
+---
+
+## The problem
+
+AI agents making decisions about hiring, credit scoring, data processing, or content moderation are operating under dozens of overlapping regulations — GDPR, EU AI Act, HIPAA, CCPA, Basel III. When an agent gets the legal logic wrong, it isn't just a bug. It's a regulatory liability event.
+
+LLMs hallucinate regulations. bidda-shield doesn't.
+
+Every compliance node in the Bidda registry traces to a specific clause of a primary legal instrument, verified against the source URL, and drift-checked weekly. No inference. No approximation.
+
+---
+
+## Quickstart
+
+```python
+from bidda_shield import BiddaShield
+
+shield = BiddaShield()
+
+# Find the compliance node most relevant to your agent's action
+result = shield.check_compliance("process biometric data for access control")
+print(result["title"])   # EU AI Act Article 5 — Prohibited AI Practices
+print(result["bluf"])    # Plain-English summary of the legal obligation
+```
+
+---
+
+## LangChain
+
+```python
+from langchain.agents import initialize_agent, AgentType
+from langchain_openai import ChatOpenAI
+from bidda_shield import BiddaLangChainTool
+
+llm  = ChatOpenAI(model="gpt-4o")
+tool = BiddaLangChainTool()
+
+agent = initialize_agent(
+    tools=[tool],
+    llm=llm,
+    agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION,
+    verbose=True,
+)
+
+agent.run(
+    "My agent is about to make an automated credit decision. "
+    "What regulations apply and what do they require?"
+)
+```
+
+The tool returns the regulation title, domain, plain-English summary (BLUF), and a link to the full verified node — for $0.01 USDC per full unlock.
+
+---
+
+## AutoGen
+
+```python
+import autogen
+from bidda_shield import BiddaAutoGenTool
+
+config_list = [{"model": "gpt-4o", "api_key": "YOUR_OPENAI_KEY"}]
+
+bidda_tool = BiddaAutoGenTool()
+
+assistant = autogen.AssistantAgent(
+    name="compliance_assistant",
+    llm_config={
+        "config_list": config_list,
+        "functions": [bidda_tool.function_schema],
+    },
+)
+
+user_proxy = autogen.UserProxyAgent(
+    name="user",
+    human_input_mode="NEVER",
+    function_map={"bidda_compliance_lookup": bidda_tool.execute},
+)
+
+user_proxy.initiate_chat(
+    assistant,
+    message="What does GDPR Article 22 require for automated decision-making?",
+)
+```
+
+---
+
+## CrewAI
+
+```python
+from crewai import Agent, Task, Crew
+from bidda_shield import BiddaCrewAITool
+
+compliance_tool = BiddaCrewAITool()
+
+compliance_officer = Agent(
+    role="Chief Compliance Officer",
+    goal="Ensure all AI agent actions comply with applicable regulations",
+    backstory="Expert in GDPR, EU AI Act, HIPAA, and global data protection law.",
+    tools=[compliance_tool],
+    verbose=True,
+)
+
+task = Task(
+    description="Review the agent action 'train a model on employee performance data' and identify all applicable regulations.",
+    agent=compliance_officer,
+)
+
+crew = Crew(agents=[compliance_officer], tasks=[task])
+crew.kickoff()
+```
+
+---
+
+## Direct API usage
+
+```python
+from bidda_shield import BiddaShield
+
+shield = BiddaShield()
+
+# Search by keyword
+nodes = shield.search_nodes("automated decision making")
+for n in nodes:
+    print(n["node_id"], "—", n["title"])
+
+# Get a specific node (free discovery tier)
+node = shield.get_node("gdpr-article-22-automated-decisions")
+print(node["bluf"])
+
+# Get full vault data (requires Skyfire JWT or USDC payment — $0.01)
+shield_paid = BiddaShield(skyfire_token="YOUR_SKYFIRE_JWT")
+full_node = shield_paid.get_node("gdpr-article-22-automated-decisions", vault=True)
+print(full_node["deterministic_workflow"])  # Step-by-step legal compliance logic
+```
+
+---
+
+## What's in a full node
+
+Each vault-tier node contains:
+
+- **BLUF** — plain-English summary of the legal obligation
+- **deterministic_workflow** — step-by-step compliance checklist derived from the primary legal text
+- **actionable_schema** — machine-readable compliance checkpoints
+- **primary_citations** — exact section references to the legal instrument
+- **crosswalks** — mappings to NIST, ISO, and peer standards
+- **dependencies** — other regulations this one depends on or triggers
+- **verification** — source URL, jurisdiction, instrument type, integrity hash
+
+All content traces to a real primary legal source. No secondary commentary. No paraphrasing.
+
+---
+
+## Payment
+
+- **Discovery tier** (free): node ID, title, domain, plain-English summary
+- **Vault tier** ($0.01 USDC per node): full deterministic logic, citations, crosswalks, workflow
+
+Pay with:
+- **Skyfire** — pass a `skyfire-pay-id` bearer token (agent-native, no wallet required)
+- **L402 / Base USDC** — send $0.01 to the Bidda Base wallet, pass the tx hash
+
+```python
+# With Skyfire
+shield = BiddaShield(skyfire_token=os.getenv("BIDDA_SKYFIRE_TOKEN"))
+
+# With Base tx hash
+shield = BiddaShield(base_tx_hash="0xYOUR_TRANSACTION_HASH")
+```
+
+---
+
+## Install options
+
+```bash
+# Core (no framework dependencies)
+pip install bidda-shield
+
+# With LangChain
+pip install "bidda-shield[langchain]"
+
+# With AutoGen
+pip install "bidda-shield[autogen]"
+
+# With CrewAI
+pip install "bidda-shield[crewai]"
+
+# Everything
+pip install "bidda-shield[all]"
+```
+
+---
+
+## Registry coverage
+
+- **4,600+ verified nodes** across 31 regulatory pillars
+- **Pillars:** AI Governance, Cybersecurity, Banking & Finance, Healthcare, Legal & IP, ESG, Workplace, Aviation & Defense, Crypto, Cloud, and 21 more
+- **Jurisdictions:** EU, US, UK, Germany, Australia, Singapore, South Africa, and global instruments
+- **Sources:** EU AI Act, GDPR, NIST CSF, ISO 27001, Basel III/IV, HIPAA, DORA, NIS2, FATF, and 150+ authority bodies
+
+Full registry: [bidda.com/intelligence](https://bidda.com/intelligence)
+
+---
+
+## Links
+
+- Registry: [bidda.com](https://bidda.com)
+- API docs: [bidda.com/developers](https://bidda.com/developers)
+- MCP server: `https://bidda.com/mcp` (Claude.ai, Claude Desktop, any MCP client)
+- Source: [git.bidda.com/Bidda-Ai/bidda-shield](https://git.bidda.com/Bidda-Ai/bidda-shield)
+- Support: [api@bidda.com](mailto:api@bidda.com)
+
+---
+
+## License
+
+MIT — use freely, attribution appreciated.

bidda_shield-0.1.0.dist-info/RECORD

@@ -0,0 +1,6 @@
+bidda_shield.py,sha256=pXl7bwjQWKz9dVW7sggk4N7cET_7rTUWKwbyHmdRs7c,13421
+bidda_shield-0.1.0.dist-info/licenses/LICENSE,sha256=UAN_Gqn6B6doggwWpBlfMZC9RcDTG28IcVpg6agcphY,1083
+bidda_shield-0.1.0.dist-info/METADATA,sha256=AjQTLUUjuPco8vdSNbzVP4JW-xb5_D7phqR9Kcdmzlw,8809
+bidda_shield-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+bidda_shield-0.1.0.dist-info/top_level.txt,sha256=whaDbCykzJxK1gmeq9UKFMO_MBIF0OL_9lEDuYSuJNA,13
+bidda_shield-0.1.0.dist-info/RECORD,,

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

bidda_shield-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Bidda Intelligence PTY LTD
+
+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.

bidda_shield-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+bidda_shield

bidda_shield.py

@@ -0,0 +1,368 @@
+"""
+bidda-shield: Bidda Compliance Intelligence SDK
+
+Integrates with LangChain, AutoGen, and CrewAI to give AI agents
+real-time access to verified compliance intelligence from bidda.com.
+
+Usage:
+    from bidda_shield import BiddaShield, BiddaLangChainTool
+
+    # Basic usage
+    shield = BiddaShield()
+    node = shield.get_node("gdpr-article-5-data-principles")
+    print(node["bluf"])
+
+    # LangChain Tool
+    from langchain.agents import initialize_agent, AgentType
+    from langchain_openai import ChatOpenAI
+    tool = BiddaLangChainTool()
+    agent = initialize_agent([tool], ChatOpenAI(), agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION)
+
+    # AutoGen Tool
+    from autogen import AssistantAgent, UserProxyAgent
+    tool = BiddaAutoGenTool()
+
+    # CrewAI Tool
+    from crewai import Agent
+    tool = BiddaCrewAITool()
+    compliance_agent = Agent(role="Compliance Officer", tools=[tool])
+"""
+
+from __future__ import annotations
+
+import os
+import json
+import time
+import hashlib
+import logging
+from typing import Optional, Any
+
+try:
+    import httpx
+    _HAS_HTTPX = True
+except ImportError:
+    import urllib.request
+    _HAS_HTTPX = False
+
+logger = logging.getLogger("bidda_shield")
+
+BIDDA_API_BASE   = "https://bidda.com/api/v1"
+DISCOVERY_SUFFIX = "/nodes"
+VAULT_SUFFIX     = "/vault/nodes"
+DEFAULT_TIMEOUT  = 10
+
+
+class BiddaError(Exception):
+    pass
+
+
+class PaymentRequired(BiddaError):
+    """Raised when a vault node requires payment (x402 / L402)."""
+    def __init__(self, node_id: str, cost_usd: str):
+        self.node_id  = node_id
+        self.cost_usd = cost_usd
+        super().__init__(
+            f"Node '{node_id}' requires payment: ${cost_usd} USDC. "
+            "Pass a Skyfire JWT via skyfire_token= or a Base tx hash via base_tx_hash=."
+        )
+
+
+class BiddaShield:
+    """
+    Core Bidda client.
+
+    Parameters
+    ----------
+    skyfire_token : str, optional
+        Skyfire pay+jwt bearer token for autonomous agent payments.
+        Set BIDDA_SKYFIRE_TOKEN env var to avoid passing it explicitly.
+    base_tx_hash : str, optional
+        Base USDC transaction hash (0x...) for L402 settlement.
+    timeout : int
+        HTTP timeout in seconds.
+    """
+
+    def __init__(
+        self,
+        skyfire_token: Optional[str] = None,
+        base_tx_hash: Optional[str] = None,
+        timeout: int = DEFAULT_TIMEOUT,
+    ):
+        self.skyfire_token = skyfire_token or os.getenv("BIDDA_SKYFIRE_TOKEN")
+        self.base_tx_hash  = base_tx_hash
+        self.timeout       = timeout
+
+    def _headers(self) -> dict[str, str]:
+        h: dict[str, str] = {"Accept": "application/json"}
+        if self.skyfire_token:
+            h["skyfire-pay-id"] = self.skyfire_token
+        if self.base_tx_hash:
+            h["x-base-tx-hash"] = self.base_tx_hash
+        return h
+
+    def _get(self, url: str) -> dict:
+        if _HAS_HTTPX:
+            resp = httpx.get(url, headers=self._headers(), timeout=self.timeout)
+            if resp.status_code == 402:
+                raise PaymentRequired("unknown", "0.01")
+            resp.raise_for_status()
+            return resp.json()
+        else:
+            req = urllib.request.Request(url, headers=self._headers())
+            with urllib.request.urlopen(req, timeout=self.timeout) as r:
+                return json.loads(r.read())
+
+    # ── Public API ─────────────────────────────────────────────────────────────
+
+    def get_node(self, node_id: str, vault: bool = False) -> dict:
+        """
+        Fetch a compliance node by ID.
+
+        Parameters
+        ----------
+        node_id : str
+            The node identifier, e.g. 'gdpr-article-5-data-principles'.
+        vault : bool
+            If True, fetch the full 13-key vault payload (requires payment token).
+            If False (default), fetch the free 6-field discovery record.
+
+        Returns
+        -------
+        dict
+            Node data. Vault nodes include deterministic_workflow,
+            actionable_schema, primary_citations, and all crosswalks.
+        """
+        if vault:
+            url = f"{BIDDA_API_BASE}{VAULT_SUFFIX}/{node_id}.json"
+        else:
+            url = f"{BIDDA_API_BASE}{DISCOVERY_SUFFIX}/{node_id}.json"
+        return self._get(url)
+
+    def search_nodes(self, query: str, pillar: Optional[str] = None) -> list[dict]:
+        """
+        Search the discovery index for nodes matching a query string.
+
+        Parameters
+        ----------
+        query : str
+            Search term (regulation name, keyword, or topic).
+        pillar : str, optional
+            Filter by pillar slug, e.g. 'cybersecurity', 'ai-governance'.
+
+        Returns
+        -------
+        list[dict]
+            Matching discovery-tier node records (6 fields each).
+        """
+        index = self._get(f"{BIDDA_API_BASE}{DISCOVERY_SUFFIX}/index.json")
+        q = query.lower()
+        results = [
+            n for n in index
+            if q in n.get("title", "").lower()
+            or q in n.get("bluf", "").lower()
+            or q in n.get("domain", "").lower()
+        ]
+        if pillar:
+            results = [n for n in results if pillar.lower() in n.get("domain", "").lower()]
+        return results
+
+    def list_pillars(self) -> list[str]:
+        """Return the list of active sovereign pillars."""
+        index = self._get(f"{BIDDA_API_BASE}{DISCOVERY_SUFFIX}/index.json")
+        return sorted({n.get("domain", "") for n in index if n.get("domain")})
+
+    def check_compliance(
+        self,
+        agent_action: str,
+        regulation: Optional[str] = None,
+        vault: bool = False,
+    ) -> dict:
+        """
+        High-level method: find and return the most relevant compliance node
+        for a described agent action.
+
+        Parameters
+        ----------
+        agent_action : str
+            What the agent is about to do, e.g. "process biometric data for access control".
+        regulation : str, optional
+            Narrow to a specific regulation, e.g. "GDPR".
+        vault : bool
+            Whether to return vault-tier data (requires payment token).
+
+        Returns
+        -------
+        dict
+            The most relevant node's data, or an empty dict if nothing matches.
+        """
+        query = f"{agent_action} {regulation or ''}".strip()
+        results = self.search_nodes(query)
+        if not results:
+            return {}
+        best = results[0]
+        if vault:
+            return self.get_node(best["node_id"], vault=True)
+        return best
+
+
+# ── LangChain Tool ─────────────────────────────────────────────────────────────
+
+try:
+    from langchain.tools import BaseTool
+    from pydantic import BaseModel, Field
+
+    class _BiddaInput(BaseModel):
+        query: str = Field(description="Regulation name, keyword, or compliance topic to look up.")
+
+    class BiddaLangChainTool(BaseTool):
+        """
+        LangChain Tool: Bidda Compliance Intelligence
+
+        Gives a LangChain agent access to verified regulatory compliance nodes
+        from bidda.com. Returns source-cited, drift-free legal logic.
+
+        Example:
+            from bidda_shield import BiddaLangChainTool
+            tool = BiddaLangChainTool(skyfire_token="your-jwt")
+        """
+        name:        str = "bidda_compliance"
+        description: str = (
+            "Look up verified compliance intelligence for any regulation, law, or standard. "
+            "Use this tool when you need to know what a regulation requires, "
+            "what the legal obligations are, or which compliance framework applies "
+            "to a specific AI action, data processing activity, or business operation. "
+            "Returns source-cited, drift-free regulatory logic from primary legal instruments. "
+            "Input: a regulation name, keyword, or compliance topic."
+        )
+        args_schema: type[BaseModel] = _BiddaInput
+
+        skyfire_token: Optional[str] = None
+        base_tx_hash:  Optional[str] = None
+
+        def _run(self, query: str) -> str:
+            client  = BiddaShield(skyfire_token=self.skyfire_token, base_tx_hash=self.base_tx_hash)
+            results = client.search_nodes(query)
+            if not results:
+                return f"No compliance nodes found for '{query}'. Try a broader search term."
+            top = results[0]
+            lines = [
+                f"Regulation: {top.get('title', 'Unknown')}",
+                f"Domain: {top.get('domain', 'Unknown')}",
+                f"Summary: {top.get('bluf', 'No summary available.')}",
+                f"Node ID: {top.get('node_id', '')}",
+                f"Full details (paid): https://bidda.com/intelligence/{top.get('node_id', '')}",
+            ]
+            if len(results) > 1:
+                lines.append(f"Related nodes: {', '.join(r['node_id'] for r in results[1:4])}")
+            return "\n".join(lines)
+
+        async def _arun(self, query: str) -> str:
+            return self._run(query)
+
+except ImportError:
+    class BiddaLangChainTool:  # type: ignore
+        """LangChain not installed. Install with: pip install langchain"""
+        def __init__(self, **_):
+            raise ImportError("LangChain not installed. Run: pip install langchain langchain-core")
+
+
+# ── AutoGen Tool ───────────────────────────────────────────────────────────────
+
+class BiddaAutoGenTool:
+    """
+    AutoGen-compatible Bidda compliance tool.
+
+    Registers a function that AutoGen agents can call to look up
+    compliance intelligence.
+
+    Example:
+        import autogen
+        from bidda_shield import BiddaAutoGenTool
+
+        tool = BiddaAutoGenTool()
+        assistant = autogen.AssistantAgent(
+            name="compliance_assistant",
+            llm_config={"functions": [tool.function_schema]},
+        )
+        tool.register(assistant)
+    """
+
+    def __init__(self, skyfire_token: Optional[str] = None):
+        self._client = BiddaShield(skyfire_token=skyfire_token)
+
+    @property
+    def function_schema(self) -> dict:
+        return {
+            "name": "bidda_compliance_lookup",
+            "description": (
+                "Look up verified compliance intelligence for any regulation, law, standard, "
+                "or compliance topic. Returns source-cited legal obligations from primary instruments."
+            ),
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "query": {
+                        "type": "string",
+                        "description": "Regulation name, keyword, or compliance topic.",
+                    }
+                },
+                "required": ["query"],
+            },
+        }
+
+    def execute(self, query: str) -> str:
+        results = self._client.search_nodes(query)
+        if not results:
+            return json.dumps({"error": f"No nodes found for: {query}"})
+        top = results[0]
+        return json.dumps({
+            "title":   top.get("title"),
+            "domain":  top.get("domain"),
+            "bluf":    top.get("bluf"),
+            "node_id": top.get("node_id"),
+            "url":     f"https://bidda.com/intelligence/{top.get('node_id')}",
+            "related": [r["node_id"] for r in results[1:4]],
+        }, indent=2)
+
+    def register(self, agent: Any) -> None:
+        """Register this tool with an AutoGen agent."""
+        try:
+            agent.register_function(
+                function_map={"bidda_compliance_lookup": lambda q: self.execute(q)}
+            )
+        except AttributeError:
+            raise RuntimeError("Agent does not support register_function. Check your AutoGen version.")
+
+
+# ── CrewAI Tool ────────────────────────────────────────────────────────────────
+
+try:
+    from crewai_tools import BaseTool as CrewBaseTool  # type: ignore
+
+    class BiddaCrewAITool(CrewBaseTool):
+        name:        str = "Bidda Compliance Lookup"
+        description: str = (
+            "Look up verified compliance intelligence for any regulation, law, or standard. "
+            "Returns source-cited legal obligations from primary instruments. Zero hallucination."
+        )
+
+        skyfire_token: Optional[str] = None
+
+        def _run(self, query: str) -> str:
+            client  = BiddaShield(skyfire_token=self.skyfire_token)
+            results = client.search_nodes(query)
+            if not results:
+                return f"No nodes found for: {query}"
+            top = results[0]
+            return (
+                f"Regulation: {top.get('title')}\n"
+                f"Domain: {top.get('domain')}\n"
+                f"Summary: {top.get('bluf')}\n"
+                f"Full node: https://bidda.com/intelligence/{top.get('node_id')}\n"
+            )
+
+except ImportError:
+    class BiddaCrewAITool:  # type: ignore
+        """crewai-tools not installed. Install with: pip install crewai-tools"""
+        def __init__(self, **_):
+            raise ImportError("crewai-tools not installed. Run: pip install crewai crewai-tools")