updated inference

.gitignore

@@ -7,4 +7,5 @@ venv/
 *.egg-info/
 dist/
 build/
-.pytest_cache/
+.pytest_cache/
+myenv/

Dockerfile

@@ -4,16 +4,6 @@
 # ---------------------------------------------------------------
 FROM python:3.11-slim
 
-# Install system utilities for DevOps tasks
-RUN apt-get update && apt-get install -y --no-install-recommends \
-    nginx \
-    docker.io \
-    systemctl \
-    curl \
-    git \
-    vim \
-    && rm -rf /var/lib/apt/lists/*
-
 # Create non-root user for Hugging Face Spaces
 RUN useradd -m -u 1000 appuser
 
@@ -26,17 +16,10 @@ RUN pip install --no-cache-dir -r requirements.txt
 # Copy application code
 COPY --chown=appuser:appuser . .
 
-# HF Spaces compatibility
-RUN chmod +x /app/app.py 2>/dev/null || true
-
 USER appuser
 
 # Expose the port HF Spaces expects
 EXPOSE 7860
 
-# Health check
-HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3 \
-    CMD python -c "import requests; requests.get('http://localhost:7860/health')" || exit 1
-
-# Start the FastAPI server
-CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860", "--workers", "1", "--reload"]
+# Start the FastAPI server (No --reload in production)
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860", "--workers", "1"]

README.md

@@ -97,65 +97,3 @@ $step = @{
 } | ConvertTo-Json -Depth 5
 
 Invoke-WebRequest -Uri "http://127.0.0.1:7860/step" -Method POST -ContentType "application/json" -Body $step
-
-## Test With LLM (OpenAI Key)
-
-1) Keep API server running.
-2) Set key and run inference:
-
-PowerShell:
-
-$env:OPENAI_API_KEY = "your-openai-key"
-python inference.py --task task1 --model gpt-4o-mini
-
-You should see step logs, rewards, and a grader score.
-
-## Test With Gemini API Key
-
-inference.py now supports OpenAI-compatible base URLs.
-
-Use Gemini via OpenAI-compatible endpoint:
-
-PowerShell:
-
-$env:GEMINI_API_KEY = "your-gemini-key"
-$env:OPENAI_BASE_URL = "https://generativelanguage.googleapis.com/v1beta/openai/"
-python inference.py --task task1 --model gemini-2.5-flash
-
-Notes:
-- You can also use OPENAI_API_KEY instead of GEMINI_API_KEY.
-- If your model name is unavailable, switch to a Gemini model enabled on your key.
-- Keep the environment server running at http://127.0.0.1:7860 (or pass --api-url).
-
-## Docker
-
-Build:
-
-docker build -t devopsenv .
-
-Run:
-
-docker run -p 7860:7860 devopsenv
-
-Then open:
-- http://127.0.0.1:7860/health
-- http://127.0.0.1:7860/docs
-
-## Project Files
-
-- app.py: FastAPI API
-- environment.py: episode logic and simulator
-- graders.py: deterministic scoring
-- data.py: task metadata
-- models.py: Pydantic schemas
-- inference.py: LLM baseline runner
-- test_integration.py: local end-to-end check
-
-## Troubleshooting
-
-- Port already in use:
-  - change server port or stop old process.
-- 400/404 from API:
-  - check episode_id and task_id values.
-- LLM errors:
-  - verify API key, model name, and OPENAI_BASE_URL for Gemini.

inference.py

@@ -1,352 +1,98 @@
 """
 Baseline LLM inference agent for DevOpsEnv.
-
-This script reads an OpenEnv environment's state() and uses an LLM to generate
-actions that solve the DevOps tasks.
-
-Usage:
-  python inference.py --task task1 --model gpt-4 --hf-token <token>
+Strictly uses the OpenAI Client, but can route to Gemini via base_url.
 """
 import os
-import sys
 import json
 import argparse
-import time
-from pathlib import Path
-from typing import Optional
-
 import requests
-from google import genai
 from openai import OpenAI
 
-# Load .env values from current folder (if present) before reading config.
-def _load_dotenv_from_workspace() -> None:
-    """Load KEY=VALUE pairs from .env into os.environ without overriding existing vars."""
-    dotenv_path = Path(__file__).resolve().parent / ".env"
-    if not dotenv_path.exists():
-        return
-
-    for raw_line in dotenv_path.read_text(encoding="utf-8").splitlines():
-        line = raw_line.strip()
-        if not line or line.startswith("#"):
-            continue
-        if line.startswith("export "):
-            line = line[7:].strip()
-        if "=" not in line:
-            continue
-
-        key, value = line.split("=", 1)
-        key = key.strip()
-        value = value.strip()
-        if not key:
-            continue
-
-        # Remove surrounding quotes if present.
-        if (value.startswith('"') and value.endswith('"')) or (
-            value.startswith("'") and value.endswith("'")
-        ):
-            value = value[1:-1]
-
-        os.environ.setdefault(key, value)
-
-
-_load_dotenv_from_workspace()
-
-# Read config from environment/.env
+# Required Hackathon Variables
 API_BASE_URL = os.environ.get("API_BASE_URL", "http://localhost:7860")
-MODEL_NAME = os.environ.get("MODEL_NAME", "gpt-4")
-HF_TOKEN = os.environ.get("HF_TOKEN", "")
-OPENAI_BASE_URL = os.environ.get("OPENAI_BASE_URL", "")
-GEMINI_DEFAULT_MODEL = os.environ.get("GEMINI_MODEL", "gemini-3-flash-preview")
-
-
-def _get_openai_client() -> OpenAI:
-    """Create an OpenAI-compatible client for OpenAI-style chat completions."""
-    api_key = os.environ.get("OPENAI_API_KEY", "sk-test")
-    client_kwargs = {"api_key": api_key}
-    if OPENAI_BASE_URL:
-        client_kwargs["base_url"] = OPENAI_BASE_URL
-    return OpenAI(**client_kwargs)
-
-
-def _get_gemini_client() -> genai.Client:
-    """Create a Gemini client using the official google-genai SDK."""
-    api_key = os.environ.get("GEMINI_API_KEY") or os.environ.get("OPENAI_API_KEY", "")
-    if not api_key:
-        raise ValueError("GEMINI_API_KEY is required for Gemini models")
-    return genai.Client(api_key=api_key)
-
-
-def _is_gemini_model(model: str) -> bool:
-    """Detect whether the requested model should use the Gemini SDK path."""
-    m = (model or "").lower()
-    return "gemini" in m
 
+# Default to Gemini 1.5 Flash (Free tier)
+MODEL_NAME = os.environ.get("MODEL_NAME", "gemini-1.5-flash") 
 
-def _resolve_gemini_model(model: str) -> str:
-    """Map shorthand Gemini model names to concrete model IDs."""
-    m = (model or "").strip()
-    if not m or m.lower() == "gemini":
-        return GEMINI_DEFAULT_MODEL
-    return m
-
-
-def _generate_action_text(
-    model: str,
-    system_prompt: str,
-    user_prompt: str,
-    openai_client: Optional[OpenAI],
-    gemini_client: Optional[genai.Client],
-) -> str:
-    """Generate model output text using Gemini SDK or OpenAI-compatible chat."""
-    if _is_gemini_model(model):
-        if gemini_client is None:
-            raise ValueError("Gemini client was not initialized")
-        gemini_model = _resolve_gemini_model(model)
-        combined_prompt = (
-            f"System instructions:\n{system_prompt}\n\n"
-            f"User request:\n{user_prompt}"
-        )
-        response = gemini_client.models.generate_content(
-            model=gemini_model,
-            contents=combined_prompt,
-        )
-        return response.text or ""
-
-    if openai_client is None:
-        raise ValueError("OpenAI client was not initialized")
-
-    response = openai_client.chat.completions.create(
-        model=model,
-        messages=[
-            {"role": "system", "content": system_prompt},
-            {"role": "user", "content": user_prompt},
-        ],
-        temperature=0.3,
-        max_tokens=1000,
-    )
-    return response.choices[0].message.content or ""
-
-
-def send_request(method: str, endpoint: str, **kwargs):
-    """Send HTTP request to the environment server."""
-    url = f"{API_BASE_URL}{endpoint}"
-    response = requests.request(method, url, timeout=10, **kwargs)
-    response.raise_for_status()
-    return response.json()
+# This will be your Gemini API Key in HF Spaces secrets, 
+# but the hackathon validator will inject their own key here.
+HF_TOKEN = os.environ.get("HF_TOKEN", "")
 
+# Google's official OpenAI-compatible endpoint
+OPENAI_BASE_URL = os.environ.get(
+    "OPENAI_BASE_URL", 
+    "https://generativelanguage.googleapis.com/v1beta/openai/"
+)
 
-def run_agent(task_id: str, max_steps: int = 20, model: Optional[str] = None) -> dict:
-    """Run the agent on a specific task."""
-    model = model or MODEL_NAME
-    if _is_gemini_model(model):
-        model = _resolve_gemini_model(model)
-    openai_client: Optional[OpenAI] = None
-    gemini_client: Optional[genai.Client] = None
-    if _is_gemini_model(model):
-        gemini_client = _get_gemini_client()
-    else:
-        openai_client = _get_openai_client()
-    
-    # Initialize episode
+def run_agent(task_id: str):
     print(f"\n{'='*60}")
-    print(f"Starting task: {task_id}")
-    print(f"Model: {model}")
+    print(f"Initializing OpenAI client with model: {MODEL_NAME}")
+    print(f"Routing to: {OPENAI_BASE_URL}")
     print(f"{'='*60}\n")
     
-    obs = send_request("POST", "/reset", json={"task_id": task_id})
-    episode_id = obs["episode_id"]
-    max_steps = obs["max_steps"]
-    
-    print(f"Episode ID: {episode_id}")
-    print(f"Max Steps: {max_steps}")
-    print(f"\nTask: {obs['task_description']}\n")
+    # The hackathon requires using the OpenAI client
+    client = OpenAI(
+        api_key=HF_TOKEN,
+        base_url=OPENAI_BASE_URL
+    )
     
-    step_count = 0
-    total_reward = 0.0
-    actions_taken = []
+    # 1. Reset Environment
+    print(f"Starting task: {task_id}")
+    res = requests.post(f"{API_BASE_URL}/reset", json={"task_id": task_id}).json()
+    episode_id = res["episode_id"]
     
-    while step_count < max_steps:
-        step_count += 1
-        
-        # Get current state
-        state = send_request("GET", f"/state?episode_id={episode_id}")
-        
-        # Prepare prompt for LLM
-        system_prompt = """You are an expert Linux DevOps engineer/SRE. 
-Your job is to diagnose and fix broken systems using bash commands and file edits.
-You are interacting with a simulated Linux environment.
-
-Available actions:
-1. bash_cmd: Execute a bash command
-2. file_edit: Edit a file
-3. submit: Submit when the task is complete
-
-Respond in JSON format with this structure:
-{
-  "action_type": "bash_cmd" | "file_edit" | "submit",
-  "command": "command to execute" (if bash_cmd),
-  "file_path": "/path/to/file" (if file_edit),
-  "file_content": "new file content" (if file_edit),
-  "summary": "why you're taking this action"
-}
-
-Be strategic:
-- Start by diagnosing the system
-- Use ps, systemctl, curl, etc. to understand issues
-- Fix the root cause
-- Submit when done
-"""
+    # Max steps to prevent infinite loops (costs money/time)
+    for step in range(20): 
+        # 2. Get State
+        state_data = requests.get(f"{API_BASE_URL}/state", params={"episode_id": episode_id}).json()
+        sys_state = state_data.get("system_state", {})
         
-        user_prompt = f"""
-Current system state:
-- Task: {obs['task_description']}
-- Step: {state['step_number']}/{state['max_steps']}
-- Reward so far: {state['total_reward']:.3f}
-
-System status:
-{json.dumps(obs['system_state'], indent=2)}
-
-Previous actions: {len(state['history'])} taken so far
-
-History of commands:
-{json.dumps(state['history'][-3:], indent=2) if state['history'] else 'None yet'}
-
-What should I do next? Think step-by-step about what the issue is and how to fix it.
-"""
+        # 3. Call LLM
+        prompt = (
+            f"Current System State: {json.dumps(sys_state)}\n"
+            "You are a DevOps assistant. What action will you take? "
+            "Reply strictly in JSON with 'action_type' ('bash_cmd', 'file_edit', or 'submit'), "
+            "and the required fields ('command' for bash, 'filepath' & 'file_content' for edits)."
+        )
         
         try:
-            # Call LLM (Gemini SDK or OpenAI-compatible chat)
-            response_text = _generate_action_text(
-                model=model,
-                system_prompt=system_prompt,
-                user_prompt=user_prompt,
-                openai_client=openai_client,
-                gemini_client=gemini_client,
+            response = client.chat.completions.create(
+                model=MODEL_NAME,
+                messages=[
+                    {"role": "system", "content": "You output strictly valid JSON. Diagnose the issue and fix it. Use action_type='submit' when done."},
+                    {"role": "user", "content": prompt}
+                ],
+                # Gemini supports JSON mode via the OpenAI proxy
+                response_format={"type": "json_object"} 
             )
-            try:
-                # Try to extract JSON from response
-                if "```json" in response_text:
-                    json_str = response_text.split("```json")[1].split("```")[0]
-                elif "```" in response_text:
-                    json_str = response_text.split("```")[1].split("```")[0]
-                else:
-                    json_str = response_text
-                
-                action_data = json.loads(json_str)
-            except (json.JSONDecodeError, IndexError):
-                print(f"Failed to parse LLM response: {response_text[:100]}")
-                # Fallback to simple diagnosis
-                action_data = {"action_type": "bash_cmd", "command": "ps aux"}
-        
-        except Exception as e:
-            print(f"LLM error: {e}. Falling back to heuristic...")
-            # Fallback heuristic actions
-            if step_count == 1:
-                action_data = {"action_type": "bash_cmd", "command": "systemctl status nginx"}
-            else:
-                action_data = {"action_type": "submit", "summary": "Diagnostics complete"}
-        
-        # Step in environment
-        try:
-            result = send_request("POST", "/step", json={
-                "episode_id": episode_id,
-                "action": action_data
-            })
-            
-            obs = result["observation"]
-            reward = result["reward"]
-            done = result["done"]
-            
-            step_count = obs["step_number"]
-            total_reward = reward["total_reward"]
-            
-            actions_taken.append(action_data)
             
-            print(f"\nStep {step_count}/{max_steps}")
-            print(f"Action: {action_data['action_type']}")
-            if action_data.get("command"):
-                print(f"Command: {action_data['command']}")
-            elif action_data.get("file_path"):
-                print(f"File: {action_data['file_path']}")
+            action_str = response.choices[0].message.content
+            action = json.loads(action_str)
+            print(f"Step {step} Action: {action}")
             
-            print(f"Reward: {reward['step_reward']:+.3f} (total: {total_reward:.3f})")
-            print(f"Info: {reward['explanation'][:100]}")
-            
-            if done:
-                print(f"\n{'='*60}")
-                print("EPISODE COMPLETE!")
-                print(f"Final Reward: {total_reward:.3f}")
-                print(f"Steps taken: {step_count}")
-                print(f"{'='*60}\n")
-                break
-        
         except Exception as e:
-            print(f"Step error: {e}")
-            break
+            print(f"LLM Error or JSON parse failed: {e}. Submitting to end early.")
+            action = {"action_type": "submit", "summary": "Failed to parse LLM response"}
         
-        # Small delay to avoid rate limiting
-        time.sleep(0.5)
-    
-    # Grade the episode
-    try:
-        grade_result = send_request("POST", "/grader", json={"episode_id": episode_id})
-        print(f"\nGrader Results:")
-        print(f"Score: {grade_result['score']:.3f}/1.0")
-        print(f"Breakdown: {json.dumps(grade_result['breakdown'], indent=2)}")
-        print(f"Feedback: {grade_result['feedback']}")
-    except Exception as e:
-        print(f"Grading error: {e}")
-    
-    return {
-        "task_id": task_id,
-        "episode_id": episode_id,
-        "final_reward": total_reward,
-        "step_count": step_count,
-        "actions": actions_taken,
-    }
-
+        # 4. Step Environment
+        step_res = requests.post(
+            f"{API_BASE_URL}/step", 
+            json={"episode_id": episode_id, "action": action}
+        ).json()
+        
+        if step_res.get("done") or action.get("action_type") == "submit":
+            print("\nEpisode finished!")
+            break
+            
+    # 5. Grade
+    grade = requests.post(f"{API_BASE_URL}/grader", json={"episode_id": episode_id}).json()
+    print(f"\nGrader Results:")
+    print(f"Final Score: {grade['score']} / 1.0")
+    print(f"Feedback: {grade['feedback']}")
 
-def main():
-    parser = argparse.ArgumentParser(description="Run DevOpsEnv baseline agent")
-    parser.add_argument("--task", default="task1", help="Task ID (task1, task2, or task3)")
-    parser.add_argument(
-        "--model",
-        default=None,
-        help=(
-            "Model name (default: env var MODEL_NAME). "
-            "For Gemini, pass a real model ID like gemini-3-flash-preview "
-            "or use --model gemini to auto-resolve to GEMINI_MODEL."
-        ),
-    )
-    parser.add_argument("--api-url", default=None, help="API URL (default: env var API_BASE_URL)")
-    parser.add_argument("--hf-token", default=None, help="HF token (default: env var HF_TOKEN)")
-    parser.add_argument(
-        "--openai-base-url",
-        default=None,
-        help="OpenAI-compatible base URL for non-OpenAI providers (for example Gemini OpenAI API)",
-    )
-    
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--task", default="task1", help="Task ID to run")
     args = parser.parse_args()
     
-    # Override env variables if provided
-    global API_BASE_URL, MODEL_NAME, HF_TOKEN, OPENAI_BASE_URL
-    if args.api_url:
-        API_BASE_URL = args.api_url
-    if args.model:
-        MODEL_NAME = args.model
-    if args.hf_token:
-        HF_TOKEN = args.hf_token
-    if args.openai_base_url:
-        OPENAI_BASE_URL = args.openai_base_url
-    
-    try:
-        result = run_agent(args.task, model=MODEL_NAME)
-        print(json.dumps(result, indent=2))
-    except Exception as e:
-        print(f"Fatal error: {e}", file=sys.stderr)
-        sys.exit(1)
-
-
-if __name__ == "__main__":
-    main()
+    run_agent(args.task)

openenv.yaml

@@ -1,22 +1,20 @@
-name: SupportEnv
+name: DevOpsEnv
 version: "1.0.0"
 description: >
-  An OpenEnv-compliant customer support ticket triage environment for SaaS platforms.
-  Agents learn to classify tickets, extract structured information, and generate
-  professional resolutions — skills directly transferable to real-world support automation.
+  An OpenEnv-compliant Linux DevOps and SRE troubleshooting environment.
+  Agents act as a junior SRE to diagnose and fix broken simulated server states
+  using bash commands and file edits.
 
-domain: customer_support
+domain: software_engineering
 tags:
   - openenv
-  - customer-support
-  - nlp
-  - information-extraction
-  - classification
-  - generation
-  - real-world
+  - devops
+  - sre
+  - troubleshooting
+  - linux
 
 license: MIT
-author: SupportEnv Contributors
+author: SolvorLabs
 
 # -------------------------------------------------
 # Environment interface
@@ -26,8 +24,7 @@ interface:
     method: POST
     path: /reset
     request:
-      task_id: string        # task1 | task2 | task3
-      ticket_index: integer  # optional, 0-4
+      task_id: string # task1 | task2 | task3
     response: Observation
 
   step:
@@ -36,7 +33,7 @@ interface:
     request:
       episode_id: string
       action: Action
-    response: StepResult     # {observation, reward, done, info}
+    response: StepResult
 
   state:
     method: GET
@@ -57,52 +54,31 @@ interface:
       episode_id: string
     response: GraderResponse
 
-  baseline:
-    method: POST
-    path: /baseline
-    request:
-      model: string          # optional, default heuristic
-      ticket_index: integer  # optional, default 0
-    response: BaselineResult
-
   health:
     method: GET
     path: /health
 
 # -------------------------------------------------
-# Typed models
+# Typed models (Matches your models.py)
 # -------------------------------------------------
 models:
   Observation:
     task_id: string
     task_description: string
     episode_id: string
-    ticket: TicketInfo
+    system_state: dict
     thread_history: list[dict]
     available_actions: list[string]
     step_number: integer
     max_steps: integer
     hint: string | null
 
-  TicketInfo:
-    ticket_id: string
-    subject: string
-    body: string
-    customer_tier: string    # free | pro | enterprise
-    account_age_days: integer
-    previous_tickets: integer
-    attachments: list[string]
-
   Action:
-    action_type: string      # classify | extract | respond | resolve | escalate | submit
-    category: string | null
-    priority: string | null
-    extracted_entities: dict | null
-    required_actions: list[string] | null
-    response_text: string | null
-    resolution_steps: list[string] | null
-    escalation_team: string | null
-    escalation_reason: string | null
+    action_type: string # bash_cmd | file_edit | submit
+    command: string | null
+    filepath: string | null
+    file_content: string | null
+    summary: string | null
 
   Reward:
     step_reward: float
@@ -128,81 +104,44 @@ models:
   GraderResponse:
     episode_id: string
     task_id: string
-    score: float              # 0.0 – 1.0
+    score: float # 0.0 – 1.0
     breakdown: dict[string, float]
     feedback: string
 
 # -------------------------------------------------
-# Tasks
+# Tasks (Matches your data.py)
 # -------------------------------------------------
 tasks:
   task1:
-    name: "Ticket Classification"
+    name: "Nginx Service Recovery"
     difficulty: easy
-    max_steps: 3
+    max_steps: 10
     description: >
-      Given a customer support ticket, classify it by category
-      (billing | technical | account | feature_request | complaint | general)
-      and priority (low | medium | high | critical).
-    scoring:
-      category_correct: 0.50
-      priority_correct: 0.40
-      efficiency: 0.10
-    tickets: 5
-
+      The Nginx web server has crashed. The agent must restart the service
+      and ensure port 80 is returning an HTTP 200 OK status.
+      
   task2:
-    name: "Information Extraction"
+    name: "Docker Compose Fix"
     difficulty: medium
-    max_steps: 5
+    max_steps: 15
     description: >
-      Extract structured entities (account IDs, names, amounts, dates, domains)
-      from the ticket body and identify the list of required actions.
-    scoring:
-      entity_coverage: 0.60
-      action_coverage: 0.30
-      no_hallucination: 0.10
-    tickets: 5
+      A Docker container is misconfigured with the wrong port mapping. 
+      The agent must edit docker-compose.yml to fix the port and spin the container up.
 
   task3:
-    name: "Resolution Generation"
+    name: "API Memory Leak"
     difficulty: hard
-    max_steps: 8
+    max_steps: 20
     description: >
-      Generate a professional customer-facing response (response_text) and
-      an ordered list of resolution steps. Scored on keyword coverage,
-      step completeness, tone (apology, urgency, timeline), and response length.
-    scoring:
-      keyword_coverage: 0.30
-      step_coverage: 0.30
-      tone_compliance: 0.25
-      length_adequate: 0.10
-      no_empty_steps: 0.05
-    tickets: 5
-
-# -------------------------------------------------
-# Reward design
-# -------------------------------------------------
-reward:
-  type: dense
-  step_cost: -0.02       # small cost per step (encourages efficiency)
-  submit_bonus: 0.05     # bonus for explicit submit action
-  max_step_penalty: -0.10 # penalty for exhausting max_steps
-  grader_bonus: up_to_1.0 # grader score (0–1) added as terminal bonus
-
-# -------------------------------------------------
-# Reproducibility
-# -------------------------------------------------
-reproducibility:
-  dataset: static  # all 15 tickets are fixed, no randomisation
-  graders: deterministic  # rule-based, no LLM judge
-  baseline_mode: heuristic  # no API key required for reference scores
+      A Python mock API is experiencing a memory leak. The agent must diagnose 
+      the running processes, kill the faulty process, patch the python file, and restart.
 
 # -------------------------------------------------
 # Deployment
 # -------------------------------------------------
 deployment:
   framework: FastAPI
-  python: ">=3.10"
+  python: ">=3.11"
   port: 7860
   dockerfile: Dockerfile
   huggingface_space: true