radhiops 0.0.1__py3-none-any.whl

radhiops/__init__.py

@@ -0,0 +1,59 @@
+"""RadhiOps — BYOE AI Engineering Platform SDK."""
+
+from __future__ import annotations
+
+__version__ = "0.0.1"
+
+from .client import RadhiOps
+from .exceptions import (
+    AgentError,
+    AuthError,
+    InsufficientCreditsError,
+    ProviderError,
+    RadhiOpsError,
+    SubscriptionRequiredError,
+)
+from .plans import PLANS, Plan, upgrade_hint
+from .orchestrator import AutonomyMode, Orchestrator
+from .providers import (
+    ChatResult,
+    Message,
+    ModelProvider,
+    available_providers,
+    get_provider,
+    register_provider,
+)
+from .deploy import (
+    Deployment,
+    DeployStatus,
+    available_deploy_providers,
+    get_deploy_provider,
+    register_deploy_provider,
+)
+
+__all__ = [
+    "__version__",
+    "RadhiOps",
+    "RadhiOpsError",
+    "AuthError",
+    "AgentError",
+    "ProviderError",
+    "InsufficientCreditsError",
+    "SubscriptionRequiredError",
+    "PLANS",
+    "Plan",
+    "upgrade_hint",
+    "AutonomyMode",
+    "Orchestrator",
+    "ChatResult",
+    "Message",
+    "ModelProvider",
+    "available_providers",
+    "get_provider",
+    "register_provider",
+    "Deployment",
+    "DeployStatus",
+    "available_deploy_providers",
+    "get_deploy_provider",
+    "register_deploy_provider",
+]

radhiops/agents/__init__.py

@@ -0,0 +1,19 @@
+"""RadhiOps agents."""
+
+from __future__ import annotations
+
+from .base import Agent
+from .cyberdefense import CyberDefenseAgent
+from .deployment import DeploymentAgent
+from .monitor import RuntimeMonitor
+from .repo import RepoAgent
+from .soc import RadhiSOC
+
+__all__ = [
+    "Agent",
+    "RadhiSOC",
+    "RepoAgent",
+    "DeploymentAgent",
+    "RuntimeMonitor",
+    "CyberDefenseAgent",
+]

radhiops/agents/base.py

@@ -0,0 +1,52 @@
+"""Base class shared by every RadhiOps agent.
+
+An agent is given:
+  - a reference to the :class:`RadhiOps` client (for credits/auth/telemetry)
+  - an optional BYOE model provider (the user's own model)
+
+Agents expose high-level capabilities (audit, deploy, monitor, ...). Each
+capability that consumes platform resources reports its credit cost through
+``self._charge(...)`` so usage stays transparent.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from ..providers.base import Message, ModelProvider
+
+if TYPE_CHECKING:
+    from ..client import RadhiOps
+
+
+class Agent:
+    #: Human-facing name, e.g. "RadhiSOC".
+    name: str = "Agent"
+
+    def __init__(self, client: "RadhiOps", model: ModelProvider | None = None) -> None:
+        self.client = client
+        self._model = model
+
+    @property
+    def model(self) -> ModelProvider:
+        """The BYOE model bound to this agent (falls back to the client default)."""
+        m = self._model or self.client.default_model
+        if m is None:
+            from ..exceptions import ProviderError
+
+            raise ProviderError(
+                f"{self.name} needs a model. Pass model=... or set a default "
+                "provider/model on the RadhiOps client."
+            )
+        return m
+
+    def _ask(self, system: str, user: str, **opts: Any) -> str:
+        """Convenience: single-turn prompt to the bound model."""
+        result = self.model.chat(
+            [Message("system", system), Message("user", user)], **opts
+        )
+        return result.text
+
+    def _charge(self, credits: int, action: str) -> None:
+        """Record credit usage for an action via the client."""
+        self.client._consume_credits(credits, f"{self.name}:{action}")

radhiops/agents/cyberdefense.py

@@ -0,0 +1,134 @@
+"""Cyber Defense Agent — runtime attack detection & response.
+
+Feed inbound requests through ``inspect`` (or wire ``middleware`` into your web
+framework). The engine combines payload signatures (SQLi, XSS, SSRF, traversal,
+command injection, header injection) with behavioral detection (brute force,
+credential stuffing, rate abuse, DDoS) into an allow/challenge/block verdict and
+maintains an auto-blocklist.
+
+Escalation routing:
+  * Code-level vulns (injection/XSS/...) -> RadhiSOC, to fix the underlying code.
+  * Volumetric/behavioral attacks (DDoS/brute force) -> handled here (block).
+"""
+
+from __future__ import annotations
+
+import time
+from typing import Any, Callable
+
+from ..defense.engine import DefenseConfig, DefenseEngine, Verdict
+from ..defense.request import Request
+from ..monitor.incident import Incident, security_incident
+from .base import Agent
+
+# Detection/behavior types that indicate a code weakness RadhiSOC should fix.
+_CODE_LEVEL = {
+    "sql_injection", "xss", "ssrf", "command_injection",
+    "path_traversal", "header_injection",
+}
+
+_EXPLAIN_SYSTEM = (
+    "You are RadhiOps' security analyst. Given a blocked HTTP request and the "
+    "detections that triggered it, explain the attack in two sentences and state "
+    "what code-level fix prevents it. Be concrete and avoid scaremongering."
+)
+
+
+class CyberDefenseAgent(Agent):
+    name = "CyberDefenseAgent"
+
+    def __init__(
+        self,
+        client,
+        model=None,
+        *,
+        config: DefenseConfig | None = None,
+        now: Callable[[], float] = time.time,
+    ) -> None:
+        super().__init__(client, model)
+        self.engine = DefenseEngine(config, now=now)
+        self._seen: set[tuple[str, str]] = set()  # (ip, attack_type) de-dupe per session
+        self._stats = {"analyzed": 0, "challenged": 0, "blocked": 0, "incidents": 0}
+
+    # ----- core ----------------------------------------------------------
+    def analyze(self, request: Request | dict[str, Any]) -> Verdict:
+        """Return a verdict for one request. Cheap — no credits (high volume)."""
+        req = request if isinstance(request, Request) else Request.from_dict(request)
+        verdict = self.engine.analyze(req)
+        self._stats["analyzed"] += 1
+        if verdict.action == "challenge":
+            self._stats["challenged"] += 1
+        elif verdict.action == "block":
+            self._stats["blocked"] += 1
+        return verdict
+
+    def inspect(self, request: Request | dict[str, Any]) -> tuple[Verdict, Incident | None]:
+        """Analyze and, for serious activity, raise a (deduped) incident."""
+        verdict = self.analyze(request)
+        incident = self._maybe_incident(verdict)
+        return verdict, incident
+
+    def _maybe_incident(self, verdict: Verdict) -> Incident | None:
+        # An already-blocklisted IP is handled — don't keep raising incidents.
+        if verdict.reason == "ip_blocklisted":
+            return None
+        serious = verdict.blocked or any(
+            d.severity in ("high", "critical") for d in verdict.detections
+        ) or any(b.severity in ("high", "critical") for b in verdict.behaviors)
+        if not serious:
+            return None
+
+        types = {d.type for d in verdict.detections} | {b.type for b in verdict.behaviors}
+        primary = next(iter(sorted(types)), "security_event")
+        key = (verdict.ip, primary)
+        if key in self._seen:
+            return None
+        self._seen.add(key)
+
+        self._charge(1, "incident")
+        self._stats["incidents"] += 1
+        code_level = bool(types & _CODE_LEVEL)
+        return security_incident(
+            target=verdict.ip,
+            summary=f"{verdict.action.upper()} {verdict.ip}: {', '.join(sorted(types))}.",
+            severity="critical" if verdict.blocked else "high",
+            escalate_to="RadhiSOC" if code_level else "CyberDefenseAgent",
+            detail=verdict.to_dict(),
+        )
+
+    # ----- blocklist controls -------------------------------------------
+    def block(self, ip: str) -> None:
+        self.engine.block_ip(ip)
+
+    def unblock(self, ip: str) -> None:
+        self.engine.unblock_ip(ip)
+
+    @property
+    def blocklist(self) -> set[str]:
+        return self.engine.blocklist
+
+    def stats(self) -> dict:
+        return {**self._stats, "blocklist_size": len(self.engine.blocklist)}
+
+    # ----- AI explanation -----------------------------------------------
+    def explain(self, verdict: Verdict) -> str:
+        if not verdict.detections and not verdict.behaviors:
+            return "No attack detected; nothing to explain."
+        self._charge(2, "explain")
+        payload = verdict.to_dict()
+        return self._ask(_EXPLAIN_SYSTEM, str(payload))
+
+    # ----- framework integration ----------------------------------------
+    def middleware(self, on_block: Callable[[Verdict], Any] | None = None):
+        """Build a WSGI-ish guard: returns a callable(request_dict) -> Verdict.
+
+        Wire this into your framework's request hook; if the verdict is a block,
+        return your 403 response (optionally via ``on_block``).
+        """
+        def guard(request: dict[str, Any]) -> Verdict:
+            verdict, _ = self.inspect(request)
+            if verdict.blocked and on_block:
+                on_block(verdict)
+            return verdict
+
+        return guard

radhiops/agents/deployment.py

@@ -0,0 +1,132 @@
+"""Deployment Agent — deploy orchestration + log monitoring + failure diagnosis.
+
+    dep = ops.deploy("vercel", token="...", team_id="...")
+    d = dep.trigger()                       # kick a deployment
+    final = dep.watch(d.id)                 # poll until ready/failed
+    if final.status.failed:
+        print(dep.diagnose(d.id))           # rule-based + AI explanation
+
+BYOE: the developer brings the platform token; RadhiOps never stores it.
+"""
+
+from __future__ import annotations
+
+import time
+from dataclasses import dataclass, field
+from typing import Any, Callable
+
+from ..deploy.base import Deployment, DeployProvider, LogLine
+from ..deploy.diagnose import diagnose_logs
+from ..deploy.registry import get_deploy_provider
+from .base import Agent
+
+_DIAGNOSE_SYSTEM = (
+    "You are RadhiOps' deployment SRE. Given build/deploy logs that the "
+    "rule-based checker could not classify, identify the most likely root cause "
+    "in one or two sentences and give a concrete fix. Be specific; don't guess "
+    "wildly. If the logs are inconclusive, say so."
+)
+
+
+@dataclass
+class DeployDiagnosis:
+    deployment_id: str
+    status: str
+    rule_based: dict
+    ai_explanation: str | None = None
+    log_tail: list[str] = field(default_factory=list)
+
+    def to_dict(self) -> dict:
+        return {
+            "deployment_id": self.deployment_id,
+            "status": self.status,
+            "rule_based": self.rule_based,
+            "ai_explanation": self.ai_explanation,
+            "log_tail": self.log_tail,
+        }
+
+
+class DeploymentAgent(Agent):
+    name = "DeploymentAgent"
+
+    def __init__(
+        self,
+        client,
+        provider: str | DeployProvider,
+        model=None,
+        *,
+        token: str | None = None,
+        sleep: Callable[[float], None] = time.sleep,
+        **provider_options: Any,
+    ) -> None:
+        super().__init__(client, model)
+        if isinstance(provider, DeployProvider):
+            self.provider = provider
+        else:
+            self.provider = get_deploy_provider(provider, token=token, **provider_options)
+        self._sleep = sleep
+
+    # ----- operations ----------------------------------------------------
+    def trigger(self, **opts: Any) -> Deployment:
+        self._charge(5, "deploy")
+        return self.provider.trigger_deploy(**opts)
+
+    def status(self, deployment_id: str) -> Deployment:
+        return self.provider.get_deployment(deployment_id)  # read: no charge
+
+    def logs(self, deployment_id: str, **opts: Any) -> list[LogLine]:
+        return self.provider.get_logs(deployment_id, **opts)  # read: no charge
+
+    def list(self, *, limit: int = 10, **opts: Any) -> list[Deployment]:
+        return self.provider.list_deployments(limit=limit, **opts)
+
+    def watch(
+        self,
+        deployment_id: str,
+        *,
+        interval: float = 5.0,
+        timeout: float = 600.0,
+        on_update: Callable[[Deployment], None] | None = None,
+    ) -> Deployment:
+        """Poll a deployment until it reaches a terminal state or times out."""
+        self._charge(2, "watch")
+        waited = 0.0
+        last: Deployment | None = None
+        while waited <= timeout:
+            last = self.provider.get_deployment(deployment_id)
+            if on_update:
+                on_update(last)
+            if last.status.is_terminal:
+                return last
+            self._sleep(interval)
+            waited += interval
+        return last or self.provider.get_deployment(deployment_id)
+
+    def diagnose(self, deployment_id: str, *, use_ai: bool = True) -> DeployDiagnosis:
+        """Diagnose a (usually failed) deployment from its logs."""
+        self._charge(3, "diagnose")
+        dep = self.provider.get_deployment(deployment_id)
+        logs = self.provider.get_logs(deployment_id)
+        tail = [str(line) for line in logs[-50:]]
+
+        rule = diagnose_logs(logs)
+        ai_text: str | None = None
+        if use_ai and not rule.matched and self._model is not None and tail:
+            self._charge(2, "diagnose_ai")
+            ai_text = self._ask(_DIAGNOSE_SYSTEM, "\n".join(tail))
+
+        return DeployDiagnosis(
+            deployment_id=deployment_id,
+            status=dep.status.value,
+            rule_based=rule.to_dict(),
+            ai_explanation=ai_text,
+            log_tail=tail,
+        )
+
+    def deploy_and_watch(self, *, on_update=None, interval: float = 5.0, **opts: Any):
+        """Convenience: trigger a deploy and watch it to completion, returning
+        the final deployment and (if it failed) a diagnosis."""
+        dep = self.trigger(**opts)
+        final = self.watch(dep.id, interval=interval, on_update=on_update)
+        diagnosis = self.diagnose(final.id) if final.status.failed else None
+        return final, diagnosis

radhiops/agents/monitor.py

@@ -0,0 +1,169 @@
+"""Runtime Monitor — production health, anomalies, crashes, and escalation.
+
+    mon = ops.monitor()
+    mon.add_target("api", "https://myapp.com/health")
+
+    # one cycle: probe every target, fold into metric windows
+    results = mon.poll()
+
+    # evaluate the rolling windows for anomalies -> incidents
+    incidents = mon.evaluate()
+    for inc in incidents:
+        print(inc.summary, "->", inc.escalate_to)
+
+    # crash detection from a log stream
+    mon.ingest_logs("api", ["Traceback (most recent call last):", "MemoryError"])
+
+A monitoring session escalates issues by handing structured Incidents to an
+``on_incident`` callback (and, in the upcoming autonomous loop, straight to the
+Deployment or Cyber-Defense agents).
+"""
+
+from __future__ import annotations
+
+import time
+from dataclasses import dataclass, field
+from typing import Any, Callable
+
+from ..monitor.anomaly import Thresholds, detect
+from ..monitor.crash import detect_crash
+from ..monitor.health import HealthProbe, HealthResult
+from ..monitor.incident import Incident, crash_incident, from_anomaly
+from ..monitor.metrics import MetricWindow, Sample
+from .base import Agent
+
+
+@dataclass
+class Target:
+    name: str
+    url: str
+    expect_status: int | tuple[int, ...] = 200
+    contains: str | None = None
+    window: MetricWindow = field(default_factory=lambda: MetricWindow("unset"))
+
+
+class RuntimeMonitor(Agent):
+    name = "RuntimeMonitor"
+
+    def __init__(
+        self,
+        client,
+        model=None,
+        *,
+        thresholds: Thresholds | None = None,
+        window_size: int = 100,
+        sleep: Callable[[float], None] = time.sleep,
+        transport: Any = None,
+        timeout: float = 10.0,
+    ) -> None:
+        super().__init__(client, model)
+        self.thresholds = thresholds or Thresholds()
+        self._window_size = window_size
+        self._sleep = sleep
+        self._probe = HealthProbe(timeout=timeout, transport=transport)
+        self.targets: dict[str, Target] = {}
+        # De-dupe repeat incidents within a session by (type, target).
+        self._open_incidents: dict[tuple[str, str], Incident] = {}
+
+    # ----- target management --------------------------------------------
+    def add_target(
+        self,
+        name: str,
+        url: str,
+        *,
+        expect_status: int | tuple[int, ...] = 200,
+        contains: str | None = None,
+    ) -> None:
+        self.targets[name] = Target(
+            name=name, url=url, expect_status=expect_status, contains=contains,
+            window=MetricWindow(name, maxlen=self._window_size),
+        )
+
+    # ----- probing -------------------------------------------------------
+    def poll(self) -> list[HealthResult]:
+        """Probe every target once and fold the result into its window."""
+        results: list[HealthResult] = []
+        for tgt in self.targets.values():
+            res = self._probe.check(
+                tgt.name, tgt.url, expect_status=tgt.expect_status, contains=tgt.contains
+            )
+            tgt.window.add(Sample(ok=res.ok, latency_ms=res.latency_ms, timestamp=res.timestamp))
+            results.append(res)
+        return results
+
+    # ----- analysis ------------------------------------------------------
+    def evaluate(self) -> list[Incident]:
+        """Run anomaly detection across all windows and return new incidents."""
+        incidents: list[Incident] = []
+        for tgt in self.targets.values():
+            for anomaly in detect(tgt.window, self.thresholds):
+                key = (anomaly.type, anomaly.target)
+                if key in self._open_incidents:
+                    continue  # already escalated this session
+                inc = from_anomaly(anomaly)
+                self._open_incidents[key] = inc
+                incidents.append(inc)
+        if incidents:
+            self._charge(1, "incident")
+        return incidents
+
+    def ingest_logs(self, target: str, logs: list[str], **_: Any) -> Incident | None:
+        """Scan a log stream for crash signatures; return an incident if found."""
+        signal = detect_crash(logs)
+        if not signal.detected:
+            return None
+        key = ("crash", target)
+        if key in self._open_incidents:
+            return self._open_incidents[key]
+        self._charge(1, "crash_detected")
+        inc = crash_incident(
+            target,
+            f"Crash detected on {target}: {signal.category}.",
+            detail={"category": signal.category, "evidence": signal.evidence},
+        )
+        self._open_incidents[key] = inc
+        return inc
+
+    def summary(self) -> dict:
+        return {name: t.window.summary() for name, t in self.targets.items()}
+
+    # ----- session loop --------------------------------------------------
+    def watch(
+        self,
+        *,
+        rounds: int = 0,
+        interval: float = 30.0,
+        timeout: float | None = None,
+        on_incident: Callable[[Incident], None] | None = None,
+        on_poll: Callable[[list[HealthResult]], None] | None = None,
+    ) -> list[Incident]:
+        """Run a monitoring loop.
+
+        Stops after ``rounds`` polls (if > 0) or after ``timeout`` seconds.
+        Calls ``on_incident`` for every new incident as it's raised.
+        """
+        if not self.targets:
+            from ..exceptions import AgentError
+
+            raise AgentError("No targets to monitor. Call add_target() first.")
+        self._charge(2, "watch")
+        all_incidents: list[Incident] = []
+        waited = 0.0
+        count = 0
+        while True:
+            results = self.poll()
+            if on_poll:
+                on_poll(results)
+            new = self.evaluate()
+            for inc in new:
+                all_incidents.append(inc)
+                if on_incident:
+                    on_incident(inc)
+            count += 1
+            if rounds and count >= rounds:
+                break
+            if timeout is not None and waited >= timeout:
+                break
+            self._sleep(interval)
+            waited += interval
+        return all_incidents