v1.0.0

.dockerignore

@@ -0,0 +1,6 @@
+.venv
+.env
+__pycache__
+.pytest_cache
+*.pyc
+.git

.gitignore

@@ -0,0 +1,207 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[codz]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py.cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+#poetry.toml
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#   pdm recommends including project-wide configuration in pdm.toml, but excluding .pdm-python.
+#   https://pdm-project.org/en/latest/usage/project/#working-with-version-control
+#pdm.lock
+#pdm.toml
+.pdm-python
+.pdm-build/
+
+# pixi
+#   Similar to Pipfile.lock, it is generally recommended to include pixi.lock in version control.
+#pixi.lock
+#   Pixi creates a virtual environment in the .pixi directory, just like venv module creates one
+#   in the .venv directory. It is recommended not to include this directory in version control.
+.pixi
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.envrc
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+# Abstra
+# Abstra is an AI-powered process automation framework.
+# Ignore directories containing user credentials, local state, and settings.
+# Learn more at https://abstra.io/docs
+.abstra/
+
+# Visual Studio Code
+#  Visual Studio Code specific template is maintained in a separate VisualStudioCode.gitignore 
+#  that can be found at https://github.com/github/gitignore/blob/main/Global/VisualStudioCode.gitignore
+#  and can be added to the global gitignore or merged into this file. However, if you prefer, 
+#  you could uncomment the following to ignore the entire vscode folder
+# .vscode/
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc
+
+# Cursor
+#  Cursor is an AI-powered code editor. `.cursorignore` specifies files/directories to
+#  exclude from AI features like autocomplete and code analysis. Recommended for sensitive data
+#  refer to https://docs.cursor.com/context/ignore-files
+.cursorignore
+.cursorindexingignore
+
+# Marimo
+marimo/_static/
+marimo/_lsp/
+__marimo__/

Dockerfile

@@ -0,0 +1,27 @@
+# ─── SRE Incident Response Environment ───────────────────────────────────────
+# Based on openenv-base for the Meta OpenEnv framework.
+# Optimised for HF Spaces CPU Basic tier (2 vCPUs, 8 GB RAM).
+# ──────────────────────────────────────────────────────────────────────────────
+
+FROM python:3.11-slim
+
+WORKDIR /app
+
+# Install curl for the Docker HEALTHCHECK
+RUN apt-get update && apt-get install -y curl && rm -rf /var/lib/apt/lists/*
+
+# Copy environment code
+COPY . .
+
+# Install server dependencies
+RUN pip install --no-cache-dir -r server/requirements.txt
+
+# Expose the default OpenEnv port
+EXPOSE 8000
+
+# Docker HEALTHCHECK (every 30 s, 5 s timeout, 3 retries)
+HEALTHCHECK --interval=30s --timeout=5s --retries=3 \
+    CMD curl -f http://localhost:8000/health || exit 1
+
+# Start uvicorn bound to all interfaces
+CMD ["uvicorn", "server.app:app", "--host", "0.0.0.0", "--port", "8000"]

LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2026 Jay Prajapati
+Copyright (c) 2026 Jay
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

README.md

@@ -0,0 +1,103 @@
+# 🛡️ Sentinel-SRE-OpenEnv: Autonomous Incident Response
+[![Python 3.11+](https://img.shields.io/badge/python-3.11+-blue.svg)](https://www.python.org/downloads/release/python-3110/)
+[![Framework: OpenEnv](https://img.shields.io/badge/Meta Framework-OpenEnv Core-purple.svg)](https://github.com/facebookresearch/openenv)
+[![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](LICENSE)
+[![Linting: Ruff](https://img.shields.io/badge/Linting-Ruff-orange.svg)](https://github.com/astral-sh/ruff)
+
+A production-grade Site Reliability Engineering (SRE) Reinforcement Learning environment built on the **Meta OpenEnv** framework. 
+
+**Sentinel-SRE** simulates catastrophic infrastructure failures to evaluate LLM agents on their ability to act as autonomous SREs. It features a dense reward system, multiple static incident tiers, and a first-of-its-kind **Dynamic Chaos Generator**.
+
+---
+
+## 🏗️ Architecture
+
+The repository adheres to Meta's RFC-004 standard for distributed AI environments.
+
+```mermaid
+graph TD
+    A[LLM Inference Agent] -->|JSON Actions| B(FastAPI Server)
+    B -->|HTTPEnvServer Validator| C{SRE Environment}
+    C -->|Simulated Side Effects| D[State Mutator]
+    D -->|Continuous Grades| E(SREGraderRubric)
+    E -->|Observations + Metrics| A
+```
+
+---
+
+## 🔥 Incident Topology (Tiers)
+
+The environment challenges the agent with escalating scenarios:
+
+| Difficulty | Incident Scenario | Primary Diagnostic Tool | Grader Metric |
+|---|---|---|---|
+| 🟢 **Easy** | **OOMKilled Pod Alert** | `diagnose` | Restored cluster uptime. |
+| 🟡 **Medium** | **High DB Latency (12,000ms)** | `run_sql` | Database latency reduction. |
+| 🔴 **Hard** | **Sudden Traffic Spike (10×)** | `scale_servers` | Time to absorb traffic (Budget: $500). |
+| 💀 **Extreme** | **Bad Code Deployment** | `rollback` | Total resolution step/time. |
+| 🧠 **Dynamic** | **User-Defined SRE Incident** | *Matches Archetype* | *Matches Archetype* |
+
+### 🧠 Featured: Dynamic Chaos Generator (Option 5)
+Leverage an **SRE Incident Router** (LLM) to classify free-text natural language prompts into solvable incident archetypes. Submit any problem (e.g., *"My checkout service is timing out due to slow database queries"*) and the environment will dynamically generate matching logs and descriptions while maintaining mathematical evaluation integrity.
+
+---
+
+## 🚀 Getting Started
+
+### 1. Prerequisites
+We use [`uv`](https://docs.astral.sh/uv/) for incredibly fast dependency management.
+```bash
+# Install environment & dependencies
+uv sync
+```
+
+### 2. Local Server Deployment
+Start the OpenEnv FastAPI layer:
+```bash
+uv run server/app.py
+```
+*The server is now listening for OpenEnv schema actions on `http://localhost:8000`.*
+
+### 3. Run the Sentinel-SRE Agent
+To test the environment natively, run the interactive inference script:
+```bash
+# Set your API key
+export HF_TOKEN="your_key"
+
+# Execute the agent loop
+uv run sre_env/inference.py
+```
+
+---
+
+## 🛠️ Testing & Linting
+
+### Automated Validation (Tests)
+Ensure the environment math is sound before submission:
+```bash
+# Execute the core test suite (Windows PowerShell)
+$env:PYTHONPATH="."; uv run pytest sre_env/tests/
+
+# Execute the core test suite (Linux/MacOS)
+PYTHONPATH=. uv run pytest sre_env/tests/
+```
+
+### Quality Assurance (Linting)
+Sentinel-SRE is built with industrial-grade linting standards:
+```bash
+# Scan for errors
+uv run ruff check .
+
+# Auto-format codebase
+uv run ruff format .
+```
+
+---
+
+## ⚖️ Evaluation & Grading
+The `SREGraderRubric` computes continuous floats `[0.0, 1.0]` based on:
+1. **Resolution Speed:** Rewards the fastest fix.
+2. **Budget Efficiency:** Penalties for wasteful cloud spending.
+3. **Collateral Damage:** Severe penalties for terminating healthy services or executing rogue production SQL without cause.
+
+Built for the 2026 OpenEnv AI Hackathon.

openenv.yaml

@@ -0,0 +1,37 @@
+# ─── SRE Incident Response Environment — OpenEnv Manifest ─────────────────────
+# Targets Hugging Face Spaces "CPU Basic" tier (2 vCPUs, 8 GB RAM).
+# ──────────────────────────────────────────────────────────────────────────────
+
+name: sentinel-sre-agent
+version: "1.0.0"
+description: >
+  Autonomous SRE incident response RL environment.
+  Simulates three stratified scenarios — pod crash recovery (easy),
+  database index optimisation (medium), and dynamic server scaling under
+  a strict budget (hard) — with proportional grading and dense rewards.
+
+hardware:
+  tier: cpu-basic
+  max_vcpus: 2
+  max_ram_gb: 8
+
+server:
+  port: 8000
+  dockerfile: Dockerfile
+
+tasks:
+  - name: pod-restart
+    difficulty: easy
+    description: Parse alert logs and restart the failing pod to restore uptime.
+
+  - name: db-index-optimisation
+    difficulty: medium
+    description: Query slow-log, identify missing index, and execute optimisation SQL.
+
+  - name: dynamic-scaling
+    difficulty: hard
+    description: Provision servers to absorb 10× traffic spike within a $500 budget.
+
+  - name: bad-deployment-rollback
+    difficulty: extreme
+    description: Diagnose cascading 500 errors from auth-service, check deployment logs, and execute a rollback to the stable revision.

pyproject.toml

@@ -0,0 +1,33 @@
+[project]
+name = "sentinel-sre"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.11"
+license = "MIT"
+dependencies = [
+    "huggingface-hub>=1.8.0",
+    "openenv-core>=0.2.2",
+    "fastapi>=0.100.0",
+    "uvicorn>=0.22.0",
+    "requests>=2.31.0",
+    "rich>=13.0.0",
+    "python-dotenv>=1.0.0",
+]
+
+[tool.uv]
+package = false
+
+[dependency-groups]
+dev = [
+    "ruff>=0.15.9",
+    "pytest>=8.0.0",
+]
+
+[tool.ruff]
+line-length = 120
+target-version = "py311"
+
+[tool.ruff.lint]
+select = ["E", "F", "I"]
+ignore = ["E501"] # Ignore long lines for SRE logs and prompts

server/api/routes/environment.py

@@ -0,0 +1,23 @@
+from fastapi import APIRouter
+from openenv.core.env_server.http_server import StepResponse
+
+from server.core.deps import env_instance
+from server.schemas.reset import CustomResetRequest
+
+router = APIRouter()
+
+
+@router.post("/custom_reset")
+def custom_reset(payload: CustomResetRequest):
+    """Custom endpoint to inject dynamically generated incident contexts."""
+    obs = env_instance.reset(seed=payload.seed)
+
+    # Override the static archetype text with the LLM's dynamic flavor
+    env_instance._state.task_description = payload.custom_description
+
+    # Refresh observation to reflect overrides
+    obs = env_instance._make_observation(
+        message=f"🚨 Custom Incident Registered! {payload.custom_description}", logs=payload.custom_logs, success=True
+    )
+
+    return StepResponse(observation=obs.model_dump(), reward=obs.reward, done=obs.done)

server/app.py

@@ -0,0 +1,28 @@
+import uvicorn
+from fastapi import FastAPI
+from fastapi.responses import JSONResponse
+
+from server.api.routes import environment
+from server.core.deps import env_server
+
+app = FastAPI(
+    title="SRE Incident Response Environment",
+    description="OpenEnv RL environment simulating autonomous SRE incident response.",
+    version="1.0.0",
+)
+
+# Standard endpoints (OpenEnv framework)
+env_server.register_routes(app)
+
+# Custom extensions
+app.include_router(environment.router, tags=["SRE Chaos"])
+
+
+@app.get("/health", tags=["Utilities"])
+async def health() -> JSONResponse:
+    """Return 200 OK for container health checks."""
+    return JSONResponse(content={"status": "ok"}, status_code=200)
+
+
+if __name__ == "__main__":
+    uvicorn.run("server.app:app", host="0.0.0.0", port=8000)

server/core/deps.py

@@ -0,0 +1,12 @@
+from openenv.core.env_server.http_server import HTTPEnvServer
+
+from server.environment import SREEnvironment
+from sre_env.models import SREAction, SREObservation
+
+env_instance = SREEnvironment()
+
+env_server = HTTPEnvServer(
+    env=lambda: env_instance,
+    action_cls=SREAction,
+    observation_cls=SREObservation,
+)

server/environment.py

@@ -0,0 +1,769 @@
+from __future__ import annotations
+
+import random
+import uuid
+from typing import Any, Optional
+
+from openenv.core.env_server.interfaces import Environment
+
+from server.rubrics import SREGraderRubric
+from sre_env.models import (
+    CommandType,
+    SREAction,
+    SREObservation,
+    SREState,
+    SystemMetrics,
+    TaskDifficulty,
+)
+
+TASK_CONFIGS = {
+    TaskDifficulty.EASY: {
+        "description": (
+            "INCIDENT: Pod 'pod-web-3' in the 'production' namespace is crash-looping. "
+            "Alerts indicate OOMKilled errors. Parse the alert logs, identify the failing "
+            "pod, and execute a restart to restore service uptime."
+        ),
+        "max_steps": 15,
+        "failing_pod": "pod-web-3",
+        "initial_uptime": 0.45,
+        "budget": 500.0,
+    },
+    TaskDifficulty.MEDIUM: {
+        "description": (
+            "INCIDENT: The 'orders' API is responding with P99 latency of 12,000 ms "
+            "(threshold: 200 ms). The slow-query log points to a full table scan on "
+            "'orders_table'. Diagnose the issue, find the missing index, and execute "
+            "the optimisation SQL command."
+        ),
+        "max_steps": 20,
+        "slow_table": "orders_table",
+        "missing_index_column": "customer_id",
+        "initial_latency_ms": 12000.0,
+        "target_latency_ms": 200.0,
+        "initial_uptime": 0.70,
+        "budget": 500.0,
+    },
+    TaskDifficulty.HARD: {
+        "description": (
+            "INCIDENT: Traffic spike detected - incoming requests jumped 10× to "
+            "50,000 RPS. Current capacity can handle 5,000 RPS. You must dynamically "
+            "scale servers to absorb the load WITHOUT exceeding a strict $500 cloud "
+            "budget. Each additional server costs $50/unit and adds 5,000 RPS capacity."
+        ),
+        "max_steps": 30,
+        "current_rps": 50000,
+        "capacity_per_server": 5000,
+        "cost_per_server": 50.0,
+        "initial_servers": 1,
+        "initial_uptime": 0.10,
+        "budget": 500.0,
+    },
+    TaskDifficulty.EXTREME: {
+        "description": (
+            "INCIDENT: A new deployment of 'auth-service' has resulted in "
+            "cascading 500 errors and user lockouts. Diagnose the issue, check "
+            "the deployment logs, and execute a rollback to the stable revision."
+        ),
+        "max_steps": 25,
+        "buggy_deployment": "auth-service",
+        "stable_revision": "v1.4.2",
+        "initial_uptime": 0.05,
+        "budget": 500.0,
+    },
+}
+
+
+class SREEnvironment(Environment[SREAction, SREObservation, SREState]):
+    """Autonomous SRE incident-response RL environment.
+
+    Supports three stratified tasks:
+      • Easy  - restart a crash-looping pod
+      • Medium - find and fix a missing DB index
+      • Hard  - scale servers under budget constraints
+    """
+
+    def __init__(self, **kwargs: Any) -> None:
+        super().__init__(**kwargs)
+        self._state = SREState()
+        self._rng = random.Random()
+        self.rubric = SREGraderRubric(self)
+
+        # Internal simulation variables (not exposed in State)
+        self._pod_restarted: bool = False
+        self._index_added: bool = False
+        self._servers_added: int = 0
+        self._diagnosed: bool = False
+        self._diagnosis_target: str = ""
+        self._current_latency_ms: float = 0.0
+        self._current_servers: int = 1
+        self._current_capacity_rps: int = 5000
+        self._catastrophic: bool = False
+        self._logs_checked: bool = False
+        self._rolled_back: bool = False
+
+    def reset(
+        self,
+        seed: Optional[int] = None,
+        episode_id: Optional[str] = None,
+        **kwargs: Any,
+    ) -> SREObservation:
+        """Reset the environment and select a new incident scenario."""
+
+        if seed is not None:
+            self._rng = random.Random(seed)
+        else:
+            self._rng = random.Random()
+
+        difficulty = self._rng.choice(list(TaskDifficulty))
+        config = TASK_CONFIGS[difficulty]
+
+        self._state = SREState(
+            episode_id=episode_id or str(uuid.uuid4()),
+            step_count=0,
+            task_difficulty=difficulty,
+            task_description=config["description"],
+            current_uptime=config["initial_uptime"],
+            budget_remaining=config["budget"],
+            max_steps=config["max_steps"],
+            incident_resolved=False,
+            root_cause_found=False,
+            total_reward=0.0,
+        )
+
+        # Reset internal sim variables
+        self._pod_restarted = False
+        self._index_added = False
+        self._servers_added = 0
+        self._diagnosed = False
+        self._diagnosis_target = ""
+        self._catastrophic = False
+        self._logs_checked = False
+        self._rolled_back = False
+
+        if difficulty == TaskDifficulty.MEDIUM:
+            self._current_latency_ms = config["initial_latency_ms"]
+        else:
+            self._current_latency_ms = 50.0  # healthy baseline
+
+        if difficulty == TaskDifficulty.HARD:
+            self._current_servers = config["initial_servers"]
+            self._current_capacity_rps = self._current_servers * config["capacity_per_server"]
+        else:
+            self._current_servers = 1
+            self._current_capacity_rps = 5000
+
+        return self._make_observation(
+            message=f"🚨 New incident assigned ({difficulty.value} difficulty). {config['description']}",
+            logs=self._generate_initial_logs(difficulty),
+            success=True,
+        )
+
+    def step(
+        self,
+        action: SREAction,
+        timeout_s: Optional[float] = None,
+        **kwargs: Any,
+    ) -> SREObservation:
+        """Execute one SRE action and return observation + dense reward."""
+
+        self._state.step_count += 1
+        difficulty = self._state.task_difficulty
+
+        # ── compute reward components ────────────────────────────────
+        progress_reward = 0.0
+        constraint_penalty = 0.0
+        time_penalty = -0.05  # constant per-step cost
+
+        message = ""
+        logs: list[str] = []
+        success = False
+
+        # ── validate action against dynamic rules ─────────────────────
+        valid_actions = self._get_available_actions()
+        if action.command_type not in valid_actions:
+            self._state.total_reward += time_penalty - 0.1
+            return self._make_observation(
+                message=f"❌ Action '{action.command_type}' is invalid or not currently available. Available: {', '.join(valid_actions)}",
+                logs=["[ERROR] Action rejected by environment schema."],
+                success=False,
+                reward=time_penalty - 0.1,
+                done=False,
+            )
+
+        cmd = CommandType(action.command_type)
+
+        if difficulty == TaskDifficulty.EASY:
+            progress_reward, message, logs, success = self._step_easy(action, cmd)
+        elif difficulty == TaskDifficulty.MEDIUM:
+            progress_reward, message, logs, success = self._step_medium(action, cmd)
+        elif difficulty == TaskDifficulty.HARD:
+            progress_reward, message, logs, success, constraint_penalty = self._step_hard(action, cmd)
+        elif difficulty == TaskDifficulty.EXTREME:
+            progress_reward, message, logs, success, constraint_penalty = self._step_extreme(action, cmd)
+
+        if cmd == CommandType.RESTART_POD and difficulty != TaskDifficulty.EASY:
+            constraint_penalty += -0.8
+            message += " ⚠️ Restarting a healthy pod caused a service disruption!"
+            self._state.current_uptime = max(0.0, self._state.current_uptime - 0.15)
+            self._catastrophic = True
+
+        if cmd == CommandType.RUN_SQL and difficulty != TaskDifficulty.MEDIUM and action.target_resource != "":
+            constraint_penalty += -0.4
+            message += " ⚠️ Running SQL on a production database without cause is risky."
+
+        step_reward = progress_reward + time_penalty + constraint_penalty
+        self._state.total_reward += step_reward
+
+        done = False
+        if self._state.incident_resolved:
+            done = True
+            message += " ✅ Incident fully resolved!"
+        elif self._state.step_count >= self._state.max_steps:
+            done = True
+            message += " ⏰ Max steps reached - episode terminated."
+        elif self._state.budget_remaining <= 0:
+            done = True
+            message += " 💸 Budget exhausted - episode terminated."
+        elif self._catastrophic and self._state.current_uptime <= 0.0:
+            done = True
+            message += " 💀 Catastrophic failure - all services down."
+
+        return self._make_observation(
+            message=message,
+            logs=logs,
+            success=success,
+            reward=step_reward,
+            done=done,
+        )
+
+    @property
+    def state(self) -> SREState:
+        """Return the current internal state."""
+        return self._state
+
+    def _step_easy(self, action: SREAction, cmd: CommandType) -> tuple[float, str, list[str], bool]:
+        """Easy: restart the correct crash-looping pod."""
+        config = TASK_CONFIGS[TaskDifficulty.EASY]
+        reward = 0.0
+        logs: list[str] = []
+
+        if cmd == CommandType.DIAGNOSE:
+            if not self._diagnosed:
+                self._diagnosed = True
+                self._diagnosis_target = action.target_resource
+                reward = 0.15
+                logs = [
+                    "[DIAG] Scanning pods in 'production' namespace...",
+                    "[DIAG] pod-web-1: Running (healthy)",
+                    "[DIAG] pod-web-2: Running (healthy)",
+                    "[DIAG] pod-web-3: CrashLoopBackOff (OOMKilled, 12 restarts)",
+                    "[DIAG] pod-web-4: Running (healthy)",
+                    "[DIAG] Root cause: pod-web-3 exceeding memory limits.",
+                ]
+                self._state.root_cause_found = True
+                return (
+                    reward,
+                    "Diagnosis complete. pod-web-3 identified as failing.",
+                    logs,
+                    True,
+                )
+            else:
+                return (
+                    0.0,
+                    "Already diagnosed. Consider taking corrective action.",
+                    logs,
+                    False,
+                )
+
+        elif cmd == CommandType.RESTART_POD:
+            if action.target_resource == config["failing_pod"]:
+                self._pod_restarted = True
+                self._state.current_uptime = min(1.0, self._state.current_uptime + 0.50)
+                if self._diagnosed:
+                    reward = 0.40
+                else:
+                    reward = 0.25  # less reward if you skipped diagnosis
+                if self._state.current_uptime >= 0.95:
+                    self._state.incident_resolved = True
+                logs = [
+                    "[K8S] kubectl rollout restart deployment/web -n production",
+                    "[K8S] pod-web-3 terminated.",
+                    "[K8S] pod-web-3-new: Running (healthy)",
+                    f"[METRICS] Uptime restored to {self._state.current_uptime:.0%}",
+                ]
+                return (
+                    reward,
+                    f"Pod '{action.target_resource}' restarted successfully.",
+                    logs,
+                    True,
+                )
+            else:
+                reward = -0.3
+                logs = [
+                    f"[K8S] pod '{action.target_resource}' not found or already healthy.",
+                ]
+                return (
+                    reward,
+                    f"Wrong pod targeted. '{action.target_resource}' is not the failing pod.",
+                    logs,
+                    False,
+                )
+
+        elif cmd == CommandType.NOOP:
+            self._state.current_uptime = max(0.0, self._state.current_uptime - 0.03)
+            logs = [f"[METRICS] Uptime degraded to {self._state.current_uptime:.0%} (no action taken)."]
+            return 0.0, "No action taken. Service continues to degrade.", logs, False
+
+        else:
+            return (
+                0.0,
+                f"Command '{action.command_type.value}' is not effective for this incident.",
+                [],
+                False,
+            )
+
+    def _step_medium(self, action: SREAction, cmd: CommandType) -> tuple[float, str, list[str], bool]:
+        """Medium: find missing DB index and execute optimisation SQL."""
+        config = TASK_CONFIGS[TaskDifficulty.MEDIUM]
+        reward = 0.0
+        logs: list[str] = []
+
+        if cmd == CommandType.DIAGNOSE:
+            if not self._diagnosed:
+                self._diagnosed = True
+                reward = 0.15
+                logs = [
+                    "[DB] Querying slow_log for queries > 1000ms...",
+                    "[DB] SELECT * FROM orders_table WHERE customer_id = ? - avg 11,800 ms (FULL TABLE SCAN)",
+                    "[DB] EXPLAIN shows: type=ALL, rows=2,400,000, no index on 'customer_id'",
+                    "[DB] Recommendation: CREATE INDEX idx_customer_id ON orders_table(customer_id)",
+                ]
+                self._state.root_cause_found = True
+                return (
+                    reward,
+                    "Slow query identified. Missing index on orders_table.customer_id.",
+                    logs,
+                    True,
+                )
+            else:
+                return 0.0, "Already diagnosed. Apply the SQL optimisation.", [], False
+
+        elif cmd == CommandType.RUN_SQL:
+            target = action.target_resource.lower()
+            sql_param = action.parameters.get("sql", "").lower()
+
+            # Check if the agent is creating the right index
+            is_correct_table = config["slow_table"] in target or config["slow_table"] in sql_param
+            is_correct_column = config["missing_index_column"] in sql_param or config["missing_index_column"] in target
+            has_create_index = "create index" in sql_param or "create index" in target
+
+            if has_create_index and is_correct_table and is_correct_column:
+                self._index_added = True
+                old_latency = self._current_latency_ms
+                self._current_latency_ms = 45.0  # excellent after indexing
+                self._state.current_uptime = min(1.0, self._state.current_uptime + 0.30)
+
+                if self._diagnosed:
+                    reward = 0.40
+                else:
+                    reward = 0.25
+
+                if self._current_latency_ms <= config["target_latency_ms"]:
+                    self._state.incident_resolved = True
+
+                logs = [
+                    "[DB] Executing: CREATE INDEX idx_customer_id ON orders_table(customer_id);",
+                    "[DB] Index created successfully. Build time: 12.3s",
+                    f"[DB] P99 latency dropped from {old_latency:.0f}ms to {self._current_latency_ms:.0f}ms",
+                    f"[METRICS] Uptime improved to {self._state.current_uptime:.0%}",
+                ]
+                return (
+                    reward,
+                    "Index created. Query performance dramatically improved.",
+                    logs,
+                    True,
+                )
+
+            elif has_create_index and is_correct_table and not is_correct_column:
+                # Partial credit - right table, wrong column
+                self._current_latency_ms *= 0.6
+                self._state.current_uptime = min(1.0, self._state.current_uptime + 0.10)
+                reward = 0.10
+                logs = [
+                    "[DB] Index created on different column. Partial improvement.",
+                    f"[DB] P99 latency: {self._current_latency_ms:.0f}ms (still above threshold).",
+                ]
+                return (
+                    reward,
+                    "Index created but on wrong column. Partial improvement.",
+                    logs,
+                    True,
+                )
+
+            else:
+                reward = -0.1
+                logs = ["[DB] SQL executed but had no meaningful effect on performance."]
+                return (
+                    reward,
+                    "SQL command did not address the root cause.",
+                    logs,
+                    False,
+                )
+
+        elif cmd == CommandType.NOOP:
+            self._current_latency_ms *= 1.05  # latency slowly worsens
+            self._state.current_uptime = max(0.0, self._state.current_uptime - 0.02)
+            logs = [f"[METRICS] Latency: {self._current_latency_ms:.0f}ms. Uptime: {self._state.current_uptime:.0%}."]
+            return (
+                0.0,
+                "No action taken. System performance continues to degrade.",
+                logs,
+                False,
+            )
+
+        else:
+            return (
+                0.0,
+                f"Command '{action.command_type.value}' is not relevant to this DB incident.",
+                [],
+                False,
+            )
+
+    def _step_hard(self, action: SREAction, cmd: CommandType) -> tuple[float, str, list[str], bool, float]:
+        """Hard: scale servers under budget to handle traffic spike."""
+        config = TASK_CONFIGS[TaskDifficulty.HARD]
+        reward = 0.0
+        constraint_penalty = 0.0
+        logs: list[str] = []
+
+        if cmd == CommandType.DIAGNOSE:
+            if not self._diagnosed:
+                self._diagnosed = True
+                reward = 0.10
+                needed = config["current_rps"] - self._current_capacity_rps
+                servers_needed = max(1, needed // config["capacity_per_server"])
+                cost_estimate = servers_needed * config["cost_per_server"]
+                logs = [
+                    f"[LB] Current traffic: {config['current_rps']:,} RPS",
+                    f"[LB] Current capacity: {self._current_capacity_rps:,} RPS ({self._current_servers} servers)",
+                    f"[LB] Deficit: {needed:,} RPS",
+                    f"[LB] Estimated servers needed: {servers_needed} (${cost_estimate:.0f} total)",
+                    f"[BUDGET] Remaining: ${self._state.budget_remaining:.0f}",
+                ]
+                self._state.root_cause_found = True
+                return (
+                    reward,
+                    "Traffic analysis complete. Scaling plan identified.",
+                    logs,
+                    True,
+                    0.0,
+                )
+            else:
+                return 0.0, "Already diagnosed. Proceed with scaling.", [], False, 0.0
+
+        elif cmd == CommandType.SCALE_SERVERS:
+            replicas = action.parameters.get("replicas", 1)
+            try:
+                replicas = int(replicas)
+            except (ValueError, TypeError):
+                replicas = 1
+
+            replicas = max(1, min(replicas, 20))  # clamp to sane range
+            cost = replicas * config["cost_per_server"]
+
+            # Check budget
+            if cost > self._state.budget_remaining:
+                constraint_penalty = -0.8
+                self._state.budget_remaining -= cost  # negative budget
+                logs = [
+                    f"[CLOUD] Provisioned {replicas} servers at ${cost:.0f}.",
+                    f"[BUDGET] ⚠️ EXCEEDED! Remaining: ${self._state.budget_remaining:.0f}",
+                ]
+                return (
+                    0.0,
+                    f"Budget exceeded! Over by ${abs(self._state.budget_remaining):.0f}.",
+                    logs,
+                    False,
+                    constraint_penalty,
+                )
+
+            # Provision servers
+            self._state.budget_remaining -= cost
+            self._current_servers += replicas
+            self._servers_added += replicas
+            self._current_capacity_rps = self._current_servers * config["capacity_per_server"]
+
+            # Update uptime based on capacity vs demand
+            capacity_ratio = min(1.0, self._current_capacity_rps / config["current_rps"])
+            self._state.current_uptime = capacity_ratio
+
+            # Proportional reward based on how much capacity gap is closed
+            reward = 0.05 + 0.35 * capacity_ratio
+            if self._diagnosed:
+                reward += 0.05
+
+            if capacity_ratio >= 1.0:
+                self._state.incident_resolved = True
+
+            logs = [
+                f"[CLOUD] Provisioned {replicas} servers. Total: {self._current_servers}.",
+                f"[CLOUD] Capacity: {self._current_capacity_rps:,} / {config['current_rps']:,} RPS ({capacity_ratio:.0%})",
+                f"[BUDGET] Spent: ${cost:.0f}. Remaining: ${self._state.budget_remaining:.0f}.",
+                f"[METRICS] Uptime: {self._state.current_uptime:.0%}",
+            ]
+            return (
+                reward,
+                f"Scaled by {replicas} servers. Capacity at {capacity_ratio:.0%}.",
+                logs,
+                True,
+                0.0,
+            )
+
+        elif cmd == CommandType.NOOP:
+            # Uptime drops further with no action
+            self._state.current_uptime = max(0.0, self._state.current_uptime - 0.05)
+            logs = [
+                f"[METRICS] Uptime: {self._state.current_uptime:.0%} (degrading).",
+                f"[LB] Dropping {max(0, config['current_rps'] - self._current_capacity_rps):,} requests.",
+            ]
+            return 0.0, "No action. Requests being dropped.", logs, False, 0.0
+
+        else:
+            return (
+                0.0,
+                f"Command '{action.command_type.value}' is not relevant to the scaling incident.",
+                [],
+                False,
+                0.0,
+            )
+
+    def _step_extreme(self, action: SREAction, cmd: CommandType) -> tuple[float, str, list[str], bool, float]:
+        """Extreme: Rollback a bad deployment based on logs."""
+        config = TASK_CONFIGS[TaskDifficulty.EXTREME]
+        reward = 0.0
+        constraint_penalty = 0.0
+        logs: list[str] = []
+
+        if cmd == CommandType.DIAGNOSE:
+            if not self._diagnosed:
+                self._diagnosed = True
+                reward = 0.15
+                logs = [
+                    "[ALERT] auth-service returning 500 Internal Server Error for 98% of requests.",
+                    "[DIAG] CPU/Mem healthy. Network healthy.",
+                    "[DIAG] Root cause appears to be a recent code deployment in auth-service.",
+                    "[HINT] Use 'check_logs' on 'auth-service' to identify the failing revision.",
+                ]
+                self._state.root_cause_found = True
+                return (
+                    reward,
+                    "Diagnosis complete. auth-service deployment is failing.",
+                    logs,
+                    True,
+                    0.0,
+                )
+            return (
+                0.0,
+                "Already diagnosed. Proceed to check deployment logs.",
+                [],
+                False,
+                0.0,
+            )
+
+        elif cmd == CommandType.CHECK_LOGS:
+            if action.target_resource == config["buggy_deployment"]:
+                self._logs_checked = True
+                reward = 0.15
+                logs = [
+                    "[LOGS] Tail of auth-service deployment history:",
+                    "  Revision 3 (v1.4.3) - FAILED (NullPointerException in AuthProvider)",
+                    "  Revision 2 (v1.4.2) - STABLE (active 3 days ago)",
+                    "  Revision 1 (v1.4.1) - STABLE",
+                    "[HINT] Use 'rollback' on 'auth-service' with parameter {'revision': 'v1.4.2'}",
+                ]
+                return (
+                    reward,
+                    "Deployment logs retrieved successfully.",
+                    logs,
+                    True,
+                    0.0,
+                )
+            return (
+                -0.1,
+                f"No deployment history found for {action.target_resource}",
+                [],
+                False,
+                0.0,
+            )
+
+        elif cmd == CommandType.ROLLBACK:
+            target = action.target_resource
+            revision = action.parameters.get("revision", "")
+
+            if target != config["buggy_deployment"]:
+                return (
+                    -0.3,
+                    f"Cannot rollback {target}. It is not the source of the incident.",
+                    [],
+                    False,
+                    0.0,
+                )
+
+            if revision != config["stable_revision"]:
+                constraint_penalty = -0.5
+                self._catastrophic = True
+                self._state.current_uptime = 0.0
+                return (
+                    0.0,
+                    f"Rolled back to bad revision '{revision}'! Complete outage.",
+                    ["[FATAL] Rollback failed. No service startup."],
+                    False,
+                    constraint_penalty,
+                )
+
+            # Success path
+            self._rolled_back = True
+            self._state.current_uptime = min(1.0, self._state.current_uptime + 0.90)
+            reward = 0.50
+            if self._state.current_uptime >= 0.95:
+                self._state.incident_resolved = True
+
+            logs = [
+                "[K8S] kubectl rollout undo deployment/auth-service --to-revision=2",
+                "[K8S] auth-service rolled back to v1.4.2",
+                f"[METRICS] Uptime recovered to {self._state.current_uptime:.0%}",
+            ]
+            return (
+                reward,
+                f"Successfully rolled back to {revision}. Service restored.",
+                logs,
+                True,
+                0.0,
+            )
+
+        elif cmd == CommandType.NOOP:
+            self._state.current_uptime = max(0.0, self._state.current_uptime - 0.05)
+            logs = [f"[METRICS] Users continually locked out. Uptime {self._state.current_uptime:.0%}"]
+            return 0.0, "No action. Outage continues.", logs, False, 0.0
+
+        return (
+            0.0,
+            f"Command '{action.command_type.value}' doesn't help with a bad deployment.",
+            [],
+            False,
+            0.0,
+        )
+
+    def _make_observation(
+        self,
+        message: str,
+        logs: list[str],
+        success: bool,
+        reward: float | None = None,
+        done: bool = False,
+    ) -> SREObservation:
+        """Build a full SREObservation with current metrics."""
+        config = TASK_CONFIGS[self._state.task_difficulty]
+
+        metrics = SystemMetrics(
+            cpu_percent=self._rng.uniform(30, 85),
+            memory_percent=self._rng.uniform(40, 90),
+            latency_ms=self._current_latency_ms,
+            uptime=self._state.current_uptime,
+            error_rate=max(0.0, 1.0 - self._state.current_uptime),
+            budget_used=config["budget"] - self._state.budget_remaining,
+        )
+
+        available = self._get_available_actions()
+
+        metadata = {}
+        if done:
+            temp_obs = SREObservation(
+                message=message,
+                logs=logs,
+                success=success,
+                metrics=metrics,
+                available_actions=available,
+                task_description=self._state.task_description,
+                done=done,
+                reward=reward,
+            )
+            score = self.rubric(None, temp_obs)
+            metadata["grader_score"] = score
+            metadata["total_accumulated_reward"] = self._state.total_reward
+
+            message = f"{message} [GRADER_SCORE: {score:.3f}]"
+
+        obs = SREObservation(
+            message=message,
+            logs=logs,
+            success=success,
+            metrics=metrics,
+            available_actions=available,
+            task_description=self._state.task_description,
+            done=done,
+            reward=reward,
+            metadata=metadata,
+        )
+
+        return obs
+
+    def _get_available_actions(self) -> list[str]:
+        """Return contextually reasonable action types."""
+        actions = [CommandType.DIAGNOSE.value, CommandType.NOOP.value]
+        difficulty = self._state.task_difficulty
+
+        # Dynamically restrict dangerous actions until diagnosis is complete
+        if difficulty == TaskDifficulty.EASY:
+            if self._diagnosed:
+                actions.append(CommandType.RESTART_POD.value)
+        elif difficulty == TaskDifficulty.MEDIUM:
+            if self._diagnosed:
+                actions.append(CommandType.RUN_SQL.value)
+        elif difficulty == TaskDifficulty.HARD:
+            if self._diagnosed:
+                actions.append(CommandType.SCALE_SERVERS.value)
+        elif difficulty == TaskDifficulty.EXTREME:
+            if self._diagnosed:
+                actions.append(CommandType.CHECK_LOGS.value)
+            if self._logs_checked:
+                actions.append(CommandType.ROLLBACK.value)
+
+        return actions
+
+    def _generate_initial_logs(self, difficulty: TaskDifficulty) -> list[str]:
+        """Generate realistic initial alert logs for each scenario."""
+        if difficulty == TaskDifficulty.EASY:
+            return [
+                "[ALERT] PagerDuty: High-severity alert triggered for 'production/web'",
+                "[K8S] Event: pod-web-3 - Back-off restarting failed container (OOMKilled)",
+                "[K8S] Event: pod-web-3 - Container 'web-app' memory limit 512Mi exceeded",
+                "[METRICS] Cluster uptime dropped to 45%. Error rate: 55%.",
+                "[HINT] Available commands: diagnose, restart_pod, noop",
+            ]
+        elif difficulty == TaskDifficulty.MEDIUM:
+            return [
+                "[ALERT] Datadog: API latency P99 > 10,000 ms on 'orders' service",
+                "[DB] Slow query log (last 5 min): 847 queries exceeding 1,000 ms",
+                "[DB] Top offender: SELECT * FROM orders_table WHERE customer_id = ?",
+                "[METRICS] API uptime: 70%. User-facing errors increasing.",
+                "[HINT] Available commands: diagnose, run_sql, noop",
+            ]
+        elif difficulty == TaskDifficulty.HARD:
+            return [
+                "[ALERT] CloudWatch: Incoming traffic surge - 50,000 RPS (10× normal)",
+                "[LB] Load balancer: 90% of requests timing out. Current capacity: 5,000 RPS.",
+                "[CLOUD] Active servers: 1. Budget remaining: $500.",
+                "[CLOUD] Server cost: $50/unit. Each adds 5,000 RPS capacity.",
+                "[METRICS] Uptime: 10%. Error rate: 90%. 45,000 requests/sec being dropped.",
+                "[HINT] Available commands: diagnose, scale_servers, noop",
+            ]
+        elif difficulty == TaskDifficulty.EXTREME:
+            return [
+                "[ALERT] Sentry: Massive spike in 500 errors for 'auth-service'",
+                "[ALERT] Zendesk: 1,200 new customer tickets 'Cannot login'",
+                "[K8S] Event: auth-service deployment v1.4.3 just completed",
+                "[METRICS] Global uptime dropped to 5%. Critical outage.",
+                "[HINT] Available commands: diagnose, check_logs, rollback, noop",
+            ]
+        return []

server/requirements.txt

@@ -0,0 +1,5 @@
+fastapi>=0.100.0
+uvicorn[standard]>=0.23.0
+pydantic>=2.0.0
+openenv-core>=0.2.2
+rich>=13.0.0

server/rubrics.py

@@ -0,0 +1,68 @@
+from typing import Any
+
+from openenv.core.rubrics.base import Rubric
+
+from sre_env.models import TaskDifficulty
+
+
+class SREGraderRubric(Rubric):
+    def __init__(self, env: Any) -> None:
+        super().__init__()
+        self._env = env
+
+    def forward(self, action: Any, observation: Any) -> float:
+        difficulty = self._env.state.task_difficulty
+
+        if difficulty == TaskDifficulty.EASY:
+            return self._grade_easy()
+        elif difficulty == TaskDifficulty.MEDIUM:
+            return self._grade_medium()
+        elif difficulty == TaskDifficulty.HARD:
+            return self._grade_hard()
+        elif difficulty == TaskDifficulty.EXTREME:
+            return self._grade_extreme()
+        return 0.0
+
+    def _grade_easy(self) -> float:
+        """Proportional to restored uptime (target ≥ 0.95)."""
+        return min(1.0, self._env.state.current_uptime / 0.95)
+
+    def _grade_medium(self) -> float:
+        """Proportional to latency improvement."""
+        from server.environment import TASK_CONFIGS
+
+        config = TASK_CONFIGS[TaskDifficulty.MEDIUM]
+        baseline = config["initial_latency_ms"]
+        target = config["target_latency_ms"]
+
+        # Access internal environment state
+        current = self._env._current_latency_ms
+
+        if current <= target:
+            return 1.0
+
+        improvement_ratio = (baseline - current) / (baseline - target)
+        return max(0.0, min(1.0, improvement_ratio))
+
+    def _grade_hard(self) -> float:
+        """Composite: 50% uptime + 30% budget + 20% speed bonus."""
+        from server.environment import TASK_CONFIGS
+
+        config = TASK_CONFIGS[TaskDifficulty.HARD]
+
+        # Uptime score
+        uptime_score = min(1.0, self._env.state.current_uptime / 0.90)
+
+        # Budget score — proportion of budget remaining
+        budget_score = max(0.0, self._env.state.budget_remaining / config["budget"])
+
+        # Speed bonus — fewer steps = higher bonus
+        speed_bonus = max(0.0, 1.0 - (self._env.state.step_count / self._env.state.max_steps))
+
+        return 0.5 * uptime_score + 0.3 * budget_score + 0.2 * speed_bonus
+
+    def _grade_extreme(self) -> float:
+        """Composite: 70% uptime + 30% speed bonus (No budget used in rollback)."""
+        uptime_score = min(1.0, self._env.state.current_uptime / 0.95)
+        speed_bonus = max(0.0, 1.0 - (self._env.state.step_count / self._env.state.max_steps))
+        return 0.7 * uptime_score + 0.3 * speed_bonus

server/schemas/reset.py

@@ -0,0 +1,10 @@
+from typing import List
+
+from pydantic import BaseModel
+
+
+class CustomResetRequest(BaseModel):
+    seed: int
+    difficulty: str
+    custom_description: str
+    custom_logs: List[str]

sre_env/__init__.py

@@ -0,0 +1,3 @@
+from sre_env.models import SREAction, SREObservation, SREState
+
+__all__ = ["SREAction", "SREObservation", "SREState"]

sre_env/constants/prompts.py

@@ -0,0 +1,44 @@
+SYSTEM_PROMPT = """
+	You are an expert SRE AI agent. You must respond ONLY with a JSON object.
+	Your goal is to resolve the incident with the highest uptime and lowest cost. 
+	Always 'diagnose' first to understand the root cause before taking corrective actions.
+
+	Schema:
+	{
+		"command_type": "diagnose" | "restart_pod" | "run_sql" | "scale_servers" | "noop",
+		"target_resource": "<resource_id>",
+		"parameters": {}
+	}
+
+	Command Details:
+		- diagnose: Sets target_resource to 'system' or the afflicted component.
+		- restart_pod: Sets target_resource to the exact failing pod name.
+		- run_sql: Sets target_resource to the table name. Requires "sql" parameter, e.g., {"sql": "CREATE INDEX ..."}.
+		- scale_servers: Sets target_resource to the cluster name. Requires "replicas" integer parameter, e.g., {"replicas": 5}.
+
+	Examples:
+	1. {"command_type": "diagnose", "target_resource": "production", "parameters": {}}
+	2. {"command_type": "restart_pod", "target_resource": "pod-web-3", "parameters": {}}
+	3. {"command_type": "run_sql", "target_resource": "orders_table", "parameters": {"sql": "CREATE INDEX idx_customer_id ON orders_table(customer_id)"}}
+	4. {"command_type": "scale_servers", "target_resource": "us-east-cluster", "parameters": {"replicas": 5}}
+
+	Respond strictly with the JSON object. Do not include markdown formatting or conversational text.
+"""
+
+ROUTER_SYSTEM_PROMPT = """
+	You are an SRE Incident Router. Map the user's custom incident specifically to one of these 4 archetypes:
+	1. "easy": Requires pod restarts. Target MUST BE 'pod-web-3'.
+	2. "medium": Requires adding DB indexes. Target MUST BE 'orders_table'.
+	3. "hard": Requires scaling servers. Target MUST BE 'system'.
+	4. "extreme": Requires diagnosing auth failures and rollback. Target MUST BE 'auth-service'.
+
+	If the custom incident is unrelated (e.g. hacking, UI design), reject it.
+	Return JSON ONLY:
+	{
+		"accepted": true/false,
+		"archetype": "easy|medium|hard|extreme",
+		"reason": "If rejected, explain why. Omit if accepted.",
+		"custom_description": "INCIDENT: Rewritten professional incident describing the problem, retaining the target requirement.",
+		"custom_logs": ["Simulated terminal log 1", "log 2", "log 3"]
+	}
+"""

sre_env/core/client.py

@@ -0,0 +1,20 @@
+import sys
+
+import requests
+
+
+def env_reset(base_url: str, seed: int | None = None) -> dict:
+    try:
+        payload = {"seed": seed} if seed is not None else {}
+        resp = requests.post(f"{base_url}/reset", json=payload, timeout=30)
+        resp.raise_for_status()
+        return resp.json()
+    except requests.exceptions.ConnectionError:
+        print(f"❌ Error: Could not connect to environment server at {base_url}")
+        sys.exit(1)
+
+
+def env_step(base_url: str, action: dict) -> dict:
+    resp = requests.post(f"{base_url}/step", json={"action": action}, timeout=30)
+    resp.raise_for_status()
+    return resp.json()

sre_env/inference.py

@@ -0,0 +1,187 @@
+import json
+import os
+import sys
+import time
+from datetime import datetime
+
+import requests
+from dotenv import load_dotenv
+from openai import OpenAI
+from rich.console import Console
+from rich.panel import Panel
+from rich.prompt import Prompt
+
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "..")))
+
+from sre_env.constants.prompts import ROUTER_SYSTEM_PROMPT, SYSTEM_PROMPT
+from sre_env.core.client import env_reset, env_step
+from sre_env.utils.parser import extract_json
+
+load_dotenv()
+
+API_BASE_URL = os.getenv("API_BASE_URL")
+MODEL_NAME = os.getenv("MODEL_NAME")
+HF_TOKEN = os.getenv("HF_TOKEN")
+ENV_BASE_URL = os.getenv("ENV_BASE_URL")
+
+MAX_STEPS = 30
+TIMEOUT_MINUTES = 18
+
+
+def main():
+    console = Console()
+    client = OpenAI(base_url=API_BASE_URL, api_key=HF_TOKEN or "dummy")
+
+    console.print(
+        Panel.fit(
+            "[bold cyan]🛡️ Sentinel-SRE Autonomous Agent[/bold cyan]\nInteractive Incident Injector",
+            border_style="cyan",
+        )
+    )
+
+    console.print("\n[bold white]Select an Incident to inject into the environment:[/bold white]")
+    console.print("  [green][1][/green] 🟢 OOMKilled Pod Crash (Easy)")
+    console.print("  [yellow][2][/yellow] 🟡 Missing Database Index (Medium)")
+    console.print("  [red][3][/red] 🔴 50,000 RPS Traffic Spike (Hard)")
+    console.print("  [magenta][4][/magenta] 💀 Bad Code Deployment (Extreme)")
+    console.print("  [blue][5][/blue] 🧠 Dynamic Task Generation (Custom Prompt)")
+
+    while True:
+        choice = Prompt.ask(
+            "\n[bold cyan]Enter scenario[/bold cyan]",
+            choices=["1", "2", "3", "4", "5"],
+            default="1",
+        )
+
+        if choice == "5":
+            user_prompt = Prompt.ask("\n[bold blue]Describe the incident you want to simulate[/bold blue]")
+
+            with console.status("[bold blue]LLM Analyzing Scenario...", spinner="dots"):
+                try:
+                    resp = client.chat.completions.create(
+                        model=MODEL_NAME,
+                        messages=[
+                            {"role": "system", "content": ROUTER_SYSTEM_PROMPT},
+                            {"role": "user", "content": user_prompt},
+                        ],
+                        response_format={"type": "json_object"},
+                    )
+                    result = json.loads(resp.choices[0].message.content)
+                    if not result.get("accepted"):
+                        console.print(f"[bold red]❌ Rejected:[/bold red] {result.get('reason')}")
+                        continue
+
+                    diff_map = {"easy": 2, "medium": 1, "hard": 5, "extreme": 0}
+                    chosen_seed = diff_map.get(result.get("archetype", "easy"), 2)
+
+                    with console.status("[bold green]Injecting Custom Chaos...", spinner="aesthetic"):
+                        payload = {
+                            "seed": chosen_seed,
+                            "difficulty": result.get("archetype", "easy"),
+                            "custom_description": result["custom_description"],
+                            "custom_logs": result.get("custom_logs", []),
+                        }
+                        r = requests.post(f"{ENV_BASE_URL}/custom_reset", json=payload, timeout=10)
+                        reset_resp = r.json()
+                        break
+                except Exception as e:
+                    console.print(f"[bold red]LLM Error:[/bold red] {e}")
+                    continue
+        else:
+            seed_map = {"1": 2, "2": 1, "3": 5, "4": 0}
+            chosen_seed = seed_map[choice]
+            with console.status("[bold green]Injecting Static Chaos...", spinner="aesthetic"):
+                reset_resp = env_reset(ENV_BASE_URL, seed=chosen_seed)
+            break
+
+    observation = reset_resp.get("observation", {})
+    done = reset_resp.get("done", False)
+
+    total_reward = 0.0
+    step_count = 0
+    start_time = time.time()
+
+    audit_trail = {
+        "timestamp": datetime.utcnow().isoformat(),
+        "task_description": observation.get("task_description", "N/A"),
+        "trajectory": [],
+    }
+
+    console.print(f"[bold yellow]📋 Task:[/bold yellow] {audit_trail['task_description']}")
+
+    while not done and step_count < MAX_STEPS:
+        if (time.time() - start_time) / 60 > TIMEOUT_MINUTES:
+            console.print("[bold red]Timeout Reached![/bold red]")
+            break
+
+        step_count += 1
+        console.print(f"\n[bold magenta]── Step {step_count} ──────────────────────────────────[/bold magenta]")
+
+        action = {}
+        with console.status("[bold green]Agent Thinking...", spinner="dots"):
+            try:
+                history = [
+                    {"role": "system", "content": SYSTEM_PROMPT},
+                    {"role": "user", "content": f"Context: {json.dumps(observation)}"},
+                ]
+                response = client.chat.completions.create(
+                    model=MODEL_NAME, messages=history, max_tokens=512, temperature=0.1
+                )
+                raw_content = response.choices[0].message.content.strip()
+                action = extract_json(raw_content)
+            except Exception as e:
+                console.print(f"[bold red]❌ LLM/Parse Error:[/bold red] {e}")
+                break
+
+        cmd_type = action.get("command_type", "UNKNOWN")
+        target = action.get("target_resource", "UNKNOWN")
+        console.print(f"  [bold blue]🚀 Action Request:[/bold blue] {cmd_type} [white]on[/white] {target}")
+
+        step_resp = env_step(ENV_BASE_URL, action)
+        prev_obs = observation
+        observation = step_resp.get("observation", {})
+        reward = step_resp.get("reward", 0.0) or 0.0
+        done = step_resp.get("done", False)
+        total_reward += reward
+
+        audit_trail["trajectory"].append(
+            {
+                "step": step_count,
+                "observation_in": prev_obs,
+                "action": action,
+                "reward": reward,
+                "observation_out": observation,
+            }
+        )
+
+        msg = observation.get("message", "")
+        color = "green" if "Success" in msg or "restored" in msg else "yellow" if "Already" in msg else "red"
+        console.print(f"  [bold {color}]► Result:[/bold {color}] {msg}")
+        console.print(
+            f"  [bold cyan]► Reward:[/bold cyan] {reward:+.3f} | [bold cyan]Total:[/bold cyan] {total_reward:+.3f}"
+        )
+
+    score = observation.get("metadata", {}).get("grader_score", "N/A")
+    final_msg = observation.get("message", "")
+    if "GRADER_SCORE:" in final_msg:
+        try:
+            score = final_msg.split("GRADER_SCORE: ")[1].split("]")[0]
+        except Exception:
+            pass
+
+    panel = Panel.fit(
+        f"[bold white]Resolution Complete[/bold white]\n"
+        f"[bold green]Final Grade:[/bold green] {score}\n"
+        f"[bold green]Total Steps:[/bold green] {step_count}",
+        title="[bold cyan]End of Episode[/bold cyan]",
+        border_style="cyan",
+    )
+    console.print("\n", panel)
+
+    with open("agent_trace.json", "w") as f:
+        json.dump(audit_trail, f, indent=2)
+    console.print("[dim]Audit trail saved to agent_trace.json[/dim]")
+
+
+if __name__ == "__main__":
+    main()

sre_env/models.py

@@ -0,0 +1,141 @@
+from enum import Enum
+from typing import Any, Dict, List
+
+from openenv.core.env_server.types import Action, Observation, State
+from pydantic import Field
+
+
+class CommandType(str, Enum):
+    """Available SRE command types."""
+
+    RESTART_POD = "restart_pod"
+    RUN_SQL = "run_sql"
+    SCALE_SERVERS = "scale_servers"
+    DIAGNOSE = "diagnose"
+    CHECK_LOGS = "check_logs"
+    ROLLBACK = "rollback"
+    NOOP = "noop"
+
+
+class TaskDifficulty(str, Enum):
+    """Task difficulty tiers."""
+
+    EASY = "easy"
+    MEDIUM = "medium"
+    HARD = "hard"
+    EXTREME = "extreme"
+
+
+class SREAction(Action):
+    """An SRE command issued by the agent.
+
+    Attributes:
+        command_type: The type of SRE command to execute. Validated dynamically in the environment.
+        target_resource: The resource to target (e.g. pod name, table name, cluster).
+        parameters: Additional key-value parameters for the command.
+    """
+
+    command_type: str = Field(
+        default="noop",
+        description="Type of SRE command to execute (restart_pod, run_sql, scale_servers, diagnose, check_logs, rollback, noop).",
+    )
+    target_resource: str = Field(
+        default="",
+        description="The target resource identifier (e.g. 'pod-web-3', 'orders_table', 'us-east-cluster').",
+    )
+    parameters: Dict[str, Any] = Field(
+        default_factory=dict,
+        description="Additional command parameters (e.g. {'replicas': 5} for scale_servers).",
+    )
+
+
+class SystemMetrics(Action):
+    """Current system metrics snapshot — embedded inside observations.
+
+    Note: Inherits from Action (BaseModel) purely for Pydantic config;
+    semantically this is just a nested model.
+    """
+
+    model_config = Action.model_config.copy()
+    model_config["extra"] = "allow"
+
+    cpu_percent: float = Field(default=0.0, description="CPU utilisation 0-100")
+    memory_percent: float = Field(default=0.0, description="Memory utilisation 0-100")
+    latency_ms: float = Field(default=0.0, description="P99 latency in milliseconds")
+    uptime: float = Field(default=1.0, description="Service uptime ratio 0.0-1.0")
+    error_rate: float = Field(default=0.0, description="Error rate 0.0-1.0")
+    budget_used: float = Field(default=0.0, description="Cloud budget consumed in $")
+
+
+class SREObservation(Observation):
+    """Observation returned after each environment step.
+
+    Combines human-readable messages, structured logs, success flags,
+    and real-time system metrics.
+    """
+
+    message: str = Field(
+        default="",
+        description="Human-readable status message describing the current situation.",
+    )
+    logs: List[str] = Field(
+        default_factory=list,
+        description="Simulated structured log lines from the SRE system.",
+    )
+    success: bool = Field(
+        default=False,
+        description="Whether the last action was successful.",
+    )
+    metrics: SystemMetrics = Field(
+        default_factory=SystemMetrics,
+        description="Current system metrics snapshot.",
+    )
+    available_actions: List[str] = Field(
+        default_factory=list,
+        description="List of contextually valid action types for the current state.",
+    )
+    task_description: str = Field(
+        default="",
+        description="Description of the current incident scenario.",
+    )
+
+
+class SREState(State):
+    """Internal episode state tracked by the environment.
+
+    Extends the OpenEnv base State (which already provides episode_id and
+    step_count) with SRE-specific telemetry.
+    """
+
+    task_difficulty: TaskDifficulty = Field(
+        default=TaskDifficulty.EASY,
+        description="Difficulty tier of the current task.",
+    )
+    task_description: str = Field(
+        default="",
+        description="Human-readable description of the active incident.",
+    )
+    current_uptime: float = Field(
+        default=1.0,
+        description="Current service uptime ratio (0.0 to 1.0).",
+    )
+    budget_remaining: float = Field(
+        default=500.0,
+        description="Remaining simulated cloud budget in USD.",
+    )
+    max_steps: int = Field(
+        default=15,
+        description="Maximum steps allowed for this episode.",
+    )
+    incident_resolved: bool = Field(
+        default=False,
+        description="Whether the incident has been fully resolved.",
+    )
+    root_cause_found: bool = Field(
+        default=False,
+        description="Whether the agent has identified the root cause.",
+    )
+    total_reward: float = Field(
+        default=0.0,
+        description="Cumulative reward accumulated during the episode.",
+    )

sre_env/tests/test_environment.py

@@ -0,0 +1,113 @@
+from server.environment import SREEnvironment
+from sre_env.models import SREAction
+
+
+def test_easy_episode():
+    env = SREEnvironment()
+    env.reset(seed=42)
+    # Ensure it's easy by forcing it if needed, or by injecting state
+    env.state.task_difficulty = "easy"
+
+    # 1. Diagnose
+    obs = env.step(SREAction(command_type="diagnose"))
+    assert obs.success is True
+    assert "pod-web-3" in obs.message
+
+    # 2. Restart wrong pod
+    obs2 = env.step(SREAction(command_type="restart_pod", target_resource="pod-web-not-real"))
+    assert obs2.success is False
+    assert obs2.reward < 0
+
+    # 3. Restart correct pod
+    obs3 = env.step(SREAction(command_type="restart_pod", target_resource="pod-web-3"))
+    assert obs3.success is True
+    assert obs3.done is True
+    assert obs3.metadata["grader_score"] > 0.8
+
+
+def test_medium_episode():
+    env = SREEnvironment()
+    env.reset(seed=42)
+    env.state.task_difficulty = "medium"
+
+    # 1. Diagnose
+    env.step(SREAction(command_type="diagnose"))
+
+    # 2. Run wrong SQL
+    obs = env.step(
+        SREAction(
+            command_type="run_sql",
+            target_resource="users",
+            parameters={"sql": "CREATE INDEX on users"},
+        )
+    )
+    assert obs.success is False
+
+    # 3. Run partial SQL (wrong column)
+    obs2 = env.step(
+        SREAction(
+            command_type="run_sql",
+            target_resource="orders_table",
+            parameters={"sql": "CREATE INDEX on orders_table(date)"},
+        )
+    )
+    assert obs2.success is True
+    assert obs2.done is False
+
+    # 4. Run correct SQL
+    obs3 = env.step(
+        SREAction(
+            command_type="run_sql",
+            target_resource="orders_table",
+            parameters={"sql": "CREATE INDEX idx ON orders_table(customer_id)"},
+        )
+    )
+    assert obs3.success is True
+    assert obs3.done is True
+    assert obs3.metadata["grader_score"] > 0.9
+
+
+def test_hard_episode():
+    env = SREEnvironment()
+    env.reset(seed=42)
+    env.state.task_difficulty = "hard"
+
+    env.step(SREAction(command_type="diagnose"))
+
+    # Scale too many (break budget)
+    obs = env.step(
+        SREAction(
+            command_type="scale_servers",
+            target_resource="cluster",
+            parameters={"replicas": 20},
+        )
+    )
+    assert obs.success is False
+    assert obs.done is True  # Out of budget
+    assert obs.metadata["grader_score"] < 0.5
+
+
+def test_extreme_episode():
+    env = SREEnvironment()
+    env.reset(seed=42)
+    env.state.task_difficulty = "extreme"
+
+    # 1. Diagnose
+    env.step(SREAction(command_type="diagnose"))
+
+    # 2. Check Logs
+    obs_logs = env.step(SREAction(command_type="check_logs", target_resource="auth-service"))
+    assert obs_logs.success is True
+    assert "v1.4.2" in str(obs_logs.logs)
+
+    # 3. Rollback
+    obs_rollback = env.step(
+        SREAction(
+            command_type="rollback",
+            target_resource="auth-service",
+            parameters={"revision": "v1.4.2"},
+        )
+    )
+    assert obs_rollback.success is True
+    assert obs_rollback.done is True
+    assert obs_rollback.metadata["grader_score"] > 0.8

sre_env/utils/parser.py

@@ -0,0 +1,15 @@
+import json
+import re
+
+
+def extract_json(text: str) -> dict:
+    """Finds the first { and last } to extract JSON from conversational filler."""
+    try:
+        match = re.search(r"(\{.*\})", text, re.DOTALL)
+        if match:
+            clean_content = match.group(1)
+            clean_content = clean_content.replace("```json", "").replace("```", "")
+            return json.loads(clean_content)
+        return json.loads(text)
+    except Exception:
+        raise ValueError(f"Failed to parse LLM response as JSON. Content: {text[:100]}...")