intutic-clawde 1.8.0__tar.gz

intutic_clawde-1.8.0/PKG-INFO

@@ -0,0 +1,21 @@
+Metadata-Version: 2.4
+Name: intutic-clawde
+Version: 1.8.0
+Summary: Programmatic proxy connection wrappers and warm-path budget gates for Intutic
+Author: Intutic
+Author-email: engineering@intutic.ai
+Requires-Python: >=3.10,<4.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Dist: requests (>=2.33.0,<3.0.0)
+Requires-Dist: urllib3 (>=2.7.0)
+Description-Content-Type: text/markdown
+
+# intutic-clawde
+
+Python SDK for Intutic Agentic AI Governance proxy wrappers.
+

intutic_clawde-1.8.0/README.md

@@ -0,0 +1,3 @@
+# intutic-clawde
+
+Python SDK for Intutic Agentic AI Governance proxy wrappers.

intutic_clawde-1.8.0/intutic_clawde/__init__.py

@@ -0,0 +1,4 @@
+from .client import ClawdeClient
+from .errors import ClawdeError, ClawdeConnectionError, ClawdeVerdictError
+
+__all__ = ["ClawdeClient", "ClawdeError", "ClawdeConnectionError", "ClawdeVerdictError"]

intutic_clawde-1.8.0/intutic_clawde/budget_checker.py

@@ -0,0 +1,42 @@
+import time
+import requests
+from typing import Dict, Any, Optional
+from .errors import ClawdeConnectionError
+
+class BudgetChecker:
+    def __init__(self, base_url: str, api_key: str):
+        self.base_url = base_url
+        self.api_key = api_key
+        self.cache: Dict[str, Dict[str, Any]] = {}
+        self.cache_ttl = 30.0 # 30s TTL
+
+    def check_budget(self, model: str, estimated_tokens: int) -> Dict[str, Any]:
+        cache_key = f"{model}:{estimated_tokens}"
+        now = time.time()
+        cached = self.cache.get(cache_key)
+        
+        if cached and (now - cached["timestamp"]) < self.cache_ttl:
+            return cached["result"]
+            
+        try:
+            url = f"{self.base_url}/v1/budget/check"
+            params = {"model": model, "estimated_tokens": str(estimated_tokens)}
+            headers = {
+                "Authorization": f"Bearer {self.api_key}",
+                "Accept": "application/json",
+            }
+            res = requests.get(url, params=params, headers=headers, timeout=5.0)
+            if res.status_code != 200:
+                raise Exception(f"Budget check returned status {res.status_code}")
+            result = res.json()
+            self.cache[cache_key] = {"result": result, "timestamp": now}
+            return result
+        except Exception as e:
+            raise ClawdeConnectionError(f"Could not reach budget check endpoint: {str(e)}")
+
+    def update_cached_budget(self, model: str, estimated_tokens: int, remaining_usd: float, allowed: bool) -> None:
+        cache_key = f"{model}:{estimated_tokens}"
+        self.cache[cache_key] = {
+            "result": {"allowed": allowed, "remaining_usd": remaining_usd},
+            "timestamp": time.time(),
+        }

intutic_clawde-1.8.0/intutic_clawde/circuit_breaker.py

@@ -0,0 +1,45 @@
+import os
+from typing import Callable, Any, Optional, TypeVar
+from .errors import ClawdeVerdictError
+
+T = TypeVar('T')
+
+class CircuitBreaker:
+    def __init__(self, client: Any):
+        self.client = client
+
+    def wrap(self, tool_name: str, max_cost_usd: Optional[float] = None, fail_open: bool = False) -> Callable[[Callable[[], T]], T]:
+        def decorator(fn: Callable[[], T]) -> T:
+            # 1. Pre-Check: Context & pre-flight budget validation
+            try:
+                if max_cost_usd is not None:
+                    budget = self.client.check_budget("default", 1)
+                    if not budget.get("allowed", True):
+                        raise ClawdeVerdictError(
+                            "kill", 
+                            f"Circuit breaker tripped for tool '{tool_name}': budget exceeded. Remaining: ${budget.get('remaining_usd')}"
+                        )
+            except Exception as e:
+                if not fail_open:
+                    raise e
+                if os.environ.get("INTUTIC_DEBUG") == "true":
+                    print(f"[Clawde SDK] Circuit breaker pre-check failed (failing open): {str(e)}")
+                    
+            # 2. Execute the function
+            try:
+                result = fn()
+                
+                # 3. Post-Check: If the result is a dict with verdict key, inspect it
+                if isinstance(result, dict) and result.get("verdict") == "kill":
+                    raise ClawdeVerdictError("kill", "Execution blocked by governance policy (Verdict: KILL)")
+                    
+                return result
+            except Exception as e:
+                if isinstance(e, ClawdeVerdictError) and not fail_open:
+                    raise e
+                if not fail_open:
+                    raise e
+                if os.environ.get("INTUTIC_DEBUG") == "true":
+                    print(f"[Clawde SDK] Circuit breaker execution failed (failing open): {str(e)}")
+                return None # type: ignore
+        return decorator # type: ignore

intutic_clawde-1.8.0/intutic_clawde/client.py

@@ -0,0 +1,138 @@
+import os
+import time
+import requests
+import json
+from typing import List, Dict, Any, Callable, Optional, Union
+from .errors import ClawdeConnectionError, ClawdeVerdictError
+from .context_resolver import resolve_context
+from .budget_checker import BudgetChecker
+from .circuit_breaker import CircuitBreaker
+
+class ClawdeClient:
+    def __init__(
+        self, 
+        api_key: str, 
+        base_url: Optional[str] = None, 
+        provider: Optional[str] = None, 
+        auto_context: bool = True, 
+        timeout: float = 30.0, 
+        retries: int = 2
+    ):
+        if not api_key:
+            raise ValueError("API key is required to initialize ClawdeClient.")
+        self.api_key = api_key
+        self.base_url = base_url or os.environ.get("INTUTIC_BASE_URL") or "http://localhost:4000"
+        self.provider = provider
+        self.auto_context = auto_context
+        self.timeout = timeout
+        self.retries = retries
+        
+        self.budget_checker = BudgetChecker(self.base_url, self.api_key)
+        self.circuit_breaker_wrapper = CircuitBreaker(self)
+        self.listeners: Dict[str, List[Callable[[Dict[str, Any]], None]]] = {
+            "hijack": [], "enhance": [], "kill": [], "bypass": []
+        }
+
+    def on(self, event: str, callback: Callable[[Dict[str, Any]], None]) -> None:
+        if event in self.listeners:
+            self.listeners[event].append(callback)
+
+    def off(self, event: str, callback: Callable[[Dict[str, Any]], None]) -> None:
+        if event in self.listeners and callback in self.listeners[event]:
+            self.listeners[event].remove(callback)
+
+    def emit(self, event: str, payload: Dict[str, Any]) -> None:
+        if event in self.listeners:
+            for cb in self.listeners[event]:
+                try:
+                    cb(payload)
+                except Exception:
+                    pass
+
+    def check_budget(self, model: str, estimated_tokens: int) -> Dict[str, Any]:
+        return self.budget_checker.check_budget(model, estimated_tokens)
+
+    def resolve_context(self) -> Dict[str, Any]:
+        if not self.auto_context:
+            return {}
+        return resolve_context()
+
+    def circuit_breaker(self, tool_name: str, max_cost_usd: Optional[float] = None, fail_open: bool = False) -> Callable[[Callable[[], Any]], Any]:
+        return self.circuit_breaker_wrapper.wrap(tool_name, max_cost_usd, fail_open)
+
+    def chat(self, model: str, messages: List[Dict[str, str]], **kwargs: Any) -> Dict[str, Any]:
+        # 1. Resolve context
+        context = self.resolve_context()
+        
+        # 2. Prepare payload
+        request_payload = {
+            "model": model,
+            "messages": messages,
+            **kwargs
+        }
+        
+        # 3. Request logic with retries
+        max_attempts = self.retries + 1
+        last_error = None
+        
+        for attempt in range(1, max_attempts + 1):
+            try:
+                headers = {
+                    "Content-Type": "application/json",
+                    "Authorization": f"Bearer {self.api_key}",
+                    "X-Intutic-Context": json.dumps(context),
+                }
+                
+                if "max_cost_usd" in kwargs:
+                    headers["X-Intutic-Cost-Limit"] = str(kwargs["max_cost_usd"])
+                if "sensitivity_tier" in kwargs:
+                    headers["X-Intutic-Sensitivity"] = str(kwargs["sensitivity_tier"])
+                    
+                url = f"{self.base_url}/v1/chat/completions"
+                res = requests.post(url, json=request_payload, headers=headers, timeout=self.timeout)
+                
+                if res.status_code != 200:
+                    raise Exception(f"HTTP error {res.status_code}: {res.text}")
+                    
+                result = res.json()
+                
+                # Extract headers
+                verdict = res.headers.get("x-intutic-verdict", "allow")
+                remaining = res.headers.get("x-intutic-budget-remaining")
+                pct = res.headers.get("x-intutic-budget-pct")
+                
+                result["verdict"] = verdict
+                if remaining:
+                    result["budget_remaining_usd"] = float(remaining)
+                if pct:
+                    result["budget_pct_used"] = float(pct)
+                    
+                # Update budget cache
+                if "budget_remaining_usd" in result:
+                    self.budget_checker.update_cached_budget(
+                        model,
+                        len(messages),
+                        result["budget_remaining_usd"],
+                        verdict != "kill"
+                    )
+                    
+                # Emit events
+                if verdict and verdict != "allow":
+                    self.emit(verdict, result)
+                    
+                # Enforcement check
+                if verdict == "kill":
+                    raise ClawdeVerdictError("kill", "Request blocked by policy (Verdict: KILL)")
+                    
+                return result
+            except Exception as e:
+                last_error = e
+                if isinstance(e, ClawdeVerdictError):
+                    raise e
+                if attempt < max_attempts:
+                    if os.environ.get("INTUTIC_DEBUG") == "true":
+                        print(f"[Clawde SDK] Attempt {attempt} failed, retrying... Error: {str(e)}")
+                    time.sleep(attempt * 0.1)
+                    continue
+                    
+        raise ClawdeConnectionError(f"Request failed after {max_attempts} attempts. Last error: {str(last_error)}")

intutic_clawde-1.8.0/intutic_clawde/context_resolver.py

@@ -0,0 +1,36 @@
+import os
+import json
+from pathlib import Path
+from typing import Dict, Any
+
+def resolve_context() -> Dict[str, Any]:
+    config_path = Path.home() / ".intutic" / "config.json"
+    
+    # 1. Primary: Read from sync-daemon config
+    if config_path.exists():
+        try:
+            with open(config_path, "r", encoding="utf-8") as f:
+                config = json.load(f)
+                return {
+                    "gitBranch": config.get("gitBranch"),
+                    "jiraTicket": config.get("jiraTicket"),
+                    "pagerdutyIncident": config.get("pagerdutyIncident"),
+                    "ciPipeline": config.get("ciPipeline"),
+                    "workingDirectory": config.get("workingDirectory", os.getcwd()),
+                    "workspaceId": config.get("workspaceId"),
+                    "sessionId": config.get("sessionId"),
+                }
+        except Exception:
+            pass
+            
+    # 2. Fallback: Environment variables
+    return {
+        "workspaceId": os.environ.get("INTUTIC_WORKSPACE_ID"),
+        "sessionId": os.environ.get("INTUTIC_SESSION_ID"),
+        "gitBranch": os.environ.get("GIT_BRANCH"),
+        "ciPipeline": os.environ.get("GITHUB_RUN_ID") 
+            or os.environ.get("BUILDKITE_BUILD_ID") 
+            or os.environ.get("CIRCLE_BUILD_NUM"),
+        "pagerdutyIncident": os.environ.get("PD_INCIDENT_ID"),
+        "workingDirectory": os.getcwd(),
+    }

intutic_clawde-1.8.0/intutic_clawde/errors.py

@@ -0,0 +1,13 @@
+class ClawdeError(Exception):
+    """Base exception for intutic-clawde SDK."""
+    pass
+
+class ClawdeConnectionError(ClawdeError):
+    """Raised when the SDK cannot reach the Intutic proxy."""
+    pass
+
+class ClawdeVerdictError(ClawdeError):
+    """Raised when the Intutic proxy returns a blocked verdict (KILL)."""
+    def __init__(self, verdict: str, message: str):
+        super().__init__(message)
+        self.verdict = verdict

intutic_clawde-1.8.0/intutic_clawde/types.py

@@ -0,0 +1,38 @@
+from typing import TypedDict, List, Dict, Any, Optional
+
+class ClawdeClientOptions(TypedDict, total=False):
+    api_key: str
+    base_url: Optional[str]
+    provider: Optional[str]
+    auto_context: Optional[bool]
+    timeout: Optional[float]
+    retries: Optional[int]
+
+class ChatMessage(TypedDict):
+    role: str
+    content: str
+
+class ChatParams(TypedDict, total=False):
+    model: str
+    messages: List[ChatMessage]
+    temperature: Optional[float]
+    max_cost_usd: Optional[float]
+    sensitivity_tier: Optional[str]
+
+class ChatResponse(Dict[str, Any]):
+    verdict: Optional[str]
+    budget_remaining_usd: Optional[float]
+    budget_pct_used: Optional[float]
+
+class ResolvedContext(TypedDict, total=False):
+    gitBranch: Optional[str]
+    jiraTicket: Optional[str]
+    pagerdutyIncident: Optional[str]
+    ciPipeline: Optional[str]
+    workingDirectory: Optional[str]
+    workspaceId: Optional[str]
+    sessionId: Optional[str]
+
+class BudgetCheckResult(TypedDict):
+    allowed: bool
+    remaining_usd: float

intutic_clawde-1.8.0/pyproject.toml

@@ -0,0 +1,21 @@
+[tool.poetry]
+name = "intutic-clawde"
+version = "1.8.0"
+description = "Programmatic proxy connection wrappers and warm-path budget gates for Intutic"
+authors = ["Intutic <engineering@intutic.ai>"]
+readme = "README.md"
+packages = [{include = "intutic_clawde"}]
+
+[tool.poetry.dependencies]
+# 3.9 reached end of life in October 2025. The patched releases of requests and
+# urllib3 below both require >=3.10, so supporting 3.9 means shipping known CVEs.
+python = "^3.10"
+requests = "^2.33.0"
+urllib3 = ">=2.7.0"
+
+[tool.poetry.group.dev.dependencies]
+pytest = "^9.0.3"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"