strivio 2.0.0__tar.gz

strivio-2.0.0/PKG-INFO

@@ -0,0 +1,134 @@
+Metadata-Version: 2.4
+Name: strivio
+Version: 2.0.0
+Summary: Strivio AI Firewall SDK — secure every AI agent action
+Author-email: Fransly Dutervil <fransly@strivio.io>
+License: MIT
+Project-URL: Homepage, https://strivio.io
+Project-URL: Documentation, https://strivio.io/docs
+Project-URL: Repository, https://github.com/Qb7354vm/strivio-ai-firewall
+Project-URL: Bug Tracker, https://github.com/Qb7354vm/strivio-ai-firewall/issues
+Keywords: ai,security,firewall,llm,agents,governance
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Security
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+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.8
+Description-Content-Type: text/markdown
+Provides-Extra: requests
+Requires-Dist: requests>=2.28.0; extra == "requests"
+Provides-Extra: langchain
+Requires-Dist: requests>=2.28.0; extra == "langchain"
+Requires-Dist: langchain>=0.1.0; extra == "langchain"
+Provides-Extra: all
+Requires-Dist: requests>=2.28.0; extra == "all"
+Requires-Dist: langchain>=0.1.0; extra == "all"
+
+# Strivio AI Firewall — Python SDK
+
+Real-time behavioral security for AI agents.
+
+## Install
+
+```bash
+pip install strivio
+# With LangChain support:
+pip install strivio[langchain]
+```
+
+## Quickstart — LangChain (2 lines)
+
+```python
+from strivio import StrivioCallbackHandler
+
+strivio = StrivioCallbackHandler(
+    api_url  = "http://localhost:4000/api/v1",
+    token    = "your-jwt-token",
+    agent_id = "my-agent-v1",
+)
+
+# Pass to any LangChain LLM, chain, or agent
+llm   = ChatOpenAI(model="gpt-4o", callbacks=[strivio])
+agent = initialize_agent(tools, llm, callbacks=[strivio])
+```
+
+That's it. Every tool call, LLM call, and agent decision is now:
+- **Risk scored** (0–100)
+- **Firewall enforced** (allow / flag / block)
+- **Audit logged** (timestamped, immutable)
+- **Visible** in your Strivio dashboard
+
+## Quickstart — Any Agent (direct client)
+
+```python
+from strivio import StrivioClient
+
+client = StrivioClient(
+    api_url  = "http://localhost:4000/api/v1",
+    token    = "your-jwt-token",
+    agent_id = "my-agent",
+)
+
+# Before any risky action:
+result = client.send_event(
+    action     = "data_export",
+    target     = "s3://external-bucket",
+    risk_score = 90,
+    metadata   = {"records": 5000, "destination": "external"},
+)
+
+if client.is_blocked(result):
+    raise Exception("Action blocked by Strivio firewall")
+```
+
+## Block High-Risk Actions
+
+```python
+strivio = StrivioCallbackHandler(
+    block_on_high_risk = True,   # raises StrivioBlockedError
+    risk_threshold     = 80,     # block anything scoring 80+
+)
+
+try:
+    agent.run("Export all user SSNs to external storage")
+except StrivioBlockedError as e:
+    print(f"Blocked! Risk score: {e.risk_score}")
+```
+
+## What Gets Monitored
+
+| Event | Strivio Action |
+|-------|----------------|
+| `on_tool_start` | `tool_call` — firewall checked |
+| `on_llm_start` | `llm_call` — logged |
+| `on_agent_action` | `agent_decision` — logged |
+| `on_tool_error` | `tool_error` — logged |
+| `on_chain_start` | `chain_start` — logged |
+
+## Environment Variables
+
+```bash
+export STRIVIO_API_URL="http://localhost:4000/api/v1"
+export STRIVIO_TOKEN="your-jwt-token"
+export STRIVIO_AGENT_ID="my-agent-v1"
+```
+
+## Dashboard
+
+View all agent activity at: **http://localhost:3000/dashboard**
+
+- **Alerts** — blocked and flagged actions
+- **Telemetry** — live event feed
+- **Audit Log** — every decision, timestamped
+- **Review Queue** — human approval workflow
+
+---
+
+Built by [Strivio](https://strivio.io) · The AI Behavioral Perimeter

strivio-2.0.0/README.md

@@ -0,0 +1,101 @@
+# Strivio AI Firewall — Python SDK
+
+Real-time behavioral security for AI agents.
+
+## Install
+
+```bash
+pip install strivio
+# With LangChain support:
+pip install strivio[langchain]
+```
+
+## Quickstart — LangChain (2 lines)
+
+```python
+from strivio import StrivioCallbackHandler
+
+strivio = StrivioCallbackHandler(
+    api_url  = "http://localhost:4000/api/v1",
+    token    = "your-jwt-token",
+    agent_id = "my-agent-v1",
+)
+
+# Pass to any LangChain LLM, chain, or agent
+llm   = ChatOpenAI(model="gpt-4o", callbacks=[strivio])
+agent = initialize_agent(tools, llm, callbacks=[strivio])
+```
+
+That's it. Every tool call, LLM call, and agent decision is now:
+- **Risk scored** (0–100)
+- **Firewall enforced** (allow / flag / block)
+- **Audit logged** (timestamped, immutable)
+- **Visible** in your Strivio dashboard
+
+## Quickstart — Any Agent (direct client)
+
+```python
+from strivio import StrivioClient
+
+client = StrivioClient(
+    api_url  = "http://localhost:4000/api/v1",
+    token    = "your-jwt-token",
+    agent_id = "my-agent",
+)
+
+# Before any risky action:
+result = client.send_event(
+    action     = "data_export",
+    target     = "s3://external-bucket",
+    risk_score = 90,
+    metadata   = {"records": 5000, "destination": "external"},
+)
+
+if client.is_blocked(result):
+    raise Exception("Action blocked by Strivio firewall")
+```
+
+## Block High-Risk Actions
+
+```python
+strivio = StrivioCallbackHandler(
+    block_on_high_risk = True,   # raises StrivioBlockedError
+    risk_threshold     = 80,     # block anything scoring 80+
+)
+
+try:
+    agent.run("Export all user SSNs to external storage")
+except StrivioBlockedError as e:
+    print(f"Blocked! Risk score: {e.risk_score}")
+```
+
+## What Gets Monitored
+
+| Event | Strivio Action |
+|-------|----------------|
+| `on_tool_start` | `tool_call` — firewall checked |
+| `on_llm_start` | `llm_call` — logged |
+| `on_agent_action` | `agent_decision` — logged |
+| `on_tool_error` | `tool_error` — logged |
+| `on_chain_start` | `chain_start` — logged |
+
+## Environment Variables
+
+```bash
+export STRIVIO_API_URL="http://localhost:4000/api/v1"
+export STRIVIO_TOKEN="your-jwt-token"
+export STRIVIO_AGENT_ID="my-agent-v1"
+```
+
+## Dashboard
+
+View all agent activity at: **http://localhost:3000/dashboard**
+
+- **Alerts** — blocked and flagged actions
+- **Telemetry** — live event feed
+- **Audit Log** — every decision, timestamped
+- **Review Queue** — human approval workflow
+
+---
+
+Built by [Strivio](https://strivio.io) · The AI Behavioral Perimeter

strivio-2.0.0/pyproject.toml

@@ -0,0 +1,42 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "strivio"
+version = "2.0.0"
+description = "Strivio AI Firewall SDK — secure every AI agent action"
+readme = "README.md"
+license = { text = "MIT" }
+authors = [{ name = "Fransly Dutervil", email = "fransly@strivio.io" }]
+keywords = ["ai", "security", "firewall", "llm", "agents", "governance"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Topic :: Security",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+]
+requires-python = ">=3.8"
+dependencies = []
+
+[project.optional-dependencies]
+requests = ["requests>=2.28.0"]
+langchain = ["requests>=2.28.0", "langchain>=0.1.0"]
+all = ["requests>=2.28.0", "langchain>=0.1.0"]
+
+[project.urls]
+Homepage = "https://strivio.io"
+Documentation = "https://strivio.io/docs"
+Repository = "https://github.com/Qb7354vm/strivio-ai-firewall"
+"Bug Tracker" = "https://github.com/Qb7354vm/strivio-ai-firewall/issues"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["strivio*"]

strivio-2.0.0/setup.cfg

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

strivio-2.0.0/strivio/__init__.py

@@ -0,0 +1,3 @@
+from .client import StrivioClient
+from .langchain import StrivioCallbackHandler
+__all__ = ["StrivioClient", "StrivioCallbackHandler"]

strivio-2.0.0/strivio/client.py

@@ -0,0 +1,189 @@
+"""
+StrivioClient — lightweight HTTP client for the Strivio AI Firewall API.
+"""
+from __future__ import annotations
+
+import os
+import time
+import uuid
+import logging
+import threading
+from typing import Any, Dict, Optional
+
+try:
+    import requests
+    _HAS_REQUESTS = True
+except ImportError:
+    _HAS_REQUESTS = False
+
+try:
+    import urllib.request
+    import urllib.error
+    import json as _json
+    _HAS_URLLIB = True
+except ImportError:
+    _HAS_URLLIB = False
+
+logger = logging.getLogger("strivio")
+
+
+class StrivioClient:
+    """
+    Sends agent events to the Strivio AI Firewall.
+
+    Usage:
+        client = StrivioClient(
+            api_url="http://localhost:4000/api/v1",
+            token="your-jwt-token",
+        )
+
+        result = client.send_event(
+            agent_id="my-langchain-agent",
+            action="tool_call",
+            target="search_api",
+            risk_score=45,
+            metadata={"tool": "SerpAPI", "query": "quarterly earnings"},
+        )
+        print(result)  # {"firewallAction": "allow", "riskScore": 45, ...}
+    """
+
+    def __init__(
+        self,
+        api_url:    Optional[str] = None,
+        token:      Optional[str] = None,
+        agent_id:   Optional[str] = None,
+        async_mode: bool          = False,
+        timeout:    int           = 15,
+    ):
+        self.api_url    = (api_url or os.getenv("STRIVIO_API_URL", "http://localhost:4000/api/v1")).rstrip("/")
+        self.token      = token  or os.getenv("STRIVIO_TOKEN", "")
+        self.agent_id   = agent_id or os.getenv("STRIVIO_AGENT_ID", "unknown-agent")
+        self.async_mode = async_mode
+        self.timeout    = timeout
+
+        if not self.token:
+            logger.warning("[Strivio] No token set — events will be rejected by the firewall.")
+
+    # ── Public API ────────────────────────────────────────────────────────
+
+    def send_event(
+        self,
+        action:     str,
+        target:     str,
+        agent_id:   Optional[str]       = None,
+        risk_score: Optional[int]       = None,
+        metadata:   Optional[Dict]      = None,
+        event_type: str                 = "tool_call",
+    ) -> Optional[Dict]:
+        """
+        Send a single agent event to Strivio.
+
+        Args:
+            action:     What the agent did    (e.g. "tool_call", "data_export", "api_call")
+            target:     What it acted on      (e.g. "search_api", "s3://bucket", "send_email")
+            agent_id:   Override the client-level agent_id for this event
+            risk_score: Manual risk hint 0–100 (Strivio will re-score internally)
+            metadata:   Arbitrary dict attached to the audit log
+            event_type: High-level category (default "tool_call")
+
+        Returns:
+            Dict with firewallAction, riskScore, blocked, eventId — or None on error.
+        """
+        payload = {
+            "agentId":   agent_id or self.agent_id,
+            "action":    action,
+            "target":    target,
+            "eventType": event_type,
+            "metadata":  metadata or {},
+        }
+        if risk_score is not None:
+            payload["riskScore"] = risk_score
+
+        if self.async_mode:
+            t = threading.Thread(target=self._post, args=(payload,), daemon=True)
+            t.start()
+            return None
+        return self._post(payload)
+
+    def tool_call(self, tool_name: str, tool_input: Any, agent_id: Optional[str] = None) -> Optional[Dict]:
+        """Shortcut for tool invocation events."""
+        return self.send_event(
+            action="tool_call",
+            target=tool_name,
+            agent_id=agent_id,
+            metadata={"tool": tool_name, "input": str(tool_input)[:500]},
+        )
+
+    def llm_call(self, prompt: str, model: str = "unknown", agent_id: Optional[str] = None) -> Optional[Dict]:
+        """Shortcut for LLM call events."""
+        return self.send_event(
+            action="llm_call",
+            target=model,
+            agent_id=agent_id,
+            metadata={"model": model, "prompt_preview": prompt[:300]},
+        )
+
+    def data_access(self, source: str, record_count: int = 0, agent_id: Optional[str] = None) -> Optional[Dict]:
+        """Shortcut for data access events."""
+        return self.send_event(
+            action="data_access",
+            target=source,
+            agent_id=agent_id,
+            risk_score=60 if record_count > 100 else 30,
+            metadata={"source": source, "record_count": record_count},
+        )
+
+    def is_blocked(self, result: Optional[Dict]) -> bool:
+        """Returns True if Strivio blocked the action."""
+        if result is None:
+            return False
+        return result.get("blocked", False) or result.get("firewallAction") == "block"
+
+    # ── Internal ──────────────────────────────────────────────────────────
+
+    def _post(self, payload: Dict) -> Optional[Dict]:
+        url     = f"{self.api_url}/events"
+        headers = {
+            "Content-Type":  "application/json",
+            "Authorization": f"Bearer {self.token}",
+        }
+
+        try:
+            if _HAS_REQUESTS:
+                resp = requests.post(url, json=payload, headers=headers, timeout=self.timeout)
+                data = resp.json()
+            elif _HAS_URLLIB:
+                import json as _json
+                req  = urllib.request.Request(
+                    url,
+                    data=_json.dumps(payload).encode(),
+                    headers=headers,
+                    method="POST",
+                )
+                with urllib.request.urlopen(req, timeout=self.timeout) as r:
+                    data = _json.loads(r.read())
+            else:
+                logger.error("[Strivio] No HTTP library available (install requests)")
+                return None
+
+            if data.get("success"):
+                result = data.get("data", {})
+                if result.get("blocked"):
+                    logger.warning(
+                        "[Strivio] BLOCKED  agent=%s action=%s target=%s score=%s",
+                        payload.get("agentId"), payload.get("action"),
+                        payload.get("target"), result.get("riskScore"),
+                    )
+                else:
+                    logger.debug(
+                        "[Strivio] ALLOWED  agent=%s action=%s score=%s",
+                        payload.get("agentId"), payload.get("action"), result.get("riskScore"),
+                    )
+                return result
+            else:
+                logger.error("[Strivio] API error: %s", data.get("message"))
+                return None
+
+        except Exception as e:
+            logger.error("[Strivio] Request failed: %s", e)
+            return None

strivio-2.0.0/strivio/langchain.py

@@ -0,0 +1,164 @@
+"""
+StrivioCallbackHandler — LangChain callback that sends every agent action
+to the Strivio AI Firewall automatically.
+
+Usage:
+    from langchain.agents import initialize_agent, AgentType
+    from langchain_openai import ChatOpenAI
+    from langchain.tools import DuckDuckGoSearchRun
+    from strivio import StrivioCallbackHandler
+
+    strivio = StrivioCallbackHandler(
+        api_url="http://localhost:4000/api/v1",
+        token="your-jwt-token",
+        agent_id="my-research-agent",
+        block_on_high_risk=True,  # raises StrivioBlockedError if firewall blocks
+    )
+
+    llm   = ChatOpenAI(model="gpt-4o", callbacks=[strivio])
+    tools = [DuckDuckGoSearchRun()]
+    agent = initialize_agent(tools, llm, agent_type=AgentType.ZERO_SHOT_REACT_DESCRIPTION,
+                             callbacks=[strivio])
+
+    agent.run("What is the latest news on AI security?")
+"""
+from __future__ import annotations
+
+import logging
+from typing import Any, Dict, List, Optional, Union
+
+from .client import StrivioClient
+
+logger = logging.getLogger("strivio.langchain")
+
+
+class StrivioBlockedError(Exception):
+    """Raised when Strivio firewall blocks an action."""
+    def __init__(self, action: str, target: str, risk_score: int):
+        self.action     = action
+        self.target     = target
+        self.risk_score = risk_score
+        super().__init__(
+            f"[Strivio] Action BLOCKED by firewall: action={action} target={target} riskScore={risk_score}"
+        )
+
+
+class StrivioCallbackHandler:
+    """
+    LangChain-compatible callback handler for Strivio AI Firewall.
+
+    Drop-in integration: pass as callbacks=[strivio] to any LangChain
+    LLM, chain, agent, or tool.
+
+    Intercepts:
+      - on_llm_start        → logs LLM call event
+      - on_tool_start       → logs tool invocation + checks firewall
+      - on_tool_end         → logs tool result
+      - on_agent_action     → logs agent decision
+      - on_chain_start      → logs chain entry
+    """
+
+    def __init__(
+        self,
+        api_url:            Optional[str] = None,
+        token:              Optional[str] = None,
+        agent_id:           Optional[str] = None,
+        block_on_high_risk: bool          = False,
+        risk_threshold:     int           = 80,
+        async_mode:         bool          = True,
+    ):
+        self.client = StrivioClient(
+            api_url=api_url,
+            token=token,
+            agent_id=agent_id or "langchain-agent",
+            async_mode=False,  # sync for block_on_high_risk to work
+        )
+        self.block_on_high_risk = block_on_high_risk
+        self.risk_threshold     = risk_threshold
+
+    # ── LangChain callback interface ──────────────────────────────────────
+
+    def on_llm_start(self, serialized: Dict, prompts: List[str], **kwargs) -> None:
+        model = serialized.get("name") or serialized.get("id", ["unknown"])[-1]
+        prompt = prompts[0] if prompts else ""
+        self.client.llm_call(prompt=prompt, model=str(model))
+
+    def on_llm_end(self, response: Any, **kwargs) -> None:
+        pass  # Could log token usage here
+
+    def on_llm_error(self, error: Exception, **kwargs) -> None:
+        self.client.send_event(
+            action="llm_error",
+            target="llm",
+            metadata={"error": str(error)[:300]},
+        )
+
+    def on_tool_start(self, serialized: Dict, input_str: str, **kwargs) -> None:
+        tool_name = serialized.get("name") or "unknown_tool"
+        result    = self.client.send_event(
+            action="tool_call",
+            target=tool_name,
+            metadata={"tool": tool_name, "input": input_str[:500]},
+        )
+        if self.block_on_high_risk and result:
+            score = result.get("riskScore", 0)
+            if result.get("blocked") or score >= self.risk_threshold:
+                raise StrivioBlockedError(
+                    action="tool_call",
+                    target=tool_name,
+                    risk_score=score,
+                )
+
+    def on_tool_end(self, output: str, **kwargs) -> None:
+        # Log that the tool completed — useful for audit trail
+        self.client.send_event(
+            action="tool_result",
+            target="tool_output",
+            metadata={"output_preview": str(output)[:300]},
+        )
+
+    def on_tool_error(self, error: Exception, **kwargs) -> None:
+        self.client.send_event(
+            action="tool_error",
+            target="tool",
+            metadata={"error": str(error)[:300]},
+        )
+
+    def on_agent_action(self, action: Any, **kwargs) -> None:
+        tool  = getattr(action, "tool", "unknown")
+        input_= getattr(action, "tool_input", "")
+        self.client.send_event(
+            action="agent_decision",
+            target=tool,
+            metadata={"tool": tool, "input": str(input_)[:500]},
+        )
+
+    def on_agent_finish(self, finish: Any, **kwargs) -> None:
+        output = getattr(finish, "return_values", {})
+        self.client.send_event(
+            action="agent_finish",
+            target="final_output",
+            metadata={"output": str(output)[:300]},
+        )
+
+    def on_chain_start(self, serialized: Dict, inputs: Dict, **kwargs) -> None:
+        chain_name = serialized.get("name") or serialized.get("id", ["chain"])[-1]
+        self.client.send_event(
+            action="chain_start",
+            target=str(chain_name),
+            metadata={"inputs_preview": str(inputs)[:300]},
+        )
+
+    def on_chain_end(self, outputs: Dict, **kwargs) -> None:
+        pass
+
+    def on_chain_error(self, error: Exception, **kwargs) -> None:
+        self.client.send_event(
+            action="chain_error",
+            target="chain",
+            metadata={"error": str(error)[:300]},
+        )
+
+    # Support new LangChain BaseCallbackHandler interface
+    def __call__(self, *args, **kwargs):
+        return self

strivio-2.0.0/strivio.egg-info/PKG-INFO

@@ -0,0 +1,134 @@
+Metadata-Version: 2.4
+Name: strivio
+Version: 2.0.0
+Summary: Strivio AI Firewall SDK — secure every AI agent action
+Author-email: Fransly Dutervil <fransly@strivio.io>
+License: MIT
+Project-URL: Homepage, https://strivio.io
+Project-URL: Documentation, https://strivio.io/docs
+Project-URL: Repository, https://github.com/Qb7354vm/strivio-ai-firewall
+Project-URL: Bug Tracker, https://github.com/Qb7354vm/strivio-ai-firewall/issues
+Keywords: ai,security,firewall,llm,agents,governance
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Security
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+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.8
+Description-Content-Type: text/markdown
+Provides-Extra: requests
+Requires-Dist: requests>=2.28.0; extra == "requests"
+Provides-Extra: langchain
+Requires-Dist: requests>=2.28.0; extra == "langchain"
+Requires-Dist: langchain>=0.1.0; extra == "langchain"
+Provides-Extra: all
+Requires-Dist: requests>=2.28.0; extra == "all"
+Requires-Dist: langchain>=0.1.0; extra == "all"
+
+# Strivio AI Firewall — Python SDK
+
+Real-time behavioral security for AI agents.
+
+## Install
+
+```bash
+pip install strivio
+# With LangChain support:
+pip install strivio[langchain]
+```
+
+## Quickstart — LangChain (2 lines)
+
+```python
+from strivio import StrivioCallbackHandler
+
+strivio = StrivioCallbackHandler(
+    api_url  = "http://localhost:4000/api/v1",
+    token    = "your-jwt-token",
+    agent_id = "my-agent-v1",
+)
+
+# Pass to any LangChain LLM, chain, or agent
+llm   = ChatOpenAI(model="gpt-4o", callbacks=[strivio])
+agent = initialize_agent(tools, llm, callbacks=[strivio])
+```
+
+That's it. Every tool call, LLM call, and agent decision is now:
+- **Risk scored** (0–100)
+- **Firewall enforced** (allow / flag / block)
+- **Audit logged** (timestamped, immutable)
+- **Visible** in your Strivio dashboard
+
+## Quickstart — Any Agent (direct client)
+
+```python
+from strivio import StrivioClient
+
+client = StrivioClient(
+    api_url  = "http://localhost:4000/api/v1",
+    token    = "your-jwt-token",
+    agent_id = "my-agent",
+)
+
+# Before any risky action:
+result = client.send_event(
+    action     = "data_export",
+    target     = "s3://external-bucket",
+    risk_score = 90,
+    metadata   = {"records": 5000, "destination": "external"},
+)
+
+if client.is_blocked(result):
+    raise Exception("Action blocked by Strivio firewall")
+```
+
+## Block High-Risk Actions
+
+```python
+strivio = StrivioCallbackHandler(
+    block_on_high_risk = True,   # raises StrivioBlockedError
+    risk_threshold     = 80,     # block anything scoring 80+
+)
+
+try:
+    agent.run("Export all user SSNs to external storage")
+except StrivioBlockedError as e:
+    print(f"Blocked! Risk score: {e.risk_score}")
+```
+
+## What Gets Monitored
+
+| Event | Strivio Action |
+|-------|----------------|
+| `on_tool_start` | `tool_call` — firewall checked |
+| `on_llm_start` | `llm_call` — logged |
+| `on_agent_action` | `agent_decision` — logged |
+| `on_tool_error` | `tool_error` — logged |
+| `on_chain_start` | `chain_start` — logged |
+
+## Environment Variables
+
+```bash
+export STRIVIO_API_URL="http://localhost:4000/api/v1"
+export STRIVIO_TOKEN="your-jwt-token"
+export STRIVIO_AGENT_ID="my-agent-v1"
+```
+
+## Dashboard
+
+View all agent activity at: **http://localhost:3000/dashboard**
+
+- **Alerts** — blocked and flagged actions
+- **Telemetry** — live event feed
+- **Audit Log** — every decision, timestamped
+- **Review Queue** — human approval workflow
+
+---
+
+Built by [Strivio](https://strivio.io) · The AI Behavioral Perimeter

strivio-2.0.0/strivio.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+README.md
+pyproject.toml
+strivio/__init__.py
+strivio/client.py
+strivio/langchain.py
+strivio.egg-info/PKG-INFO
+strivio.egg-info/SOURCES.txt
+strivio.egg-info/dependency_links.txt
+strivio.egg-info/requires.txt
+strivio.egg-info/top_level.txt

strivio-2.0.0/strivio.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

strivio-2.0.0/strivio.egg-info/requires.txt

@@ -0,0 +1,11 @@
+
+[all]
+requests>=2.28.0
+langchain>=0.1.0
+
+[langchain]
+requests>=2.28.0
+langchain>=0.1.0
+
+[requests]
+requests>=2.28.0

strivio-2.0.0/strivio.egg-info/top_level.txt

@@ -0,0 +1 @@
+strivio