governor-sdk 0.2.0__tar.gz

governor_sdk-0.2.0/PKG-INFO

@@ -0,0 +1,50 @@
+Metadata-Version: 2.4
+Name: governor-sdk
+Version: 0.2.0
+Summary: Python SDK for GovernorAI - The execution boundary for autonomous AI
+Author: GovernorAI Team
+License: Apache-2.0
+Project-URL: Homepage, https://github.com/governor/governor
+Project-URL: Documentation, https://github.com/governor/governor#readme
+Project-URL: Repository, https://github.com/governor/governor.git
+Project-URL: Issues, https://github.com/governor/governor/issues
+Keywords: governor,ai,governance,agent,policy,safety
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software 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
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.28.0
+Provides-Extra: langchain
+Requires-Dist: langchain<2.0.0,>=1.2.0; extra == "langchain"
+Requires-Dist: langchain-core<2.0.0,>=1.2.0; extra == "langchain"
+Provides-Extra: llamaindex
+Requires-Dist: llama-index<0.15.0,>=0.14.0; extra == "llamaindex"
+Provides-Extra: crewai
+Requires-Dist: crewai<0.12.0,>=0.11.0; python_version < "3.14" and extra == "crewai"
+Provides-Extra: langgraph
+Requires-Dist: langgraph<2.0.0,>=1.1.0; extra == "langgraph"
+Requires-Dist: langchain-core<2.0.0,>=1.2.0; extra == "langgraph"
+Provides-Extra: all
+Requires-Dist: langchain<2.0.0,>=1.2.0; extra == "all"
+Requires-Dist: langchain-core<2.0.0,>=1.2.0; extra == "all"
+Requires-Dist: llama-index<0.15.0,>=0.14.0; extra == "all"
+Requires-Dist: crewai<0.12.0,>=0.11.0; python_version < "3.14" and extra == "all"
+Requires-Dist: langgraph<2.0.0,>=1.1.0; extra == "all"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.4.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.1.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.21.0; extra == "dev"
+Requires-Dist: pytest-mock>=3.12.0; extra == "dev"
+Requires-Dist: ruff>=0.1.0; extra == "dev"
+Requires-Dist: black>=23.0.0; extra == "dev"
+Requires-Dist: mypy>=1.7.0; extra == "dev"
+Requires-Dist: types-requests>=2.31.0; extra == "dev"
+Dynamic: requires-python

governor_sdk-0.2.0/governor/__init__.py

@@ -0,0 +1,109 @@
+"""GovernorAI SDK - Python client for GovernorAI AI governance.
+
+Quickstart:
+    pip install governor-sdk
+    export GOVERNOR_URL=https://gateway.governorai.ai
+    export GOVERNOR_API_KEY=gov_xxx
+
+    # One-line governance for any supported framework:
+    from governor import govern
+    governed_agent = govern(your_agent)
+"""
+
+from .client import (
+    AsyncGovernorAIClient,
+    GovernorAIApprovalRequired,
+    GovernorAIClient,
+    GovernorAIDenied,
+    GovernorAIError,
+)
+from .decorator import governed, governed_tool_call
+
+__version__ = "0.2.0"
+__all__ = [
+    "AsyncGovernorAIClient",
+    "GovernorAIClient",
+    "GovernorAIError",
+    "GovernorAIDenied",
+    "GovernorAIApprovalRequired",
+    "governed",
+    "governed_tool_call",
+    "govern",
+]
+
+
+def govern(agent, *, governor_url=None, api_key=None, agent_id=None, namespace="default"):
+    """Universal one-line governance wrapper.
+
+    Auto-detects the framework and wraps the agent/executor with GovernorAI
+    governance. Supports LangChain, CrewAI, LangGraph, and LlamaIndex.
+
+    Args:
+        agent: The agent/executor/crew/engine to govern
+        governor_url: Gateway URL (falls back to GOVERNOR_URL env var)
+        api_key: API key (falls back to GOVERNOR_API_KEY env var)
+        agent_id: Agent identifier (auto-derived if omitted)
+        namespace: Namespace for policy lookup
+
+    Returns:
+        A governed wrapper that intercepts tool calls through GovernorAI.
+
+    Example:
+        from governor import govern
+        governed = govern(your_langchain_executor)
+        result = governed.invoke({"input": "query"})
+    """
+    agent_type = type(agent).__name__
+    module = type(agent).__module__ or ""
+
+    # LangChain AgentExecutor or Runnable
+    if "langchain" in module or agent_type in ("AgentExecutor", "RunnableSequence"):
+        from .integrations.langchain import wrap_agent
+        return wrap_agent(
+            agent,
+            governor_url=governor_url,
+            api_key=api_key,
+            agent_id=agent_id,
+            namespace=namespace,
+        )
+
+    # CrewAI Crew
+    if "crewai" in module or agent_type == "Crew":
+        from .integrations.crewai import GovernorAICrew
+        client = GovernorAIClient(base_url=governor_url, api_key=api_key)
+        return GovernorAICrew(
+            crew=agent,
+            governor_client=client,
+            crew_id=agent_id or "crewai-crew",
+            namespace=namespace,
+        )
+
+    # LangGraph ToolNode
+    if "langgraph" in module or agent_type == "ToolNode":
+        from .integrations.langgraph import GovernedToolNode
+        return GovernedToolNode(
+            tools=getattr(agent, "tools_by_name", {}).values() if hasattr(agent, "tools_by_name") else [],
+            governor_url=governor_url,
+            api_key=api_key,
+            agent_id=agent_id or "langgraph-agent",
+        )
+
+    # LlamaIndex QueryEngine
+    if "llama_index" in module or "llamaindex" in module or "QueryEngine" in agent_type:
+        from .integrations.llamaindex import GovernorAIQueryEngine
+        client = GovernorAIClient(base_url=governor_url, api_key=api_key)
+        return GovernorAIQueryEngine(
+            query_engine=agent,
+            governor_client=client,
+            agent_id=agent_id or "llamaindex-agent",
+            namespace=namespace,
+        )
+
+    raise TypeError(
+        f"Cannot auto-detect framework for {agent_type} from {module}. "
+        f"Use framework-specific wrappers instead:\n"
+        f"  from governor.integrations.langchain import wrap_agent\n"
+        f"  from governor.integrations.crewai import GovernorAICrew\n"
+        f"  from governor.integrations.langgraph import GovernedToolNode\n"
+        f"  from governor.integrations.llamaindex import GovernedQueryEngine"
+    )

governor_sdk-0.2.0/governor/__main__.py

@@ -0,0 +1,4 @@
+"""Allow running GovernorAI CLI as: python -m governor"""
+from .cli import main
+
+main()

governor_sdk-0.2.0/governor/cli.py

@@ -0,0 +1,210 @@
+"""GovernorAI CLI — terminal-first developer experience.
+
+Usage:
+    python -m governor init       # Configure access
+    python -m governor test       # Send a test governed action
+    python -m governor status     # Check connection and policy status
+"""
+
+import argparse
+import json
+import os
+import sys
+from pathlib import Path
+
+from .client import GovernorAIClient, GovernorAIError
+
+
+CONFIG_FILE = ".governor.env"
+ENV_URL = "GOVERNOR_URL"
+ENV_KEY = "GOVERNOR_API_KEY"
+
+
+def get_client():
+    """Create a client from env vars or config file."""
+    url = os.environ.get(ENV_URL)
+    key = os.environ.get(ENV_KEY)
+
+    if not url or not key:
+        # Try .env-style config file (KEY=VALUE format, no YAML dependency)
+        config_path = Path(CONFIG_FILE)
+        if config_path.exists():
+            with open(config_path) as f:
+                for line in f:
+                    line = line.strip()
+                    if line.startswith("#") or "=" not in line:
+                        continue
+                    k, v = line.split("=", 1)
+                    k, v = k.strip(), v.strip()
+                    if k == "GOVERNOR_URL" and not url:
+                        url = v
+                    elif k == "GOVERNOR_API_KEY" and not key:
+                        key = v
+
+    if not url:
+        print(f"Error: Set {ENV_URL} or create {CONFIG_FILE}")
+        sys.exit(1)
+    if not key:
+        print(f"Error: Set {ENV_KEY} or create {CONFIG_FILE}")
+        sys.exit(1)
+
+    return GovernorAIClient(base_url=url, api_key=key)
+
+
+def cmd_init(args):
+    """Configure GovernorAI access."""
+    url = args.url or input(f"GovernorAI Gateway URL [{os.environ.get(ENV_URL, 'https://gateway.governorai.ai')}]: ").strip()
+    if not url:
+        url = os.environ.get(ENV_URL, "https://gateway.governorai.ai")
+
+    key = args.key or input("API Key: ").strip()
+    if not key:
+        print("Error: API key is required.")
+        sys.exit(1)
+
+    # Test connectivity
+    print(f"\nTesting connection to {url}...")
+    client = GovernorAIClient(base_url=url, api_key=key)
+    try:
+        # Try a simple health check or list policies
+        result = client.execute(
+            agent_id="governorai-cli-test",
+            tool="cli.init.ping",
+            args={"purpose": "connectivity_test"},
+        )
+        print(f"✓ Connected! Decision: {result.get('decision', 'ALLOW')}")
+    except GovernorAIError as e:
+        # Even a DENY is a successful connection
+        if "denied" in str(e).lower() or "blocked" in str(e).lower():
+            print(f"✓ Connected! (Policy denied test action — governance is working)")
+        else:
+            print(f"✗ Connection failed: {e}")
+            sys.exit(1)
+    except Exception as e:
+        print(f"✗ Connection failed: {e}")
+        sys.exit(1)
+
+    # Save config (.env format — no YAML dependency)
+    print(f"\nSaving to {CONFIG_FILE}...")
+    with open(CONFIG_FILE, "w") as f:
+        f.write(f"# GovernorAI configuration\n")
+        f.write(f"GOVERNOR_URL={url}\n")
+        f.write(f"GOVERNOR_API_KEY={key}\n")
+    print(f"✓ Config saved to {CONFIG_FILE}")
+    print(f"\nYou can also set environment variables:")
+    print(f"  export {ENV_URL}={url}")
+    print(f"  export {ENV_KEY}={key}")
+
+
+def cmd_test(args):
+    """Send a test governed action."""
+    client = get_client()
+    agent_id = args.agent or "cli-test-agent"
+    tool = args.tool or "cli.test.action"
+    raw_args = args.args
+
+    test_args = {}
+    if raw_args:
+        try:
+            test_args = json.loads(raw_args)
+        except json.JSONDecodeError:
+            print(f"Error: --args must be valid JSON, got: {raw_args}")
+            sys.exit(1)
+    else:
+        # Default test payload that should trigger a deny with the starter policy
+        test_args = {
+            "destination_external": True,
+            "contains_pii": True,
+            "payload_preview": "Test PII data",
+        }
+
+    print(f"Sending governed action...")
+    print(f"  Agent:  {agent_id}")
+    print(f"  Tool:   {tool}")
+    print(f"  Args:   {json.dumps(test_args, indent=2)}")
+    print()
+
+    try:
+        result = client.execute(
+            agent_id=agent_id,
+            tool=tool,
+            args=test_args,
+        )
+        decision = result.get("decision", "UNKNOWN")
+        reason = result.get("reason", "")
+        latency = result.get("latency_ms", "?")
+
+        if decision == "ALLOW":
+            print(f"  ✓ Decision: ALLOW")
+        elif decision == "DENY":
+            print(f"  ✗ Decision: DENY")
+        else:
+            print(f"  ⚡ Decision: {decision}")
+
+        if reason:
+            print(f"  Reason:  {reason}")
+        print(f"  Latency: {latency}ms")
+        print(f"\nView in dashboard → Events page")
+
+    except GovernorAIError as e:
+        print(f"  ✗ Error: {e}")
+        sys.exit(1)
+
+
+def cmd_status(args):
+    """Check connection and governance status."""
+    client = get_client()
+
+    print(f"GovernorAI Status")
+    print(f"  URL: {client.base_url}")
+    print(f"  Key: {client.api_key[:10]}..." if client.api_key else "  Key: not set")
+    print()
+
+    # Test connectivity
+    try:
+        result = client.execute(
+            agent_id="governorai-cli-status",
+            tool="cli.status.ping",
+            args={"purpose": "status_check"},
+        )
+        print(f"  Connection: ✓ OK")
+        print(f"  Decision:   {result.get('decision', 'ALLOW')}")
+    except GovernorAIError as e:
+        if "denied" in str(e).lower():
+            print(f"  Connection: ✓ OK (policy active)")
+        else:
+            print(f"  Connection: ✗ Failed ({e})")
+    except Exception as e:
+        print(f"  Connection: ✗ Failed ({e})")
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        prog="governorai",
+        description="GovernorAI CLI — AI governance from your terminal",
+    )
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    # init
+    init_parser = subparsers.add_parser("init", help="Configure GovernorAI access")
+    init_parser.add_argument("--url", help="Gateway URL")
+    init_parser.add_argument("--key", help="API key")
+    init_parser.set_defaults(func=cmd_init)
+
+    # test
+    test_parser = subparsers.add_parser("test", help="Send a test governed action")
+    test_parser.add_argument("--agent", help="Agent ID (default: cli-test-agent)")
+    test_parser.add_argument("--tool", help="Tool name (default: cli.test.action)")
+    test_parser.add_argument("--args", help="JSON args (default: PII test payload)")
+    test_parser.set_defaults(func=cmd_test)
+
+    # status
+    status_parser = subparsers.add_parser("status", help="Check connection status")
+    status_parser.set_defaults(func=cmd_status)
+
+    args = parser.parse_args()
+    args.func(args)
+
+
+if __name__ == "__main__":
+    main()