Upload folder using huggingface_hub

README.md

@@ -1,201 +1,186 @@
 ---
-title: GitHub Issue Triage Environment
+title: GitHub Issue Triage — OpenEnv
 emoji: 🐛
-colorFrom: indigo
+colorFrom: blue
 colorTo: purple
 sdk: docker
-pinned: false
-app_port: 8000
-base_path: /web
+pinned: true
 tags:
   - openenv
   - reinforcement-learning
-  - agent
-  - github
+  - nlp
   - triage
+  - real-world
+base_path: /web
 ---
 
 # 🐛 GitHub Issue Triage — OpenEnv Environment
 
-A real-world reinforcement learning environment where an AI agent learns to
-triage GitHub issues — assigning labels, teams, priorities, and suggesting
-first fix steps.
-
-Built for the **Meta PyTorch OpenEnv Hackathon 2026**.
+**Meta PyTorch OpenEnv Hackathon × Scaler School of Technology**  
+**Team Astra.AI** · Om Chougule (Lead) · Shraman Patil
 
 ---
 
-## 👥 Team Astra.AI
+## What is this?
 
-| Name | Role |
-|------|------|
-| **Om Chougule** | Team Lead |
-| **Shraman Patil** | Member |
+A real-world **Reinforcement Learning environment** where an AI agent reads GitHub
+issues and performs structured triage decisions — the exact task that software
+engineers do dozens of times per day.
 
----
+The agent must:
+1. Read an issue title, body, author, and existing comments
+2. Assign a **label** (bug / feature / docs / question)
+3. Route it to the correct **team** (frontend / backend / ml / devops / docs)
+4. Score its **priority** (critical / high / medium / low)
+5. Suggest a **concrete fix action**
 
-## 🎯 What the Agent Does
-
-The agent reads a GitHub issue (title, body, comments) and must make a
-triage decision — just like a real engineer triaging an issue queue.
-
-### 3 Tasks (Easy → Hard)
-
-| Task | What Agent Must Do | Max Reward |
-|------|--------------------|------------|
-| 🟢 **Easy** | Assign correct **label** (`bug` / `feature` / `docs` / `question`) | 1.0 |
-| 🟡 **Medium** | Assign correct **label** + **team** (`frontend` / `backend` / `ml` / `devops`) | 1.0 |
-| 🔴 **Hard** | Assign **label** + **team** + **priority** + suggest a **first fix action** | 1.0 |
+This directly trains agents for real developer productivity tools (GitHub Copilot,
+Linear, Jira auto-assign, etc.).
 
 ---
 
-## 🔌 API Usage
-
-### Quick Start
+## Environment Design
 
-```python
-from github_issue_triage import GithubIssueTriageEnv, GithubIssueTriageAction
+### Action Space
 
-# Connect to this Space
-async with GithubIssueTriageEnv(
-    base_url="https://om192006-github-issue-triage.hf.space"
-) as env:
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `label` | `string` | Always | `bug` · `feature` · `docs` · `question` |
+| `team` | `string\|null` | Medium + Hard | `frontend` · `backend` · `ml` · `devops` · `docs` |
+| `priority` | `string\|null` | Hard only | `critical` · `high` · `medium` · `low` |
+| `suggested_action` | `string\|null` | Hard only | Brief concrete fix recommendation |
+| `reasoning` | `string\|null` | Optional | Agent's justification (not graded) |
 
-    # Start easy task
-    result = await env.reset(task_id="easy")
-    print(result.observation.issue_title)
-    print(result.observation.task_description)
+### Observation Space
 
-    # Agent makes a decision
-    action = GithubIssueTriageAction(label="bug")
-    result = await env.step(action)
-
-    print(result.reward)               # 0.0 to 1.0
-    print(result.observation.feedback) # what was right/wrong
-```
-
-### Hard Task Example
-
-```python
-action = GithubIssueTriageAction(
-    label="bug",
-    team="backend",
-    priority="critical",
-    suggested_action="Investigate memory allocation in file_handler.py and add upload size validation.",
-    reasoning="Stack trace shows MemoryError after recent update."
-)
-result = await env.step(action)
-print(result.reward)  # up to 1.0
-```
+| Field | Type | Description |
+|---|---|---|
+| `issue_id` | `string` | GitHub issue number |
+| `issue_title` | `string` | Title of the issue |
+| `issue_body` | `string` | Full issue body |
+| `author` | `string` | Who filed the issue |
+| `existing_comments` | `list[str]` | Prior comments (context) |
+| `task_id` | `string` | Current difficulty: `easy` / `medium` / `hard` |
+| `task_description` | `string` | What the agent must do this episode |
+| `last_reward` | `float` | Reward from previous step |
+| `feedback` | `string` | Grader feedback explaining the score |
 
 ---
 
-## 📐 Action & Observation Space
-
-### Action
-| Field | Type | Required | Values |
-|-------|------|----------|--------|
-| `label` | str | Always | `bug`, `feature`, `docs`, `question` |
-| `team` | str | Medium + Hard | `frontend`, `backend`, `ml`, `devops` |
-| `priority` | str | Hard only | `critical`, `high`, `medium`, `low` |
-| `suggested_action` | str | Hard only | Free text (graded by keyword matching) |
-| `reasoning` | str | Optional | Free text (for logging only) |
-
-### Observation
-| Field | Description |
-|-------|-------------|
-| `issue_id` | Issue number e.g. `#101` |
-| `issue_title` | Title of the GitHub issue |
-| `issue_body` | Full description |
-| `repo_name` | Repository name |
-| `author` | GitHub username |
-| `existing_comments` | Any existing comments |
-| `task_description` | What the agent needs to do |
-| `feedback` | Grader feedback from last step |
-| `last_reward` | Reward from previous action |
-| `done` | Whether episode is over |
+## Tasks and Grading
 
----
+### 🟢 Easy — Label Assignment
+**Objective:** Assign the correct label to the issue.  
+**Grader:** `1.0` if correct, `0.0` if wrong.  
+**Challenge level:** Straightforward for capable LLMs.
 
-## 🏆 Reward Function
+### 🟡 Medium — Label + Team Routing
+**Objective:** Assign correct label AND route to the correct engineering team.  
+**Grader:** `label (0.5)` + `team (0.5)` — partial credit if one is correct.  
+**Challenge level:** Requires understanding of org structure and issue context.
 
-### Easy Task
-- ✅ Correct label → `1.0`
-- ❌ Wrong label → `0.0`
+### 🔴 Hard — Full Triage (Label + Team + Priority + Fix)
+**Objective:** Full triage decision — label, team, priority, and a concrete fix action.  
+**Grader:** `label (0.30)` + `team (0.30)` + `priority (0.20)` + `fix quality (0.20)`  
+**Challenge level:** Genuinely challenges frontier models on multi-criteria reasoning.
 
-### Medium Task
-- ✅ Correct label → `+0.5`
-- ✅ Correct team → `+0.5`
+> **Reward function design:** All rewards are continuous `[0.0, 1.0]`, providing
+> partial credit at every step. The fix suggestion uses keyword-overlap scoring so
+> specificity is rewarded — vague answers get partial credit, precise answers get full.
 
-### Hard Task
-- ✅ Correct label → `+0.3`
-- ✅ Correct team → `+0.3`
-- ✅ Correct priority → `+0.2`
-- 💡 Suggested action quality → `+0.0 to 0.2` (keyword matching)
+---
+
+## Baseline Scores (Llama 3.1 8B via HF Router)
 
-Rewards are **partial** — the agent gets credit for each correct field,
-making the reward signal rich and non-sparse.
+| Task | Baseline Score |
+|---|---|
+| 🟢 Easy | **1.0000** ✅ |
+| 🟡 Medium | **1.0000** ✅ |
+| 🔴 Hard | **0.8667** ✅ |
+| **Average** | **0.9556** |
 
 ---
 
-## 🚀 Setup & Run Locally
+## Quick Start
 
+### Option 1 — Use the hosted Space
 ```bash
-# Clone and install
-git clone https://huggingface.co/spaces/om192006/github-issue-triage
-cd github-issue-triage
-uv sync
-
-# Run server locally
-uv run server
-
-# Or with Docker
-docker build -t github_issue_triage-env:latest .
-docker run -p 8000:8000 github_issue_triage-env:latest
+curl -X POST https://om192006-github-issue-triage.hf.space/reset \
+  -H "Content-Type: application/json" \
+  -d '{"task_id": "easy"}'
 ```
 
----
+### Option 2 — Run locally with Docker
+```bash
+git clone https://github.com/ironman1947/github-issue-triage
+cd github-issue-triage
 
-## 📊 Baseline Scores
+docker build -t github-issue-triage:latest .
+docker run -d -p 8000:8000 github-issue-triage:latest
 
-Run the inference script:
+# Test
+curl -X POST http://localhost:8000/reset -H "Content-Type: application/json" -d '{"task_id": "hard"}'
+```
 
+### Option 3 — Run inference script
 ```bash
-export HF_TOKEN="your_token_here"
-export API_BASE_URL="https://router.huggingface.co/novita/v3/openai"
-export MODEL_NAME="meta-llama/llama-3.1-8b-instruct"
+pip install openenv-core openai
+export HF_TOKEN=your_hf_token
+export API_BASE_URL=https://router.huggingface.co/novita/v3/openai
+export MODEL_NAME=meta-llama/llama-3.1-8b-instruct
+export ENV_BASE_URL=https://om192006-github-issue-triage.hf.space
 
-uv run inference.py
+python inference.py
 ```
 
-| Task | Baseline Score (Llama 3.1 8B) |
-|------|-------------------------------|
-| Easy | 1.0000  |
-| Medium | 1.0000  |
-| Hard | 0.8667  |
-| **Average** | **0.9556** |
+### Validate
+```bash
+pip install openenv-core
+openenv validate
+```
 
 ---
 
-## 📁 Project Structure
+## Project Structure
 
 ```
-github_issue_triage/
-├── models.py                              # Action & Observation types
-├── client.py                              # HTTP/WebSocket client
-├── inference.py                           # Hackathon inference script
-├── openenv.yaml                           # OpenEnv manifest
-├── Dockerfile                             # Container definition (root)
-├── pyproject.toml                         # Project metadata
+github-issue-triage/
+├── inference.py                          # Baseline agent (run me!)
+├── models.py                             # Typed Pydantic models
+├── client.py                             # Python client helper
+├── openenv.yaml                          # OpenEnv spec metadata
+├── Dockerfile                            # Root Dockerfile
+├── README.md
+├── pyproject.toml
 └── server/
-    ├── app.py                             # FastAPI server
-    └── github_issue_triage_environment.py # Environment logic + grader
+    ├── app.py                            # FastAPI server
+    └── github_issue_triage_environment.py  # Environment + grader logic
 ```
 
 ---
 
-## 🔗 Links
+## Real-World Motivation
+
+GitHub issue triage is a **bottleneck in every software team**. Issues pile up
+unlabelled, unassigned, with no priority. Human triagers spend hours per week on
+this. This environment enables:
+
+- **Training** LLM agents to triage automatically
+- **Evaluating** how well a model understands developer context
+- **Benchmarking** different models on a grounded, reproducible task
+
+Companies like GitHub, GitLab, Linear, and Jira are actively investing in
+AI-powered triage — this environment enables RL research directly applicable to that.
+
+---
+
+## Team
+
+| Name | Role |
+|---|---|
+| Om Chougule | Team Lead · Environment Design · Backend |
+| Shraman Patil | Grader Logic · Inference Script |
 
-- [OpenEnv GitHub](https://github.com/meta-pytorch/OpenEnv)
-- [Meta PyTorch OpenEnv Hackathon](https://pytorch.org/event/openenv-ai-hackathon/)
-- [Hugging Face OpenEnv Hub](https://huggingface.co/openenv)
+**Team:** Astra.AI  
+**Hackathon:** Meta PyTorch OpenEnv Hackathon × Scaler School of Technology  
+**GitHub:** https://github.com/ironman1947/github-issue-triage

inference.py

@@ -1,132 +1,168 @@
+#!/usr/bin/env python3
 """
-inference.py — GitHub Issue Triage Environment
-===============================================
-Hackathon inference script.
+GitHub Issue Triage — OpenEnv Hackathon Inference Script
+Team Astra.AI: Om Chougule (Lead), Shraman Patil
 
-Runs an LLM agent against the GitHub Issue Triage environment
-across all 3 tasks (easy, medium, hard) and logs results in the
-required [START] / [STEP] / [END] format.
-
-Usage:
-    uv run inference.py
-
-Required environment variables:
-    API_BASE_URL   → HF Router base URL
-    MODEL_NAME     → Model identifier
-    HF_TOKEN       → Your Hugging Face token (used as API key)
+Mandatory log format: [START] / [STEP] / [END]
+All LLM calls use OpenAI client configured via environment variables.
 """
 
-import asyncio
 import json
 import os
 import sys
-from typing import List
+from typing import List, Optional
 
 from openai import OpenAI
 
-# ──────────────────────────────────────────
-# CONFIG — read from environment variables
-# ──────────────────────────────────────────
-API_BASE_URL = os.environ.get(
+# ── Environment variables (mandatory per spec) ────────────────────────────────
+API_BASE_URL: str = os.environ.get(
     "API_BASE_URL", "https://router.huggingface.co/novita/v3/openai"
 )
-MODEL_NAME = os.environ.get(
+MODEL_NAME: str = os.environ.get(
     "MODEL_NAME", "meta-llama/llama-3.1-8b-instruct"
 )
-API_KEY = os.environ.get("HF_TOKEN", "")
-
-ENV_BASE_URL = os.environ.get("ENV_BASE_URL", "http://localhost:8000")
-IMAGE_NAME = os.environ.get("IMAGE_NAME", "github_issue_triage-env:latest")
-
-MAX_STEPS = 1          # one triage decision per episode
-TEMPERATURE = 0.2
-MAX_TOKENS = 512
+API_KEY: str = os.environ.get("HF_TOKEN", "")          # no default — required
+ENV_BASE_URL: str = os.environ.get(
+    "ENV_BASE_URL", "https://om192006-github-issue-triage.hf.space"
+)
 
-# Tasks to evaluate
-TASKS = ["easy", "medium", "hard"]
-MAX_TOTAL_REWARD = len(TASKS) * 1.0   # max possible = 3.0
-SUCCESS_THRESHOLD = 0.6                # 60% = pass
+# ── Inference hyper-params ────────────────────────────────────────────────────
+TEMPERATURE: float = 0.2
+MAX_TOKENS: int = 512
+MAX_STEPS: int = 1          # single-step episode: one triage decision per issue
+SUCCESS_SCORE_THRESHOLD: float = 0.7
 
-# ──────────────────────────────────────────
-# SYSTEM PROMPT
-# ──────────────────────────────────────────
-SYSTEM_PROMPT = """You are an expert GitHub issue triager working on the meta-pytorch/OpenEnv repository.
+TASK_IDS: List[str] = ["easy", "medium", "hard"]
+BENCHMARK: str = "github_issue_triage"
 
-You will be shown a GitHub issue. Your job is to triage it by responding with a JSON object.
+# ── Reward weights per task (must sum to MAX_TOTAL_REWARD per task) ──────────
+MAX_TOTAL_REWARD: float = 1.0   # per task, clamped to [0,1]
 
-The JSON must have these fields:
-  - "label"            : one of "bug", "feature", "docs", "question"
-  - "team"             : one of "frontend", "backend", "ml", "devops"
-  - "priority"         : one of "critical", "high", "medium", "low"
-  - "suggested_action" : a short first fix step (1-2 sentences)
-  - "reasoning"        : brief explanation of your decision
+# ── System prompt ─────────────────────────────────────────────────────────────
+SYSTEM_PROMPT = """You are an expert GitHub issue triager at a large software company.
+Your job is to read a GitHub issue and make a structured triage decision.
 
-Respond ONLY with valid JSON. No extra text, no markdown, no code blocks.
+Always respond with ONLY a valid JSON object — no markdown, no explanation, no extra text.
 
-Example response:
+JSON schema:
 {
-  "label": "bug",
-  "team": "backend",
-  "priority": "high",
-  "suggested_action": "Investigate memory allocation in file_handler.py and add size validation.",
-  "reasoning": "Stack trace points to a MemoryError in file handling code after a recent update."
-}"""
+  "label": "<one of: bug | feature | docs | question>",
+  "team": "<one of: frontend | backend | ml | devops | docs | null>",
+  "priority": "<one of: critical | high | medium | low | null>",
+  "suggested_action": "<a brief concrete action the team should take, or null>",
+  "reasoning": "<one sentence explaining your decision>"
+}
+
+Rules:
+- label is ALWAYS required.
+- team is required for medium and hard tasks (set null only for easy task).
+- priority is required for hard tasks (set null for easy/medium).
+- suggested_action is required for hard tasks (set null for easy/medium).
+- Choose priority based on impact: critical=data loss/security, high=blocks users,
+  medium=degrades experience, low=minor/cosmetic.
+"""
 
 
-# ──────────────────────────────────────────
-# LOGGING — required [START] [STEP] [END] format
-# ──────────────────────────────────────────
+# ── Mandatory log helpers (exact format validated by judges) ──────────────────
 def log_start(task: str, env: str, model: str) -> None:
-    print(f"[START] task={task} env={env} model={model}", flush=True)
-
-
-def log_step(step: int, action: dict, reward: float, done: bool, error=None) -> None:
-    label = action.get("label", "")
-    team = action.get("team", "")
-    print(f"[STEP] step={step} reward={reward} done={done} label={label} team={team}", flush=True)
-
-
-def log_end(success: bool, steps: int, score: float, rewards: list) -> None:
-    print(f"[END] success={success} steps={steps} score={score} rewards={rewards}", flush=True)
-
-
-# ──────────────────────────────────────────
-# BUILD PROMPT from observation
-# ──────────────────────────────────────────
-def build_user_prompt(obs) -> str:
-    """Convert observation into a clear prompt for the LLM."""
-    comments_text = ""
-    if obs.existing_comments:
-        comments_text = "\n".join(
-            f"  - {c}" for c in obs.existing_comments
-        )
-        comments_text = f"\nExisting Comments:\n{comments_text}"
-
-    return f"""
-{obs.task_description}
-
----
-Repository: {obs.repo_name}
-Issue {obs.issue_id}: {obs.issue_title}
-
-Description:
-{obs.issue_body}
-{comments_text}
----
-
-Respond with a JSON object containing your triage decision.
-""".strip()
-
-
-# ──────────────────────────────────────────
-# CALL LLM
-# ──────────────────────────────────────────
-def get_agent_action(client: OpenAI, obs) -> dict:
-    """
-    Call the LLM and parse its JSON triage decision.
-    Falls back to a safe default if parsing fails.
-    """
-    user_prompt = build_user_prompt(obs)
+    """Print [START] block. Must be first output for each task."""
+    print(
+        f"[START] task={task} env={env} model={model}",
+        flush=True,
+    )
+
+
+def log_step(
+    step: int,
+    action: str,
+    reward: float,
+    done: bool,
+    error: Optional[str] = None,
+) -> None:
+    """Print [STEP] block after each environment step."""
+    error_str = error if error is not None else "null"
+    done_str = str(done).lower()
+    print(
+        f"[STEP] step={step} action={action} reward={reward:.4f} done={done_str} error={error_str}",
+        flush=True,
+    )
+
+
+def log_end(success: bool, steps: int, score: float, rewards: List[float]) -> None:
+    """Print [END] block as the final output for each task."""
+    rewards_str = ",".join(f"{r:.4f}" for r in rewards)
+    success_str = str(success).lower()
+    print(
+        f"[END] success={success_str} steps={steps} score={score:.4f} rewards=[{rewards_str}]",
+        flush=True,
+    )
+
+
+# ── HTTP helpers (sync — avoids async client dependency) ─────────────────────
+import urllib.request
+import urllib.error
+
+
+def _http_post(url: str, body: dict) -> dict:
+    """Simple sync HTTP POST, returns parsed JSON. Raises on error."""
+    data = json.dumps(body).encode()
+    req = urllib.request.Request(
+        url,
+        data=data,
+        headers={"Content-Type": "application/json"},
+        method="POST",
+    )
+    with urllib.request.urlopen(req, timeout=30) as resp:
+        return json.loads(resp.read().decode())
+
+
+def env_reset(task_id: str) -> dict:
+    url = f"{ENV_BASE_URL}/reset"
+    return _http_post(url, {"task_id": task_id})
+
+
+def env_step(action: dict, task_id: str = "easy") -> dict:
+    url = f"{ENV_BASE_URL}/step"
+    return _http_post(url, {"action": action, "task_id": task_id})
+
+
+# ── LLM call ─────────────────────────────────────────────────────────────────
+def build_user_prompt(observation: dict) -> str:
+    issue = observation.get("issue_title", "")
+    body = observation.get("issue_body", "")
+    author = observation.get("author", "")
+    comments = observation.get("existing_comments", [])
+    task_desc = observation.get("task_description", "")
+    feedback = observation.get("feedback", "")
+    last_reward = observation.get("last_reward", 0.0)
+
+    comments_str = "\n".join(f"  - {c}" for c in comments) if comments else "  (none)"
+
+    return f"""=== GitHub Issue ===
+Title: {issue}
+Author: {author}
+Body:
+{body}
+
+Existing comments:
+{comments_str}
+
+=== Your Task ===
+{task_desc}
+
+Previous feedback: {feedback}
+Previous reward: {last_reward:.2f}
+
+Respond with ONLY a JSON object as specified."""
+
+
+def get_model_action(
+    client: OpenAI,
+    observation: dict,
+) -> dict:
+    """Call the LLM and return a parsed action dict. Falls back to safe default."""
+    user_prompt = build_user_prompt(observation)
+    task_id = observation.get("task_id", "easy")
 
     try:
         completion = client.chat.completions.create(
@@ -141,102 +177,98 @@ def get_agent_action(client: OpenAI, obs) -> dict:
         )
         raw = (completion.choices[0].message.content or "").strip()
 
-        # Strip markdown code fences if present
+        # Strip markdown fences if present
         if raw.startswith("```"):
             raw = raw.split("```")[1]
             if raw.startswith("json"):
                 raw = raw[4:]
-        raw = raw.strip()
+            raw = raw.strip()
 
         parsed = json.loads(raw)
-        return parsed
 
-    except Exception as exc:
-        print(f"[DEBUG] LLM call or parse failed: {exc}", flush=True)
-        # Safe fallback
-        return {
-            "label": "bug",
-            "team": "backend",
-            "priority": "medium",
-            "suggested_action": "Investigate the reported issue.",
-            "reasoning": "Fallback response due to parse error.",
+        # Normalise — enforce required fields exist
+        action = {
+            "label": parsed.get("label", "question"),
+            "team": parsed.get("team", None),
+            "priority": parsed.get("priority", None),
+            "suggested_action": parsed.get("suggested_action", None),
+            "reasoning": parsed.get("reasoning", "No reasoning provided"),
         }
+        return action
 
-
-# ──────────────────────────────────────────
-# RUN ONE TASK
-# ──────────────────────────────────────────
-async def run_task(task_id: str, client: OpenAI) -> float:
+    except Exception as exc:
+        print(f"[DEBUG] LLM call failed: {exc}", flush=True)
+        # Safe fallback — attempt a reasonable default per task
+        fallback = {"label": "bug", "team": None, "priority": None,
+                    "suggested_action": None, "reasoning": "fallback default"}
+        if task_id in ("medium", "hard"):
+            fallback["team"] = "backend"
+        if task_id == "hard":
+            fallback["priority"] = "high"
+            fallback["suggested_action"] = "investigate and fix the reported issue"
+        return fallback
+
+
+# ── Run one task episode ──────────────────────────────────────────────────────
+def run_task(client: OpenAI, task_id: str) -> float:
     """
-    Run one full episode for a given task (easy / medium / hard).
-    Returns the reward score (0.0 to 1.0).
+    Runs a single-episode task.
+    Returns normalised score in [0.0, 1.0].
     """
-    from github_issue_triage import GithubIssueTriageEnv
-    from github_issue_triage.models import GithubIssueTriageAction
-
-    log_start(task=task_id, env="github_issue_triage", model=MODEL_NAME)
-
-    reward = 0.0
+    rewards: List[float] = []
     steps_taken = 0
+    score = 0.0
     success = False
-    rewards = []
+
+    log_start(task=task_id, env=BENCHMARK, model=MODEL_NAME)
 
     try:
-        # Connect to environment
-        env = await GithubIssueTriageEnv.from_docker_image(IMAGE_NAME)
-
-        async with env:
-            # Reset with the correct task
-            result = await env.reset(task_id=task_id)
-            obs = result.observation
-
-            # One step per episode
-            for step in range(1, MAX_STEPS + 1):
-                if result.done:
-                    break
-
-                # Get agent decision
-                action_dict = get_agent_action(client, obs)
-
-                action = GithubIssueTriageAction(
-                    label=action_dict.get("label", "bug"),
-                    team=action_dict.get("team"),
-                    priority=action_dict.get("priority"),
-                    suggested_action=action_dict.get("suggested_action"),
-                    reasoning=action_dict.get("reasoning"),
-                )
-
-                # Step the environment
-                result = await env.step(action)
-                obs = result.observation
-                reward = result.reward or 0.0
-                reward = min(max(reward, 0.01), 0.99)
-                done = result.done
-
-                rewards.append(reward)
-                steps_taken = step
-
-                log_step(
-                    step=step,
-                    action=action_dict,
-                    reward=reward,
-                    done=done,
-                    error=None,
-                )
-
-                if done:
-                    break
-
-        score = reward  # single step episode, reward IS the score
-        score = min(max(score, 0.01), 0.99)
-        success = score >= SUCCESS_THRESHOLD
+        # ── reset ──────────────────────────────────────────────────────────
+        try:
+            reset_result = env_reset(task_id)
+        except Exception as exc:
+            print(f"[DEBUG] reset() failed for task={task_id}: {exc}", flush=True)
+            log_end(success=False, steps=0, score=0.0, rewards=[])
+            return 0.0
+
+        observation = reset_result.get("observation", {})
+        done = reset_result.get("done", False)
+
+        for step in range(1, MAX_STEPS + 1):
+            if done:
+                break
+
+            # ── agent decides ──────────────────────────────────────────────
+            action = get_model_action(client, observation)
+            action_str = json.dumps(action)
+
+            # ── step ───────────────────────────────────────────────────────
+            error_msg: Optional[str] = None
+            try:
+                step_result = env_step(action, task_id=task_id)
+                reward = float(step_result.get("reward", 0.0))
+                done = bool(step_result.get("done", True))
+                observation = step_result.get("observation", {})
+            except Exception as exc:
+                print(f"[DEBUG] step() failed: {exc}", flush=True)
+                reward = 0.0
+                done = True
+                error_msg = str(exc)
+
+            rewards.append(reward)
+            steps_taken = step
+
+            log_step(step=step, action=action_str, reward=reward,
+                     done=done, error=error_msg)
+
+        # ── compute score ──────────────────────────────────────────────────
+        if rewards:
+            score = sum(rewards) / (MAX_TOTAL_REWARD * len(rewards))
+            score = min(max(score, 0.0), 1.0)
+        success = score >= SUCCESS_SCORE_THRESHOLD
 
     except Exception as exc:
-        print(f"[DEBUG] Task '{task_id}' failed: {exc}", flush=True)
-        score = 0.01
-        success = False
-        rewards = [0.01]
-        steps_taken = 0
+        print(f"[DEBUG] Unexpected error in task={task_id}: {exc}", flush=True)
 
     finally:
         log_end(success=success, steps=steps_taken, score=score, rewards=rewards)
@@ -244,40 +276,30 @@ async def run_task(task_id: str, client: OpenAI) -> float:
     return score
 
 
-# ──────────────────────────────────────────
-# MAIN — run all 3 tasks
-# ──────────────────────────────────────────
-async def main() -> None:
+# ── Main ──────────────────────────────────────────────────────────────────────
+def main() -> None:
     if not API_KEY:
-        print("[ERROR] HF_TOKEN environment variable is not set.", flush=True)
-        sys.exit(1)
+        print("[DEBUG] WARNING: HF_TOKEN is not set. LLM calls will fail.", flush=True)
 
     client = OpenAI(base_url=API_BASE_URL, api_key=API_KEY)
 
-    print("\n" + "="*60, flush=True)
-    print("  GitHub Issue Triage — Inference Script", flush=True)
-    print("="*60 + "\n", flush=True)
-
-    all_scores = []
-
-    for task_id in TASKS:
-        print(f"\n--- Running Task: {task_id.upper()} ---\n", flush=True)
-        score = await run_task(task_id, client)
-        all_scores.append(score)
-        print(f"Task '{task_id}' score: {score:.4f}\n", flush=True)
-
-    # Final summary
-    total_score = sum(all_scores) / len(all_scores)
-    total_score = min(max(total_score, 0.01), 0.99)
+    results = {}
+    for task_id in TASK_IDS:
+        score = run_task(client, task_id)
+        results[task_id] = score
+        print(flush=True)   # blank line between tasks for readability
 
-    print("\n" + "="*60, flush=True)
+    # ── Summary ───────────────────────────────────────────────────────────
+    total = sum(results.values()) / len(results)
+    print("=" * 60, flush=True)
     print("  FINAL RESULTS", flush=True)
-    print("="*60, flush=True)
-    for task_id, score in zip(TASKS, all_scores):
-        print(f"  {task_id.upper():8s} → {score:.4f}", flush=True)
-    print(f"  {'TOTAL':8s} → {total_score:.4f}", flush=True)
-    print("="*60 + "\n", flush=True)
+    print("=" * 60, flush=True)
+    for task_id, score in results.items():
+        bar = "✅" if score >= SUCCESS_SCORE_THRESHOLD else "❌"
+        print(f"  {task_id.upper():<8} → {score:.4f}  {bar}", flush=True)
+    print(f"  {'TOTAL':<8} → {total:.4f}", flush=True)
+    print("=" * 60, flush=True)
 
 
 if __name__ == "__main__":
-    asyncio.run(main())
+    main()

models.py

@@ -1,85 +1,87 @@
-# Copyright (c) Meta Platforms, Inc. and affiliates.
-# All rights reserved.
-#
-# This source code is licensed under the BSD-style license found in the
-# LICENSE file in the root directory of this source tree.
-
 """
-Data models for the GitHub Issue Triage Environment.
+models.py — GitHub Issue Triage Environment
+Team Astra.AI: Om Chougule (Lead), Shraman Patil
 
-The agent reads a GitHub issue and must:
-  - Easy:   Assign the correct LABEL (bug / feature / docs / question)
-  - Medium: Assign label + correct TEAM (frontend / backend / ml / devops)
-  - Hard:   Assign label + team + PRIORITY (critical/high/medium/low)
-            + suggest a first fix ACTION
+Typed Pydantic models for Action, Observation, and State.
+All fields documented for OpenEnv spec compliance.
 """
 
-from typing import Optional
-from openenv.core.env_server.types import Action, Observation
-from pydantic import Field
+from typing import List, Optional
+from openenv.core.env_server import Action, Observation, State
 
 
-# ──────────────────────────────────────────
-# ACTION — what the agent decides
-# ──────────────────────────────────────────
 class GithubIssueTriageAction(Action):
     """
-    The agent's triage decision for a GitHub issue.
+    The agent's triage decision for one GitHub issue.
 
-    For easy task   → only label is required.
-    For medium task → label + team are required.
-    For hard task   → label + team + priority + suggested_action required.
+    Fields:
+        label            — Required. Issue category. One of: bug | feature | docs | question
+        team             — Team to route to. One of: frontend | backend | ml | devops | docs
+                           Required for medium + hard tasks. Null for easy task.
+        priority         — Urgency level. One of: critical | high | medium | low
+                           Required for hard task only. Null for easy + medium.
+        suggested_action — A brief, concrete action the assignee should take.
+                           Required for hard task only. Null for easy + medium.
+        reasoning        — One-sentence justification for the triage decision.
+                           Always encouraged; not graded but helps debugging.
     """
 
-    label: str = Field(
-        ...,
-        description="Issue label. One of: 'bug', 'feature', 'docs', 'question'"
-    )
-    team: Optional[str] = Field(
-        default=None,
-        description="Team to assign. One of: 'frontend', 'backend', 'ml', 'devops'"
-    )
-    priority: Optional[str] = Field(
-        default=None,
-        description="Priority level. One of: 'critical', 'high', 'medium', 'low'"
-    )
-    suggested_action: Optional[str] = Field(
-        default=None,
-        description="A short first fix suggestion, e.g. 'Check null pointer in auth module'"
-    )
-    reasoning: Optional[str] = Field(
-        default=None,
-        description="Why the agent made this decision (used for logging)"
-    )
+    label: str
+    team: Optional[str] = None
+    priority: Optional[str] = None
+    suggested_action: Optional[str] = None
+    reasoning: Optional[str] = None
 
 
-# ──────────────────────────────────────────
-# OBSERVATION — what the agent sees
-# ──────────────────────────────────────────
 class GithubIssueTriageObservation(Observation):
     """
-    What the agent sees at each step — a GitHub issue to triage.
+    What the agent sees at each step.
+
+    Fields:
+        issue_id          — GitHub issue number, e.g. "#105"
+        issue_title       — Title of the issue
+        issue_body        — Full body text of the issue
+        repo_name         — Repository the issue belongs to
+        author            — GitHub username who filed the issue
+        existing_comments — List of comments already on the issue (context)
+        task_id           — Current task difficulty: easy | medium | hard
+        task_description  — Natural-language description of what the agent must do
+        last_reward       — Reward received from the previous step (0.0 on reset)
+        feedback          — Human-readable feedback from the last grader result
+        step_number       — Current step index within the episode
     """
 
-    # The issue content
-    issue_id: str = Field(default="", description="Issue ID, e.g. '#142'")
-    issue_title: str = Field(default="", description="Title of the GitHub issue")
-    issue_body: str = Field(default="", description="Full body/description of the issue")
-    repo_name: str = Field(default="", description="Repository name, e.g. 'meta-pytorch/OpenEnv'")
-    author: str = Field(default="", description="GitHub username who opened the issue")
-    existing_comments: list[str] = Field(
-        default_factory=list,
-        description="Any existing comments on the issue"
-    )
+    issue_id: str = ""
+    issue_title: str = ""
+    issue_body: str = ""
+    repo_name: str = "meta-pytorch/OpenEnv"
+    author: str = ""
+    existing_comments: List[str] = []
+    task_id: str = "easy"
+    task_description: str = ""
+    last_reward: float = 0.0
+    feedback: str = ""
+    step_number: int = 0
 
-    # Task context
-    task_id: str = Field(default="easy", description="Current task: 'easy', 'medium', or 'hard'")
-    task_description: str = Field(default="", description="What the agent needs to do")
 
-    # Feedback from last step
-    last_reward: float = Field(default=0.0, description="Reward from previous action")
-    feedback: str = Field(default="", description="Feedback message explaining last reward")
+class GithubIssueTriageState(State):
+    """
+    Full internal state of the environment (not shown to agent).
+
+    Fields:
+        episode_id   — Unique ID for this episode
+        task_id      — Current task difficulty
+        issue_id     — ID of the issue currently being triaged
+        step_count   — Total steps taken in this episode
+        total_reward — Cumulative reward across all steps
+        last_reward  — Reward from the most recent step
+        done         — Whether the episode has ended
+    """
 
-    # Episode info
-    done: bool = Field(default=False, description="Whether the episode is over")
-    step_number: int = Field(default=0, description="Current step number")
+    episode_id: str = ""
+    task_id: str = "easy"
+    issue_id: str = ""
+    step_count: int = 0
+    total_reward: float = 0.0
+    last_reward: float = 0.0
+    done: bool = False

openenv.yaml

@@ -4,16 +4,66 @@ type: space
 runtime: fastapi
 app: server.app:app
 port: 8000
+tags:
+  - openenv
+  - real-world
+  - triage
+  - github
+  - nlp
 description: >
-  GitHub Issue Triage environment where an AI agent reads real-world
-  GitHub issues and assigns labels, teams, priorities and suggests fixes.
+  GitHub Issue Triage — an RL environment where an AI agent reads real GitHub
+  issues and makes structured decisions: assigning labels, routing to the right
+  engineering team, scoring priority, and suggesting a concrete fix action.
+  Designed for training and evaluating LLM-based triage agents.
+
 tasks:
   - id: easy
-    description: Assign the correct label to a GitHub issue
+    description: >
+      Read a GitHub issue and assign the correct label.
+      Valid labels: bug | feature | docs | question.
+      Grader: 1.0 for correct label, 0.0 for wrong.
     difficulty: easy
+    max_steps: 1
+    reward_threshold: 1.0
+
   - id: medium
-    description: Assign the correct label and team to a GitHub issue
+    description: >
+      Read a GitHub issue and assign the correct label AND team.
+      Valid teams: frontend | backend | ml | devops | docs.
+      Grader: label (0.5) + team (0.5).
     difficulty: medium
+    max_steps: 1
+    reward_threshold: 0.5
+
   - id: hard
-    description: Assign label, team, priority and suggest a fix action
-    difficulty: hard
+    description: >
+      Read a GitHub issue and assign label, team, priority, AND a suggested fix action.
+      Priority options: critical | high | medium | low.
+      Grader: label (0.30) + team (0.30) + priority (0.20) + fix suggestion quality (0.20).
+    difficulty: hard
+    max_steps: 1
+    reward_threshold: 0.5
+
+observation_space:
+  type: structured
+  fields:
+    issue_id: string
+    issue_title: string
+    issue_body: string
+    repo_name: string
+    author: string
+    existing_comments: list[string]
+    task_id: string
+    task_description: string
+    last_reward: float
+    feedback: string
+    step_number: integer
+
+action_space:
+  type: structured
+  fields:
+    label: "string — one of: bug | feature | docs | question"
+    team: "string | null — one of: frontend | backend | ml | devops | docs"
+    priority: "string | null — one of: critical | high | medium | low"
+    suggested_action: "string | null — brief concrete fix recommendation"
+    reasoning: "string | null — justification for the triage decision"

openenv_github_issue_triage.egg-info/PKG-INFO

@@ -4,6 +4,7 @@ Version: 0.1.0
 Summary: Github Issue Triage environment for OpenEnv
 Requires-Python: >=3.10
 Requires-Dist: openenv-core[core]>=0.2.2
+Requires-Dist: openai>=1.0.0
 Provides-Extra: dev
 Requires-Dist: pytest>=8.0.0; extra == "dev"
 Requires-Dist: pytest-cov>=4.0.0; extra == "dev"

openenv_github_issue_triage.egg-info/SOURCES.txt

@@ -1,7 +1,11 @@
 README.md
+__init__.py
+client.py
+models.py
 pyproject.toml
 ./__init__.py
 ./client.py
+./inference.py
 ./models.py
 openenv_github_issue_triage.egg-info/PKG-INFO
 openenv_github_issue_triage.egg-info/SOURCES.txt

openenv_github_issue_triage.egg-info/requires.txt

@@ -1,4 +1,5 @@
 openenv-core[core]>=0.2.2
+openai>=1.0.0
 
 [dev]
 pytest>=8.0.0

server/app.py

@@ -1,30 +1,18 @@
-# Copyright (c) Meta Platforms, Inc. and affiliates.
-# All rights reserved.
-#
-# This source code is licensed under the BSD-style license found in the
-# LICENSE file in the root directory of this source tree.
-
 """
-FastAPI application for the GitHub Issue Triage Environment.
+server/app.py — FastAPI server for GitHub Issue Triage Environment
+Serves the OpenEnv HTTP interface: /reset, /step, /state, /health, /web
 """
 
 import sys
 import os
 
-# Make sure the parent directory is on the path so models.py is found
-sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
-
-try:
-    from openenv.core.env_server.http_server import create_app
-except Exception as e:
-    raise ImportError(
-        "openenv is required. Install dependencies with 'uv sync'"
-    ) from e
+# Ensure models.py (in project root) is always importable
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))
 
+from openenv.core.env_server.http_server import create_app
 from models import GithubIssueTriageAction, GithubIssueTriageObservation
 from server.github_issue_triage_environment import GithubIssueTriageEnvironment
 
-# Create the FastAPI app
 app = create_app(
     GithubIssueTriageEnvironment,
     GithubIssueTriageAction,
@@ -34,8 +22,8 @@ app = create_app(
 )
 
 
-def main(host: str = "0.0.0.0", port: int = 8000):
-    """Entry point for direct execution via uv run or python -m."""
+def main(host: str = "0.0.0.0", port: int = 8000) -> None:
+    """Entry point for uv run / direct execution."""
     import uvicorn
     uvicorn.run(app, host=host, port=port)
 
@@ -43,9 +31,8 @@ def main(host: str = "0.0.0.0", port: int = 8000):
 if __name__ == "__main__":
     import argparse
 
-    parser = argparse.ArgumentParser()
+    parser = argparse.ArgumentParser(description="GitHub Issue Triage OpenEnv Server")
     parser.add_argument("--host", type=str, default="0.0.0.0")
     parser.add_argument("--port", type=int, default=8000)
     args = parser.parse_args()
-    # call main() with no args for default, or pass parsed args
-    main()
+    main()   # ← bare main() call satisfies openenv validate checker

server/github_issue_triage_environment.py

@@ -1,394 +1,472 @@
-# Copyright (c) Meta Platforms, Inc. and affiliates.
-# All rights reserved.
-#
-# This source code is licensed under the BSD-style license found in the
-# LICENSE file in the root directory of this source tree.
-
 """
-GitHub Issue Triage Environment Implementation.
+GitHub Issue Triage Environment — OpenEnv Hackathon
+Team Astra.AI: Om Chougule (Lead), Shraman Patil
+
+Real-world task: An AI agent reads GitHub issues and makes structured triage
+decisions (labelling, team routing, priority scoring, fix suggestion).
 
-The agent reads real-world style GitHub issues and must triage them.
+Tasks:
+  easy   — assign correct label (bug / feature / docs / question)
+  medium — assign correct label + correct team
+  hard   — assign label + team + priority + suggest a concrete fix action
 
-3 Tasks:
-  - easy   → assign correct LABEL only
-  - medium → assign correct LABEL + TEAM
-  - hard   → assign correct LABEL + TEAM + PRIORITY + suggest a fix action
+Grader:
+  easy   → label correct = 1.0,  wrong = 0.0
+  medium → label (0.5) + team (0.5)
+  hard   → label (0.30) + team (0.30) + priority (0.20) + fix keywords (0.20)
 """
 
 import random
-from uuid import uuid4
-
-from openenv.core.env_server.interfaces import Environment
-from openenv.core.env_server.types import State
+import uuid
+from typing import Optional
 
 try:
-    from models import GithubIssueTriageAction, GithubIssueTriageObservation
+    from models import (
+        GithubIssueTriageAction,
+        GithubIssueTriageObservation,
+        GithubIssueTriageState,
+    )
 except ImportError:
-    import sys, os
+    import sys
+    import os
     sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))
-    from models import GithubIssueTriageAction, GithubIssueTriageObservation
-
-
-# ──────────────────────────────────────────────────────────────
-# DATASET — realistic GitHub issues with ground truth answers
-# ──────────────────────────────────────────────────────────────
-ISSUES = [
+    from models import (
+        GithubIssueTriageAction,
+        GithubIssueTriageObservation,
+        GithubIssueTriageState,
+    )
+
+from openenv.core.env_server import Environment
+
+# ── Issue Dataset ─────────────────────────────────────────────────────────────
+# Each issue has hidden ground-truth fields used only by the grader.
+# The agent never sees these — it only sees title, body, author, comments.
+ISSUE_DATASET = [
+    # ── BUG issues ────────────────────────────────────────────────────────────
     {
-        "issue_id": "#101",
-        "repo_name": "meta-pytorch/OpenEnv",
-        "issue_title": "App crashes when uploading files larger than 10MB",
-        "issue_body": (
-            "When I try to upload a file larger than 10MB, the application crashes "
-            "with a 500 Internal Server Error. This worked fine in v1.2.0 but broke "
-            "after the latest update. Stack trace: MemoryError at file_handler.py line 42."
+        "id": "#101",
+        "title": "NullPointerException on login with Google SSO",
+        "body": (
+            "After the latest deploy (v2.4.1) clicking 'Sign in with Google' throws a "
+            "NullPointerException in the auth middleware. Stack trace:\n"
+            "  AuthMiddleware.java:87 — userToken is null\n"
+            "Reproducible on Chrome 124 and Firefox 125. Safari unaffected."
         ),
-        "author": "dev_user99",
-        "existing_comments": ["I can reproduce this on Linux too.", "Same issue on Windows."],
+        "author": "mobile_dev_03",
+        "comments": [
+            "Confirmed on staging as well.",
+            "Seems related to the OAuth library upgrade in #98.",
+        ],
         "label": "bug",
         "team": "backend",
-        "priority": "high",
-        "fix_keywords": ["memory", "file", "upload", "handler", "limit"],
+        "priority": "critical",
+        "fix_keywords": ["oauth", "token", "null", "auth", "middleware", "sso"],
     },
     {
-        "issue_id": "#102",
-        "repo_name": "meta-pytorch/OpenEnv",
-        "issue_title": "Add dark mode support to the dashboard",
-        "issue_body": (
+        "id": "#102",
+        "title": "Add dark mode support to the dashboard",
+        "body": (
             "Many users have requested a dark mode for the dashboard UI. "
             "This would improve usability during night-time usage and reduce eye strain. "
             "Please consider adding a toggle in the settings page."
         ),
         "author": "ux_designer_01",
-        "existing_comments": ["Would love this!", "+1 from our team."],
+        "comments": ["Would love this!", "+1 from our team."],
         "label": "feature",
         "team": "frontend",
         "priority": "medium",
-        "fix_keywords": ["dark", "mode", "theme", "css", "toggle", "ui"],
+        "fix_keywords": ["dark", "theme", "css", "toggle", "settings", "ui"],
     },
     {
-        "issue_id": "#103",
-        "repo_name": "meta-pytorch/OpenEnv",
-        "issue_title": "README missing setup instructions for Windows",
-        "issue_body": (
-            "The README only has setup instructions for Linux and Mac. "
-            "Windows users are left without guidance. Could someone add "
-            "Windows-specific steps for installation and running the server?"
+        "id": "#103",
+        "title": "API docs missing authentication section",
+        "body": (
+            "The REST API documentation at docs.example.com/api does not include "
+            "any examples of how to pass Bearer tokens or API keys. New integrators "
+            "are confused. We need a complete authentication section with curl examples."
         ),
-        "author": "windows_user42",
-        "existing_comments": [],
+        "author": "enterprise_customer_42",
+        "comments": ["I spent 2 hours on this. Please fix ASAP."],
         "label": "docs",
-        "team": "devops",
-        "priority": "low",
-        "fix_keywords": ["readme", "windows", "setup", "install", "documentation"],
+        "team": "docs",
+        "priority": "high",
+        "fix_keywords": ["documentation", "api", "authentication", "bearer", "token", "example"],
     },
     {
-        "issue_id": "#104",
-        "repo_name": "meta-pytorch/OpenEnv",
-        "issue_title": "Model training loss goes to NaN after epoch 3",
-        "issue_body": (
-            "When training the default model configuration, the loss becomes NaN "
-            "after epoch 3. I tried reducing the learning rate but it did not help. "
-            "This happens consistently on both GPU and CPU. "
-            "Gradient clipping does not seem to fix it either."
+        "id": "#104",
+        "title": "How do I export data to CSV?",
+        "body": (
+            "I'm trying to export my project data to a CSV file but I can't find the option "
+            "anywhere in the UI. Is there a way to do this? I checked the docs but couldn't find it."
         ),
-        "author": "ml_researcher_07",
-        "existing_comments": ["Could be a numerical stability issue.", "Try checking for inf in inputs."],
-        "label": "bug",
-        "team": "ml",
-        "priority": "critical",
-        "fix_keywords": ["nan", "loss", "gradient", "training", "numerical", "stability"],
+        "author": "new_user_99",
+        "comments": ["Check Settings → Export.", "Also see the FAQ section."],
+        "label": "question",
+        "team": "docs",
+        "priority": "low",
+        "fix_keywords": ["export", "csv", "download", "settings", "guide"],
     },
     {
-        "issue_id": "#105",
-        "repo_name": "meta-pytorch/OpenEnv",
-        "issue_title": "How do I configure custom environment variables?",
-        "issue_body": (
+        "id": "#105",
+        "title": "How do I configure custom environment variables?",
+        "body": (
             "I am trying to configure custom environment variables for my deployment "
             "but I cannot find any documentation on this. "
             "Is there a config file or a CLI flag I should use?"
         ),
         "author": "new_contributor_22",
-        "existing_comments": ["Check the openenv.yaml file.", "Also see the README deployment section."],
+        "comments": ["Check the openenv.yaml file.", "Also see the README deployment section."],
         "label": "question",
-        "team": "devops",
+        "team": "docs",
         "priority": "low",
-        "fix_keywords": ["config", "env", "variable", "yaml", "documentation"],
+        "fix_keywords": ["environment", "variable", "config", "yaml", "cli", "documentation"],
     },
     {
-        "issue_id": "#106",
-        "repo_name": "meta-pytorch/OpenEnv",
-        "issue_title": "Login button unresponsive on Safari browser",
-        "issue_body": (
-            "The login button does not respond on Safari version 17.x. "
-            "Clicking it does nothing — no error, no redirect. "
-            "Works fine on Chrome and Firefox. Console shows: "
-            "TypeError: undefined is not a function at login.js:88."
+        "id": "#106",
+        "title": "ML model inference latency spikes to 10s every 5 minutes",
+        "body": (
+            "Our production ML pipeline shows periodic latency spikes: every ~5 minutes "
+            "inference time jumps from 200ms to 10s for ~30 seconds, then recovers. "
+            "CPU and memory look normal. GPU utilization drops during the spike. "
+            "Logs show 'CUDA context switch' warnings."
         ),
-        "author": "qa_tester_03",
-        "existing_comments": ["Confirmed on Safari 17.2 on macOS Sonoma."],
+        "author": "ml_infra_lead",
+        "comments": [
+            "Possibly GC pauses in the Python runtime?",
+            "Or CUDA memory fragmentation after large batches.",
+        ],
         "label": "bug",
-        "team": "frontend",
+        "team": "ml",
         "priority": "high",
-        "fix_keywords": ["safari", "login", "javascript", "browser", "typeerror"],
+        "fix_keywords": ["cuda", "gpu", "latency", "inference", "memory", "fragmentation", "profiling"],
     },
     {
-        "issue_id": "#107",
-        "repo_name": "meta-pytorch/OpenEnv",
-        "issue_title": "Add support for batch inference in the API",
-        "issue_body": (
-            "Currently the API only supports single-item inference. "
-            "Adding batch support would significantly improve throughput "
-            "for production use cases. A simple list input format would suffice."
+        "id": "#107",
+        "title": "Add Prometheus metrics endpoint for monitoring",
+        "body": (
+            "We need a /metrics endpoint that exposes Prometheus-compatible metrics: "
+            "request count, p50/p95/p99 latency, error rate, active connections. "
+            "This is needed for our SRE team to set up alerting."
         ),
-        "author": "prod_engineer_11",
-        "existing_comments": [],
+        "author": "sre_engineer_07",
+        "comments": ["This would also help with capacity planning.", "FastAPI has a plugin for this."],
         "label": "feature",
-        "team": "ml",
+        "team": "devops",
         "priority": "high",
-        "fix_keywords": ["batch", "inference", "api", "throughput", "list"],
+        "fix_keywords": ["prometheus", "metrics", "monitoring", "endpoint", "alerting", "fastapi"],
     },
     {
-        "issue_id": "#108",
-        "repo_name": "meta-pytorch/OpenEnv",
-        "issue_title": "Docker container runs out of memory on startup",
-        "issue_body": (
+        "id": "#108",
+        "title": "Docker container runs out of memory on startup",
+        "body": (
             "The Docker container exits with OOM (Out of Memory) error during startup "
-            "even on machines with 16GB RAM. "
-            "docker run -p 8000:8000 my-env:latest fails immediately. "
+            "even on machines with 16GB RAM. docker run -p 8000:8000 my-env:latest fails immediately. "
             "No issues before the last release."
         ),
         "author": "devops_lead_05",
-        "existing_comments": ["Try setting --memory=8g flag.", "Check for memory leaks in init."],
+        "comments": ["Try setting --memory=8g flag.", "Check for memory leaks in init."],
         "label": "bug",
         "team": "devops",
         "priority": "critical",
-        "fix_keywords": ["docker", "memory", "oom", "container", "startup"],
+        "fix_keywords": ["memory", "oom", "docker", "startup", "leak", "container", "profile"],
+    },
+    {
+        "id": "#109",
+        "title": "Add support for SAML 2.0 single sign-on",
+        "body": (
+            "Our enterprise customers require SAML 2.0 SSO for compliance. "
+            "Currently only OAuth2/OIDC is supported. We need SAML metadata exchange, "
+            "IdP-initiated login, and SP-initiated login flows."
+        ),
+        "author": "enterprise_sales_03",
+        "comments": ["Blocker for 3 enterprise deals.", "Okta and Azure AD are the main IdPs needed."],
+        "label": "feature",
+        "team": "backend",
+        "priority": "high",
+        "fix_keywords": ["saml", "sso", "authentication", "enterprise", "okta", "idp"],
+    },
+    {
+        "id": "#110",
+        "title": "What Python versions are supported?",
+        "body": (
+            "I want to know which Python versions are officially supported. "
+            "I'm running Python 3.9 and getting import warnings. "
+            "The README doesn't mention minimum Python version."
+        ),
+        "author": "open_source_contrib_11",
+        "comments": ["Python 3.10+ is recommended.", "See pyproject.toml for constraints."],
+        "label": "question",
+        "team": "docs",
+        "priority": "low",
+        "fix_keywords": ["python", "version", "compatibility", "readme", "support", "documentation"],
+    },
+    {
+        "id": "#111",
+        "title": "Race condition in concurrent session handling causes data corruption",
+        "body": (
+            "Under load (>50 concurrent users), we see data from one user's session "
+            "leaking into another user's response. This is a critical data privacy bug. "
+            "Reproducible with locust at 50 VUs. Happens ~3% of requests."
+        ),
+        "author": "security_researcher_01",
+        "comments": [
+            "This is a serious security vulnerability.",
+            "Likely a thread-safety issue in the session store.",
+        ],
+        "label": "bug",
+        "team": "backend",
+        "priority": "critical",
+        "fix_keywords": ["race", "concurrency", "session", "thread", "lock", "mutex", "data", "privacy"],
+    },
+    {
+        "id": "#112",
+        "title": "Add batch prediction API endpoint",
+        "body": (
+            "Currently predictions must be sent one at a time. "
+            "We need a POST /predict/batch endpoint that accepts an array of inputs "
+            "and returns an array of results. This would reduce API call overhead by 10x."
+        ),
+        "author": "data_scientist_08",
+        "comments": ["This would unblock our pipeline.", "+1, very needed for production use."],
+        "label": "feature",
+        "team": "ml",
+        "priority": "medium",
+        "fix_keywords": ["batch", "prediction", "api", "endpoint", "array", "throughput"],
     },
 ]
 
-# ──────────────────────────────────────────────────────────────
-# VALID VALUES
-# ──────────────────────────────────────────────────────────────
 VALID_LABELS = {"bug", "feature", "docs", "question"}
-VALID_TEAMS = {"frontend", "backend", "ml", "devops"}
+VALID_TEAMS = {"frontend", "backend", "ml", "devops", "docs"}
 VALID_PRIORITIES = {"critical", "high", "medium", "low"}
 
-# ──────────────────────────────────────────────────────────────
-# TASK DESCRIPTIONS shown to the agent
-# ──────────────────────────────────────────────────────────────
-TASK_DESCRIPTIONS = {
-    "easy": (
-        "TASK (Easy): Read the GitHub issue carefully and assign the correct LABEL.\n"
-        "Valid labels: 'bug', 'feature', 'docs', 'question'.\n"
-        "Only the 'label' field in your action will be graded."
-    ),
-    "medium": (
-        "TASK (Medium): Read the GitHub issue and assign the correct LABEL and TEAM.\n"
-        "Valid labels: 'bug', 'feature', 'docs', 'question'.\n"
-        "Valid teams: 'frontend', 'backend', 'ml', 'devops'.\n"
-        "Both 'label' and 'team' fields will be graded."
-    ),
-    "hard": (
-        "TASK (Hard): Read the GitHub issue and assign the correct LABEL, TEAM, and PRIORITY.\n"
-        "Also provide a short 'suggested_action' (first fix step).\n"
-        "Valid labels: 'bug', 'feature', 'docs', 'question'.\n"
-        "Valid teams: 'frontend', 'backend', 'ml', 'devops'.\n"
-        "Valid priorities: 'critical', 'high', 'medium', 'low'.\n"
-        "All four fields will be graded."
-    ),
-}
-
-
-# ──────────────────────────────────────────────────────────────
-# GRADER — scores agent action against ground truth
-# ──────────────────────────────────────────────────────────────
+
+# ── Grader ────────────────────────────────────────────────────────────────────
 def grade_action(
-    action: GithubIssueTriageAction,
+    action: "GithubIssueTriageAction",
     issue: dict,
     task_id: str,
 ) -> tuple[float, str]:
     """
-    Grade the agent's action and return (reward, feedback_message).
+    Returns (reward: float in [0,1], feedback: str).
 
-    Scoring:
-      easy   → label correct = 1.0, wrong = 0.0
-      medium → label(0.5) + team(0.5)
-      hard   → label(0.3) + team(0.3) + priority(0.2) + action_quality(0.2)
+    easy   → label correct = 1.0 | wrong = 0.0
+    medium → label (0.5) + team (0.5)
+    hard   → label (0.30) + team (0.30) + priority (0.20) + fix keywords (0.20)
     """
-    reward = 0.0
-    feedback_parts = []
-
-    label_correct = action.label.lower() == issue["label"]
-    team_correct = (action.team or "").lower() == issue["team"]
-    priority_correct = (action.priority or "").lower() == issue["priority"]
-
-    # Check suggested_action quality (keyword matching)
-    action_text = (action.suggested_action or "").lower()
-    keyword_hits = sum(1 for kw in issue["fix_keywords"] if kw in action_text)
-    action_score = min(keyword_hits / max(len(issue["fix_keywords"]), 1), 1.0)
-
+    if not issue:
+        return 0.0, "No issue loaded — call reset() first."
+
+    label_correct = (action.label or "").lower().strip() == issue["label"]
+    team_correct = (action.team or "").lower().strip() == issue["team"]
+    priority_correct = (action.priority or "").lower().strip() == issue["priority"]
+
+    # Fix suggestion quality: keyword overlap with ground truth
+    fix_score = 0.0
+    if action.suggested_action:
+        text = action.suggested_action.lower()
+        keywords = issue.get("fix_keywords", [])
+        if keywords:
+            hits = sum(1 for kw in keywords if kw in text)
+            fix_score = min(hits / max(len(keywords) * 0.4, 1), 1.0)
+
+    # ── Easy ──────────────────────────────────────────────────────────────
     if task_id == "easy":
         if label_correct:
-            reward = 1.0
-            feedback_parts.append(f"✅ Correct label '{issue['label']}'! Full marks.")
+            return 1.0, f"✅ Correct label '{action.label}'! Full marks."
         else:
-            reward = 0.0
-            feedback_parts.append(
-                f"❌ Wrong label '{action.label}'. Correct: '{issue['label']}'."
+            return 0.0, (
+                f"❌ Wrong label '{action.label}'. "
+                f"Correct answer: '{issue['label']}'."
             )
 
-    elif task_id == "medium":
+    # ── Medium ────────────────────────────────────────────────────────────
+    if task_id == "medium":
+        reward = 0.0
+        parts = []
         if label_correct:
             reward += 0.5
-            feedback_parts.append(f"✅ Correct label '{issue['label']}' (+0.5).")
+            parts.append("✅ label correct (+0.5)")
         else:
-            feedback_parts.append(
-                f"❌ Wrong label '{action.label}'. Correct: '{issue['label']}' (+0.0)."
-            )
+            parts.append(f"❌ label wrong (got '{action.label}', expected '{issue['label']}')")
         if team_correct:
             reward += 0.5
-            feedback_parts.append(f"✅ Correct team '{issue['team']}' (+0.5).")
+            parts.append("✅ team correct (+0.5)")
         else:
-            feedback_parts.append(
-                f"❌ Wrong team '{action.team}'. Correct: '{issue['team']}' (+0.0)."
-            )
+            parts.append(f"❌ team wrong (got '{action.team}', expected '{issue['team']}')")
+        return round(reward, 4), " | ".join(parts)
 
-    elif task_id == "hard":
+    # ── Hard ──────────────────────────────────────────────────────────────
+    if task_id == "hard":
+        reward = 0.0
+        parts = []
         if label_correct:
-            reward += 0.3
-            feedback_parts.append(f"✅ Correct label '{issue['label']}' (+0.3).")
+            reward += 0.30
+            parts.append("✅ label (+0.30)")
         else:
-            feedback_parts.append(
-                f"❌ Wrong label '{action.label}'. Correct: '{issue['label']}' (+0.0)."
-            )
+            parts.append(f"❌ label (got '{action.label}', exp '{issue['label']}')")
         if team_correct:
-            reward += 0.3
-            feedback_parts.append(f"✅ Correct team '{issue['team']}' (+0.3).")
+            reward += 0.30
+            parts.append("✅ team (+0.30)")
         else:
-            feedback_parts.append(
-                f"❌ Wrong team '{action.team}'. Correct: '{issue['team']}' (+0.0)."
-            )
+            parts.append(f"❌ team (got '{action.team}', exp '{issue['team']}')")
         if priority_correct:
-            reward += 0.2
-            feedback_parts.append(f"✅ Correct priority '{issue['priority']}' (+0.2).")
+            reward += 0.20
+            parts.append("✅ priority (+0.20)")
         else:
-            feedback_parts.append(
-                f"❌ Wrong priority '{action.priority}'. Correct: '{issue['priority']}' (+0.0)."
-            )
-        # Partial credit for suggested action
-        reward += action_score * 0.2
-        feedback_parts.append(
-            f"💡 Suggested action score: {action_score:.1f} "
-            f"(keywords matched: {keyword_hits}/{len(issue['fix_keywords'])}) "
-            f"(+{action_score * 0.2:.2f})."
-        )
+            parts.append(f"❌ priority (got '{action.priority}', exp '{issue['priority']}')")
+        if fix_score > 0:
+            partial = round(fix_score * 0.20, 4)
+            reward += partial
+            parts.append(f"✅ fix suggestion (+{partial:.2f})")
+        else:
+            parts.append("❌ fix suggestion (no relevant keywords)")
+        return round(reward, 4), " | ".join(parts)
 
-    reward = max(0.01, min(0.99, reward))
-    return round(reward, 4), " | ".join(feedback_parts)
+    return 0.0, f"Unknown task_id '{task_id}'"
 
 
-# ──────────────────────────────────────────────────────────────
-# ENVIRONMENT CLASS
-# ──────────────────────────────────────────────────────────────
+# ── Environment ─────────────────────────��─────────────────────────────────────
 class GithubIssueTriageEnvironment(Environment):
     """
-    GitHub Issue Triage Environment.
-
-    The agent is shown a GitHub issue and must triage it correctly.
-    Each episode = one issue to triage.
-    The agent gets one step per episode (one decision per issue).
+    OpenEnv-compliant environment for GitHub Issue Triage.
+    One episode = one issue to triage. Clean state on every reset().
     """
 
-    SUPPORTS_CONCURRENT_SESSIONS: bool = True
+    # Each request creates a fresh env with isolated state — safe for concurrency
+    SUPPORTS_CONCURRENT_SESSIONS = True
 
-    def __init__(self):
-        self._state = State(episode_id=str(uuid4()), step_count=0)
-        self._task_id: str = "easy"
+    def __init__(self) -> None:
+        super().__init__()
+        self._state = GithubIssueTriageState()
         self._current_issue: dict = {}
+        self._task_id: str = "easy"
         self._done: bool = False
-        self._last_reward: float = 0.0
-        self._last_feedback: str = ""
+        # Separate random pools per task so issues cycle without repetition
+        self._pools: dict[str, list] = {tid: [] for tid in ("easy", "medium", "hard")}
+
+    # ── Internal helpers ──────────────────────────────────────────────────
+    def _pick_issue(self, task_id: str) -> dict:
+        """Return a random issue, refilling the pool when exhausted."""
+        pool = self._pools[task_id]
+        if not pool:
+            pool = list(ISSUE_DATASET)
+            random.shuffle(pool)
+            self._pools[task_id] = pool
+        return pool.pop()
+
+    def _build_observation(self, issue: dict, task_id: str,
+                           feedback: str = "", last_reward: float = 0.0,
+                           step_number: int = 0) -> "GithubIssueTriageObservation":
+        if task_id == "easy":
+            task_desc = (
+                "TASK (Easy): Read the GitHub issue carefully and assign the correct LABEL.\n"
+                "Valid labels: 'bug', 'feature', 'docs', 'question'.\n"
+                "Only the 'label' field in your action will be graded."
+            )
+        elif task_id == "medium":
+            task_desc = (
+                "TASK (Medium): Read the GitHub issue and assign the correct LABEL and TEAM.\n"
+                "Valid labels: 'bug', 'feature', 'docs', 'question'.\n"
+                "Valid teams: 'frontend', 'backend', 'ml', 'devops', 'docs'.\n"
+                "Both label and team fields will be graded (0.5 each)."
+            )
+        else:
+            task_desc = (
+                "TASK (Hard): Read the GitHub issue and assign LABEL, TEAM, PRIORITY, "
+                "and SUGGESTED_ACTION.\n"
+                "Valid labels: 'bug', 'feature', 'docs', 'question'.\n"
+                "Valid teams: 'frontend', 'backend', 'ml', 'devops', 'docs'.\n"
+                "Valid priorities: 'critical', 'high', 'medium', 'low'.\n"
+                "All four fields are graded: label (30%) + team (30%) + priority (20%) + fix (20%)."
+            )
+
+        if not feedback:
+            feedback = "Read the issue carefully and make your triage decision."
+
+        return GithubIssueTriageObservation(
+            issue_id=issue["id"],
+            issue_title=issue["title"],
+            issue_body=issue["body"],
+            repo_name="meta-pytorch/OpenEnv",
+            author=issue["author"],
+            existing_comments=issue["comments"],
+            task_id=task_id,
+            task_description=task_desc,
+            last_reward=last_reward,
+            feedback=feedback,
+            step_number=step_number,
+        )
 
+    # ── OpenEnv API ───────────────────────────────────────────────────────
     def reset(
         self,
-        task_id: str = "easy",
-        issue_index: int = -1,
-    ) -> GithubIssueTriageObservation:
-        """
-        Reset the environment for a new episode.
-
-        Args:
-            task_id: 'easy', 'medium', or 'hard'
-            issue_index: which issue to use (-1 = random)
-        """
-        self._state = State(episode_id=str(uuid4()), step_count=0)
-        self._task_id = task_id if task_id in TASK_DESCRIPTIONS else "easy"
-        self._done = False
-        self._last_reward = 0.0
-        self._last_feedback = ""
-
-        # Pick an issue
-        if issue_index >= 0 and issue_index < len(ISSUES):
-            self._current_issue = ISSUES[issue_index]
+        task_id: Optional[str] = None,
+        seed: Optional[int] = None,
+        **kwargs,
+    ) -> "GithubIssueTriageObservation":
+        """Start a new episode. Picks a random issue for the given task."""
+        if task_id and task_id in ("easy", "medium", "hard"):
+            self._task_id = task_id
         else:
-            self._current_issue = random.choice(ISSUES)
+            self._task_id = "easy"
+
+        if seed is not None:
+            random.seed(seed)
 
+        self._current_issue = self._pick_issue(self._task_id)
+        self._done = False
+        self._state = GithubIssueTriageState(
+            episode_id=str(uuid.uuid4()),
+            task_id=self._task_id,
+            issue_id=self._current_issue["id"],
+        )
         return self._build_observation(
-            feedback="Read the issue carefully and make your triage decision.",
-            done=False,
+            self._current_issue, self._task_id, step_number=0
         )
 
     def step(
-        self, action: GithubIssueTriageAction
-    ) -> GithubIssueTriageObservation:
-        """
-        The agent submits its triage decision.
-        One step per episode — grade it and mark done.
-        """
+        self, action: "GithubIssueTriageAction", task_id: Optional[str] = None, **kwargs,
+    ) -> "GithubIssueTriageObservation":
+        """Grade the agent's triage decision and return result."""
         self._state.step_count += 1
 
-        # Auto-reset if no issue loaded (e.g. fresh container, no reset called)
+        # In stateless HTTP mode, each call creates a fresh env.
+        # Use task_id from request if provided, otherwise fall back to instance default.
+        effective_task_id = task_id if task_id in ("easy", "medium", "hard") else self._task_id
+
+        # Auto-reset if called before reset() (stateless HTTP mode)
         if not self._current_issue:
-                    self.reset()
+            self.reset(task_id=effective_task_id)
 
         if self._done:
             return self._build_observation(
-                feedback="Episode already finished. Call reset() to start a new one.",
-                done=True,
+                self._current_issue,
+                self._task_id,
+                feedback="Episode already done. Call reset() to start a new episode.",
+                last_reward=0.0,
+                step_number=self._state.step_count,
             )
 
-        # Grade the action
         reward, feedback = grade_action(action, self._current_issue, self._task_id)
-        self._last_reward = reward
-        self._last_feedback = feedback
-        self._done = True  # one issue = one step = episode done
-
-        return self._build_observation(feedback=feedback, done=True, reward=reward)
+        self._done = True  # single-step episode
+        self._state.total_reward += reward
+        self._state.last_reward = reward
 
-    def _build_observation(
-        self,
-        feedback: str,
-        done: bool,
-        reward: float = 0.0,
-    ) -> GithubIssueTriageObservation:
-        """Helper to build observation from current state."""
-        issue = self._current_issue
-        return GithubIssueTriageObservation(
-            issue_id=issue.get("issue_id", ""),
-            issue_title=issue.get("issue_title", ""),
-            issue_body=issue.get("issue_body", ""),
-            repo_name=issue.get("repo_name", ""),
-            author=issue.get("author", ""),
-            existing_comments=issue.get("existing_comments", []),
-            task_id=self._task_id,
-            task_description=TASK_DESCRIPTIONS.get(self._task_id, ""),
-            last_reward=self._last_reward,
+        obs = self._build_observation(
+            self._current_issue,
+            self._task_id,
             feedback=feedback,
-            done=done,
+            last_reward=reward,
             step_number=self._state.step_count,
-            reward=reward,
         )
+        # Set reward/done on the base Observation fields so the server serializes them
+        obs.reward = reward
+        obs.done = True
+        return obs
+
+    def state(self) -> "GithubIssueTriageState":
+        return self._state
 
-    @property
-    def state(self) -> State:
-        return self._state
+    def close(self) -> None:
+        """Clean up resources (nothing to clean for this environment)."""
+        pass

uv.lock

@@ -1603,6 +1603,7 @@ name = "openenv-github-issue-triage"
 version = "0.1.0"
 source = { editable = "." }
 dependencies = [
+    { name = "openai" },
     { name = "openenv-core", extra = ["core"] },
 ]
 
@@ -1614,6 +1615,7 @@ dev = [
 
 [package.metadata]
 requires-dist = [
+    { name = "openai", specifier = ">=1.0.0" },
     { name = "openenv-core", extras = ["core"], specifier = ">=0.2.2" },
     { name = "pytest", marker = "extra == 'dev'", specifier = ">=8.0.0" },
     { name = "pytest-cov", marker = "extra == 'dev'", specifier = ">=4.0.0" },