Upload folder using huggingface_hub

.env.example

@@ -0,0 +1,7 @@
+# Mandatory hackathon environment variables
+API_BASE_URL=https://your-openai-compatible-endpoint/v1
+MODEL_NAME=your-model-id
+HF_TOKEN=your-api-key
+
+# Optional for validator remote ping
+SPACE_URL=https://your-space-name.hf.space

.github/workflows/ci.yml

@@ -0,0 +1,20 @@
+name: CI
+
+on:
+  push:
+  pull_request:
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: '3.11'
+      - name: Install deps
+        run: |
+          python -m pip install --upgrade pip
+          pip install -r requirements.txt
+      - name: Run tests
+        run: python -m pytest -q

.gitignore

@@ -0,0 +1,24 @@
+# Python
+__pycache__/
+*.py[cod]
+*.so
+.pytest_cache/
+.mypy_cache/
+
+# Virtual environments
+.venv/
+venv/
+
+# Build artifacts
+build/
+dist/
+*.egg-info/
+
+# OS/editor
+.DS_Store
+.vscode/
+.idea/
+
+# Runtime artifacts
+*.log
+scores/

Dockerfile

@@ -0,0 +1,19 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+
+ENV PYTHONDONTWRITEBYTECODE=1
+ENV PYTHONUNBUFFERED=1
+
+COPY pyproject.toml requirements.txt README.md /app/
+COPY src /app/src
+COPY scripts /app/scripts
+COPY openenv.yaml /app/openenv.yaml
+COPY app.py /app/app.py
+
+RUN pip install --no-cache-dir --upgrade pip && \
+    pip install --no-cache-dir -r requirements.txt
+
+EXPOSE 7860
+
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -0,0 +1,200 @@
+---
+title: Support Triage OpenEnv
+emoji: "📨"
+colorFrom: blue
+colorTo: teal
+sdk: docker
+app_port: 7860
+tags:
+  - openenv
+  - reinforcement-learning
+  - customer-support
+license: mit
+---
+
+# Support Triage OpenEnv
+
+A complete, real-world OpenEnv environment for training/evaluating agents on **customer support ticket triage**. The environment simulates what support teams actually do: read inbox tickets, classify urgency/category, draft safe responses, and resolve the right ticket.
+
+## Why this environment
+
+Most agent benchmarks under-model production support workflows. This environment focuses on practical support operations with:
+- Multi-ticket inbox context selection
+- Policy-compliant communication
+- Priority + escalation decisions
+- Deterministic graders and dense reward shaping
+
+## OpenEnv API compliance
+
+The environment exposes:
+- `reset(task_id?: str) -> Observation`
+- `step(action: Action) -> (Observation, Reward, done, info)`
+- `state() -> dict`
+
+Typed Pydantic models:
+- `Observation`: [`src/support_triage_openenv/models.py`](src/support_triage_openenv/models.py)
+- `Action`: [`src/support_triage_openenv/models.py`](src/support_triage_openenv/models.py)
+- `Reward`: [`src/support_triage_openenv/models.py`](src/support_triage_openenv/models.py)
+
+Metadata:
+- `openenv.yaml`
+
+## Action space
+
+`Action` model fields:
+- `action_type`: one of `read_ticket | classify_ticket | draft_reply | resolve_ticket`
+- `ticket_id`: required for `read_ticket`, `classify_ticket`, `resolve_ticket`
+- `priority`: optional enum `low | medium | high | urgent`
+- `category`: optional enum `account | billing | technical | abuse | general`
+- `needs_escalation`: optional bool
+- `message`: text for `draft_reply`
+
+## Observation space
+
+`Observation` includes:
+- `task_id`, `objective`, `step_count`, `max_steps`
+- `inbox`: ticket metadata list (`ticket_id`, subject, tier, age, read flag)
+- `current_ticket_content`: only visible after reading selected ticket
+- `latest_system_note`: feedback from last step
+- `score_hint`: partial grader components (`read`, `classify`, `reply`, `resolve`)
+
+## Tasks and difficulty
+
+1. `easy_password_reset` (Easy)
+- Correctly process account lockout and send secure reset guidance.
+
+2. `medium_billing_dispute` (Medium)
+- Investigate duplicate billing with context ticket and provide policy-compliant refund timeline.
+
+3. `hard_outage_incident` (Hard)
+- Handle a high-stakes outage report requiring multi-ticket context, urgent escalation, and careful incident messaging.
+
+Each task has deterministic grading in `support_triage_openenv.graders.grade_task`, returning a score `0.0-1.0`.
+
+## Reward design
+
+Reward is shaped and meaningful across the trajectory:
+- Positive dense signal from partial grader progress (read/context, classification fields, reply quality, resolve correctness)
+- Penalties for invalid actions, repeated loops, and malformed steps
+- Final step guarantees score alignment with deterministic grader output
+
+## Project structure
+
+- `src/support_triage_openenv/env.py` - environment implementation
+- `src/support_triage_openenv/models.py` - typed OpenEnv models
+- `src/support_triage_openenv/tasks.py` - task specs (easy/medium/hard)
+- `src/support_triage_openenv/graders.py` - deterministic grader logic
+- `scripts/run_baseline.py` - OpenAI baseline inference runner
+- `scripts/validate_env.py` - tests + optional `openenv validate`
+- `app.py` - FastAPI app for HF Space runtime
+- `Dockerfile` - containerized deployment
+
+## Setup
+
+```bash
+cd /home/ai24mtech14005/meta_hackathon
+python3 -m venv .venv
+source .venv/bin/activate
+pip install -r requirements.txt
+```
+
+## Run tests
+
+```bash
+python -m pytest -q
+```
+
+## Run baseline
+
+OpenAI model baseline:
+
+```bash
+export API_BASE_URL=https://your-openai-compatible-endpoint/v1
+export MODEL_NAME=your-model-id
+export HF_TOKEN=your-api-key
+python inference.py --mode openai --output scores/inference_scores.json
+```
+
+Deterministic heuristic baseline:
+
+```bash
+python inference.py --mode heuristic --output scores/inference_scores.json
+```
+
+Outputs JSON report to `scores/inference_scores.json` and structured stdout logs with `[START]`, `[STEP]`, `[END]`.
+
+## Run API locally
+
+```bash
+uvicorn app:app --host 0.0.0.0 --port 7860
+```
+
+Endpoints:
+- `GET /health`
+- `POST /reset`
+- `POST /step`
+- `GET /state`
+
+## Docker
+
+```bash
+docker build -t support-triage-openenv .
+docker run --rm -p 7860:7860 support-triage-openenv
+```
+
+## Hugging Face Space deployment
+
+- Create a **Docker Space**.
+- Push this repository to the Space.
+- Keep `README.md` frontmatter tags including `openenv`.
+- Space serves the API on port `7860`.
+
+## One-command remote bootstrap
+
+If you want this local repo to automatically create and push to both GitHub + HF:
+
+```bash
+export GITHUB_USERNAME=your_github_user
+export GITHUB_TOKEN=your_github_pat
+export HF_USERNAME=your_hf_user
+export HF_TOKEN=your_hf_token
+bash scripts/bootstrap_remotes.sh support-triage-openenv
+```
+
+## Baseline scores (heuristic reproducible)
+
+Generated with:
+
+```bash
+python inference.py --mode heuristic --output scores/inference_scores.json
+```
+
+- `easy_password_reset`: grader `1.0`, reward `1.0`
+- `medium_billing_dispute`: grader `1.0`, reward `1.0`
+- `hard_outage_incident`: grader `1.0`, reward `1.0`
+- Overall average grader score: `1.0`
+- Tracked reference artifact: `baseline_expected_scores.json`
+
+## Pre-submission validator
+
+Run full strict validation (all disqualification gates):
+
+```bash
+python pre_submission_validate.py --space-url https://your-space-name.hf.space
+```
+
+Local-only run while iterating (skips Docker daemon + remote space ping):
+
+```bash
+python pre_submission_validate.py --skip-docker --skip-space
+```
+
+Run organizer-provided script directly (integrated path):
+
+```bash
+bash scripts/pre_validation_script.sh https://your-space-name.hf.space .
+```
+
+Notes:
+- `scripts/sample_inference_script.sh` is kept as organizer reference.
+- Root `inference.py` is aligned to the required `[START]`, `[STEP]`, `[END]` line format.

app.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+from fastapi import FastAPI
+
+from support_triage_openenv.env import SupportTriageEnv
+from support_triage_openenv.models import Action
+
+app = FastAPI(title="Support Triage OpenEnv", version="0.1.0")
+env = SupportTriageEnv()
+
+
+@app.get("/health")
+def health() -> dict[str, str]:
+    return {"status": "ok"}
+
+
+@app.post("/reset")
+def reset(payload: dict | None = None) -> dict:
+    task_id = (payload or {}).get("task_id")
+    obs = env.reset(task_id=task_id)
+    return obs.model_dump()
+
+
+@app.post("/step")
+def step(action: Action) -> dict:
+    obs, reward, done, info = env.step(action)
+    return {
+        "observation": obs.model_dump(),
+        "reward": reward.model_dump(),
+        "done": done,
+        "info": info,
+    }
+
+
+@app.get("/state")
+def state() -> dict:
+    return env.state()

baseline_expected_scores.json

@@ -0,0 +1,29 @@
+{
+  "mode": "heuristic",
+  "model": "gpt-4.1-mini",
+  "avg_grader_score": 1.0,
+  "avg_final_reward": 1.0,
+  "episodes": [
+    {
+      "task_id": "easy_password_reset",
+      "steps": 4,
+      "grader_score": 1.0,
+      "reward": 1.0,
+      "done_reason": "resolved"
+    },
+    {
+      "task_id": "medium_billing_dispute",
+      "steps": 5,
+      "grader_score": 1.0,
+      "reward": 1.0,
+      "done_reason": "resolved"
+    },
+    {
+      "task_id": "hard_outage_incident",
+      "steps": 6,
+      "grader_score": 1.0,
+      "reward": 1.0,
+      "done_reason": "resolved"
+    }
+  ]
+}

inference.py

@@ -0,0 +1,300 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import time
+from dataclasses import asdict, dataclass
+from pathlib import Path
+from typing import Any
+
+from openai import OpenAI
+
+from support_triage_openenv import Action, SupportTriageEnv
+
+# Mandatory variables requested by organizers.
+API_BASE_URL = os.getenv("API_BASE_URL") or "https://router.huggingface.co/v1"
+MODEL_NAME = os.getenv("MODEL_NAME") or "Qwen/Qwen2.5-72B-Instruct"
+HF_TOKEN = os.getenv("HF_TOKEN")
+
+BENCHMARK = os.getenv("SUPPORT_TRIAGE_BENCHMARK", "support-triage-openenv")
+SUCCESS_SCORE_THRESHOLD = float(os.getenv("SUCCESS_SCORE_THRESHOLD", "0.9"))
+
+SYSTEM_PROMPT = (
+    "You are solving customer support ticket triage. "
+    "Return exactly one JSON object with keys: "
+    "action_type, ticket_id, priority, category, needs_escalation, message."
+)
+
+RULE_POLICY: dict[str, list[dict[str, Any]]] = {
+    "easy_password_reset": [
+        {"action_type": "read_ticket", "ticket_id": "T-1001"},
+        {
+            "action_type": "classify_ticket",
+            "ticket_id": "T-1001",
+            "priority": "medium",
+            "category": "account",
+            "needs_escalation": False,
+        },
+        {
+            "action_type": "draft_reply",
+            "message": (
+                "We will send a reset link to your email. For security, confirm the request "
+                "from your registered email before using the reset link."
+            ),
+        },
+        {"action_type": "resolve_ticket", "ticket_id": "T-1001"},
+    ],
+    "medium_billing_dispute": [
+        {"action_type": "read_ticket", "ticket_id": "T-2001"},
+        {"action_type": "read_ticket", "ticket_id": "T-2002"},
+        {
+            "action_type": "classify_ticket",
+            "ticket_id": "T-2001",
+            "priority": "high",
+            "category": "billing",
+            "needs_escalation": False,
+        },
+        {
+            "action_type": "draft_reply",
+            "message": (
+                "We confirmed a duplicate charge. We are issuing a refund and will share the invoice update. "
+                "Refund processing typically takes 3-5 business days."
+            ),
+        },
+        {"action_type": "resolve_ticket", "ticket_id": "T-2001"},
+    ],
+    "hard_outage_incident": [
+        {"action_type": "read_ticket", "ticket_id": "T-3001"},
+        {"action_type": "read_ticket", "ticket_id": "T-3002"},
+        {"action_type": "read_ticket", "ticket_id": "T-3003"},
+        {
+            "action_type": "classify_ticket",
+            "ticket_id": "T-3001",
+            "priority": "urgent",
+            "category": "technical",
+            "needs_escalation": True,
+        },
+        {
+            "action_type": "draft_reply",
+            "message": (
+                "We have escalated this incident and are investigating now. "
+                "The status page will carry updates while we continue incident response."
+            ),
+        },
+        {"action_type": "resolve_ticket", "ticket_id": "T-3001"},
+    ],
+}
+
+
+@dataclass
+class EpisodeResult:
+    task_id: str
+    steps: int
+    score: float
+    success: bool
+    final_reward: float
+    rewards: list[float]
+    fallback_count: int
+
+
+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: str, reward: float, done: bool, error: str | None) -> None:
+    error_val = error if error else "null"
+    done_val = str(done).lower()
+    print(
+        f"[STEP] step={step} action={action} reward={reward:.2f} done={done_val} error={error_val}",
+        flush=True,
+    )
+
+
+def log_end(success: bool, steps: int, score: float, rewards: list[float]) -> None:
+    rewards_str = ",".join(f"{r:.2f}" for r in rewards)
+    print(f"[END] success={str(success).lower()} steps={steps} score={score:.3f} rewards={rewards_str}", flush=True)
+
+
+def _extract_json(text: str) -> str:
+    text = text.strip()
+    start = text.find("{")
+    end = text.rfind("}")
+    if start == -1 or end == -1 or end <= start:
+        raise ValueError("No JSON object found in model response")
+    return text[start : end + 1]
+
+
+def heuristic_action(task_id: str, step_idx: int) -> Action:
+    plan = RULE_POLICY[task_id]
+    idx = min(step_idx, len(plan) - 1)
+    return Action.model_validate(plan[idx])
+
+
+def llm_action(client: OpenAI, observation: dict[str, Any], state: dict[str, Any]) -> Action:
+    prompt = json.dumps(
+        {
+            "instruction": "Pick the best next single action to maximize final task score.",
+            "observation": observation,
+            "state": state,
+        },
+        ensure_ascii=True,
+    )
+    completion = client.chat.completions.create(
+        model=MODEL_NAME,
+        messages=[
+            {"role": "system", "content": SYSTEM_PROMPT},
+            {"role": "user", "content": prompt},
+        ],
+        temperature=0,
+        max_tokens=220,
+        stream=False,
+    )
+    text = (completion.choices[0].message.content or "").strip()
+    payload = json.loads(_extract_json(text))
+    return Action.model_validate(payload)
+
+
+def action_to_str(action: Action) -> str:
+    if action.action_type == "read_ticket":
+        return f"read_ticket({action.ticket_id})"
+    if action.action_type == "classify_ticket":
+        return (
+            f"classify_ticket({action.ticket_id},{action.priority},{action.category},"
+            f"{str(bool(action.needs_escalation)).lower()})"
+        )
+    if action.action_type == "draft_reply":
+        length = len((action.message or "").strip())
+        return f"draft_reply(len={length})"
+    if action.action_type == "resolve_ticket":
+        return f"resolve_ticket({action.ticket_id})"
+    return action.action_type
+
+
+def run_episode(
+    env: SupportTriageEnv,
+    task_id: str,
+    mode: str,
+    client: OpenAI | None,
+    started_at: float,
+    runtime_limit_seconds: int,
+) -> EpisodeResult:
+    obs = env.reset(task_id)
+    done = False
+    info: dict[str, Any] = {}
+    rewards: list[float] = []
+    steps_taken = 0
+    fallback_count = 0
+    success = False
+    score = 0.0
+    final_reward = 0.0
+
+    log_start(task=task_id, env=BENCHMARK, model=MODEL_NAME)
+
+    while not done:
+        if time.monotonic() - started_at > runtime_limit_seconds:
+            raise TimeoutError(f"Runtime exceeded {runtime_limit_seconds}s")
+
+        step_idx = env.state()["step_count"]
+
+        if mode == "heuristic":
+            action = heuristic_action(task_id, step_idx)
+        else:
+            assert client is not None
+            try:
+                action = llm_action(client, obs.model_dump(), env.state())
+            except Exception:
+                fallback_count += 1
+                action = heuristic_action(task_id, step_idx)
+
+        step_error: str | None = None
+        try:
+            obs, reward, done, info = env.step(action)
+            reward_value = float(reward.value)
+        except Exception as exc:
+            step_error = str(exc)
+            reward_value = 0.0
+            done = True
+
+        steps_taken = step_idx + 1
+        rewards.append(reward_value)
+        final_reward = reward_value
+
+        log_step(
+            step=steps_taken,
+            action=action_to_str(action),
+            reward=reward_value,
+            done=done,
+            error=step_error,
+        )
+
+        if done:
+            break
+
+    score = max(0.0, min(1.0, float(info.get("grader_score", 0.0))))
+    success = score >= SUCCESS_SCORE_THRESHOLD
+    log_end(success=success, steps=steps_taken, score=score, rewards=rewards)
+
+    return EpisodeResult(
+        task_id=task_id,
+        steps=steps_taken,
+        score=round(score, 4),
+        success=success,
+        final_reward=round(final_reward, 4),
+        rewards=[round(r, 4) for r in rewards],
+        fallback_count=fallback_count,
+    )
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Submission inference script.")
+    parser.add_argument("--mode", choices=["openai", "heuristic"], default="openai")
+    parser.add_argument("--output", default="scores/inference_scores.json")
+    parser.add_argument("--runtime-limit-seconds", type=int, default=1200)
+    parser.add_argument("--task-id", default="", help="Optional single task id; default runs all tasks")
+    args = parser.parse_args()
+
+    if args.mode == "openai" and not HF_TOKEN:
+        raise RuntimeError("HF_TOKEN is required for --mode openai")
+
+    env = SupportTriageEnv()
+    task_ids = [args.task_id] if args.task_id else env.task_ids
+
+    client = None
+    if args.mode == "openai":
+        client = OpenAI(base_url=API_BASE_URL, api_key=HF_TOKEN)
+
+    started_at = time.monotonic()
+    episodes: list[EpisodeResult] = []
+    for task_id in task_ids:
+        if task_id not in env.task_ids:
+            raise ValueError(f"Unknown task_id '{task_id}'")
+        episodes.append(
+            run_episode(
+                env=env,
+                task_id=task_id,
+                mode=args.mode,
+                client=client,
+                started_at=started_at,
+                runtime_limit_seconds=args.runtime_limit_seconds,
+            )
+        )
+
+    summary = {
+        "mode": args.mode,
+        "api_base_url": API_BASE_URL,
+        "model_name": MODEL_NAME,
+        "avg_score": round(sum(e.score for e in episodes) / len(episodes), 4),
+        "avg_final_reward": round(sum(e.final_reward for e in episodes) / len(episodes), 4),
+        "total_steps": int(sum(e.steps for e in episodes)),
+        "episodes": [asdict(e) for e in episodes],
+    }
+
+    output_path = Path(args.output)
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    output_path.write_text(json.dumps(summary, indent=2), encoding="utf-8")
+
+
+if __name__ == "__main__":
+    main()

openenv.yaml

@@ -0,0 +1,31 @@
+name: support-triage-openenv
+version: 0.1.0
+entrypoint: src/support_triage_openenv/env.py:SupportTriageEnv
+description: |
+  Real-world customer support ticket triage environment with deterministic tasks,
+  typed action/observation/reward models, and dense reward shaping.
+license: mit
+tags:
+  - openenv
+  - reinforcement-learning
+  - customer-support
+maintainers:
+  - name: meta-hackathon-team
+api:
+  reset: "reset(task_id?: str) -> Observation"
+  step: "step(action: Action) -> tuple[Observation, Reward, bool, info]"
+  state: "state() -> dict"
+models:
+  observation: support_triage_openenv.models.Observation
+  action: support_triage_openenv.models.Action
+  reward: support_triage_openenv.models.Reward
+tasks:
+  - id: easy_password_reset
+    difficulty: easy
+    grader: support_triage_openenv.graders.grade_task
+  - id: medium_billing_dispute
+    difficulty: medium
+    grader: support_triage_openenv.graders.grade_task
+  - id: hard_outage_incident
+    difficulty: hard
+    grader: support_triage_openenv.graders.grade_task

pre_submission_validate.py

@@ -0,0 +1,352 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import argparse
+import importlib
+import json
+import os
+import re
+import subprocess
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+import httpx
+import yaml
+from pydantic import BaseModel
+
+ROOT = Path(__file__).resolve().parent
+if str(ROOT / "src") not in sys.path:
+    sys.path.insert(0, str(ROOT / "src"))
+if str(ROOT) not in sys.path:
+    sys.path.insert(0, str(ROOT))
+
+START_RE = re.compile(r"^\[START\] task=([^ ]+) env=([^ ]+) model=(.+)$")
+STEP_RE = re.compile(r"^\[STEP\] step=(\d+) action=(.+) reward=([0-9]+\.[0-9]{2}) done=(true|false) error=(.+)$")
+END_RE = re.compile(r"^\[END\] success=(true|false) steps=(\d+) score=([0-9]+\.[0-9]{3}) rewards=([0-9\.,-]*)$")
+
+
+@dataclass
+class CheckResult:
+    name: str
+    passed: bool
+    detail: str
+
+
+def run_command(cmd: list[str], timeout: int = 300) -> tuple[int, str, str]:
+    proc = subprocess.run(cmd, cwd=ROOT, capture_output=True, text=True, timeout=timeout)
+    return proc.returncode, proc.stdout, proc.stderr
+
+
+def check_env_config() -> CheckResult:
+    required = ["API_BASE_URL", "MODEL_NAME", "HF_TOKEN"]
+    missing = [k for k in required if not os.getenv(k)]
+    if missing:
+        return CheckResult("Env vars configured", False, f"Missing: {', '.join(missing)}")
+    return CheckResult("Env vars configured", True, "API_BASE_URL, MODEL_NAME, HF_TOKEN are set")
+
+
+def check_inference_file() -> CheckResult:
+    path = ROOT / "inference.py"
+    if not path.exists():
+        return CheckResult("Root inference.py", False, "inference.py missing at repo root")
+
+    text = path.read_text(encoding="utf-8")
+    required_snippets = [
+        "from openai import OpenAI",
+        "API_BASE_URL",
+        "MODEL_NAME",
+        "HF_TOKEN",
+        "[START] task=",
+        "[STEP] step=",
+        "[END] success=",
+    ]
+    missing = [s for s in required_snippets if s not in text]
+    if missing:
+        return CheckResult("Root inference.py", False, f"Missing required content: {missing}")
+
+    return CheckResult("Root inference.py", True, "Found required script name, env vars, OpenAI client, and organizer log format")
+
+
+def check_openenv_compliance() -> CheckResult:
+    cfg_path = ROOT / "openenv.yaml"
+    if not cfg_path.exists():
+        return CheckResult("OpenEnv compliance", False, "openenv.yaml not found")
+
+    cfg = yaml.safe_load(cfg_path.read_text(encoding="utf-8"))
+    for key in ["entrypoint", "models", "tasks", "api"]:
+        if key not in cfg:
+            return CheckResult("OpenEnv compliance", False, f"Missing key in openenv.yaml: {key}")
+
+    entrypoint = cfg["entrypoint"]
+    if ":" not in entrypoint:
+        return CheckResult("OpenEnv compliance", False, "Entrypoint must be <path>:<ClassName>")
+
+    fs_path, class_name = entrypoint.split(":", 1)
+    module_name = fs_path.replace("/", ".").replace(".py", "")
+    module = importlib.import_module(module_name)
+    env_cls = getattr(module, class_name, None)
+    if env_cls is None:
+        return CheckResult("OpenEnv compliance", False, f"Entrypoint class not found: {class_name}")
+
+    env = env_cls()
+    for method_name in ["reset", "step", "state"]:
+        if not callable(getattr(env, method_name, None)):
+            return CheckResult("OpenEnv compliance", False, f"Missing callable method: {method_name}")
+
+    model_refs = cfg.get("models", {})
+    for model_name in ["observation", "action", "reward"]:
+        dotted = model_refs.get(model_name)
+        if not dotted or "." not in dotted:
+            return CheckResult("OpenEnv compliance", False, f"Invalid model ref for {model_name}: {dotted}")
+        mod_name, cls_name = dotted.rsplit(".", 1)
+        cls = getattr(importlib.import_module(mod_name), cls_name, None)
+        if cls is None or not issubclass(cls, BaseModel):
+            return CheckResult("OpenEnv compliance", False, f"{dotted} must resolve to Pydantic BaseModel")
+
+    obs = env.reset(cfg["tasks"][0]["id"])
+    if not isinstance(obs, BaseModel):
+        return CheckResult("OpenEnv compliance", False, "reset() must return typed model")
+
+    action_mod_name, action_cls_name = model_refs["action"].rsplit(".", 1)
+    action_cls = getattr(importlib.import_module(action_mod_name), action_cls_name)
+    action = action_cls(action_type="read_ticket", ticket_id="T-1001")
+    obs2, reward, done, info = env.step(action)
+
+    if not isinstance(obs2, BaseModel):
+        return CheckResult("OpenEnv compliance", False, "step() observation must be typed model")
+    if not isinstance(reward, BaseModel):
+        return CheckResult("OpenEnv compliance", False, "step() reward must be typed model")
+    if not isinstance(done, bool):
+        return CheckResult("OpenEnv compliance", False, "step() done must be bool")
+    if not isinstance(info, dict):
+        return CheckResult("OpenEnv compliance", False, "step() info must be dict")
+    if not isinstance(env.state(), dict):
+        return CheckResult("OpenEnv compliance", False, "state() must return dict")
+
+    return CheckResult("OpenEnv compliance", True, "openenv.yaml + typed models + reset/step/state validated")
+
+
+def check_task_graders() -> CheckResult:
+    inference = importlib.import_module("inference")
+    env_mod = importlib.import_module("support_triage_openenv.env")
+    action_mod = importlib.import_module("support_triage_openenv.models")
+
+    env = env_mod.SupportTriageEnv()
+    task_ids = env.task_ids
+    if len(task_ids) < 3:
+        return CheckResult("3+ tasks with graders", False, f"Expected >=3 tasks, got {len(task_ids)}")
+
+    details: list[str] = []
+    for task_id in task_ids:
+        env.reset(task_id)
+        done = False
+        info: dict[str, Any] = {}
+
+        while not done:
+            step_idx = env.state()["step_count"]
+            raw_action = inference.RULE_POLICY[task_id][min(step_idx, len(inference.RULE_POLICY[task_id]) - 1)]
+            action = action_mod.Action.model_validate(raw_action)
+            _, reward, done, info = env.step(action)
+            reward_value = float(reward.value)
+            if not (0.0 <= reward_value <= 1.0):
+                return CheckResult("3+ tasks with graders", False, f"Reward out of range in {task_id}: {reward_value}")
+
+        grader_score = float(info.get("grader_score", -1.0))
+        if not (0.0 <= grader_score <= 1.0):
+            return CheckResult("3+ tasks with graders", False, f"Grader out of range in {task_id}: {grader_score}")
+
+        details.append(f"{task_id}:{grader_score:.4f}")
+
+    return CheckResult("3+ tasks with graders", True, " | ".join(details))
+
+
+def _validate_log_sequence(lines: list[str]) -> tuple[bool, str]:
+    if not lines:
+        return False, "No stdout lines from inference.py"
+
+    phase = "need_start"
+    steps_seen = 0
+    episodes = 0
+
+    for line in lines:
+        if line.startswith("[START]"):
+            if phase != "need_start":
+                return False, "[START] appeared before previous episode ended"
+            if not START_RE.match(line):
+                return False, f"Invalid [START] format: {line}"
+            phase = "need_step_or_end"
+            steps_seen = 0
+            continue
+
+        if line.startswith("[STEP]"):
+            if phase != "need_step_or_end":
+                return False, "[STEP] appeared before [START]"
+            m = STEP_RE.match(line)
+            if not m:
+                return False, f"Invalid [STEP] format: {line}"
+            reward = float(m.group(3))
+            if reward < 0.0 or reward > 1.0:
+                return False, f"[STEP] reward out of range: {reward}"
+            steps_seen += 1
+            continue
+
+        if line.startswith("[END]"):
+            if phase != "need_step_or_end":
+                return False, "[END] appeared before [START]"
+            m = END_RE.match(line)
+            if not m:
+                return False, f"Invalid [END] format: {line}"
+            end_steps = int(m.group(2))
+            score = float(m.group(3))
+            rewards_blob = m.group(4)
+
+            if end_steps != steps_seen:
+                return False, f"[END] steps mismatch: expected {steps_seen}, got {end_steps}"
+            if score < 0.0 or score > 1.0:
+                return False, f"[END] score out of range: {score}"
+
+            rewards = [r for r in rewards_blob.split(",") if r != ""]
+            if len(rewards) != steps_seen:
+                return False, f"[END] rewards count mismatch: expected {steps_seen}, got {len(rewards)}"
+            for r in rewards:
+                rv = float(r)
+                if rv < 0.0 or rv > 1.0:
+                    return False, f"[END] reward out of range: {rv}"
+
+            episodes += 1
+            phase = "need_start"
+            continue
+
+        return False, f"Unexpected stdout line (must be START/STEP/END only): {line}"
+
+    if phase != "need_start":
+        return False, "Missing [END] for final episode"
+    if episodes == 0:
+        return False, "No complete episodes found"
+
+    return True, f"Validated {episodes} episode log sequences"
+
+
+def check_inference_repro() -> CheckResult:
+    output_path = ROOT / "scores" / "inference_scores.json"
+    cmd = [sys.executable, "inference.py", "--mode", "heuristic", "--output", str(output_path)]
+    code, out, err = run_command(cmd, timeout=120)
+    if code != 0:
+        return CheckResult("Baseline reproduces", False, f"inference.py failed: {err.strip() or out.strip()}")
+
+    if not output_path.exists():
+        return CheckResult("Baseline reproduces", False, "scores/inference_scores.json was not created")
+
+    try:
+        payload = json.loads(output_path.read_text(encoding="utf-8"))
+    except Exception as exc:
+        return CheckResult("Baseline reproduces", False, f"Invalid JSON output: {exc}")
+
+    for key in ["avg_score", "avg_final_reward", "episodes"]:
+        if key not in payload:
+            return CheckResult("Baseline reproduces", False, f"Missing key in output JSON: {key}")
+
+    lines = [ln.strip() for ln in out.splitlines() if ln.strip()]
+    ok, detail = _validate_log_sequence(lines)
+    if not ok:
+        return CheckResult("Baseline reproduces", False, detail)
+
+    return CheckResult("Baseline reproduces", True, f"inference.py completed and wrote {output_path.relative_to(ROOT)}; {detail}")
+
+
+def check_docker_build(skip: bool) -> CheckResult:
+    if skip:
+        return CheckResult("Dockerfile builds", True, "Skipped by --skip-docker")
+
+    code, out, err = run_command(["docker", "build", "-t", "support-triage-openenv:presubmit", "."], timeout=900)
+    if code != 0:
+        msg = (err or out).strip().splitlines()
+        short = msg[-1] if msg else "docker build failed"
+        return CheckResult("Dockerfile builds", False, short)
+    return CheckResult("Dockerfile builds", True, "docker build succeeded")
+
+
+def check_space_ping(space_url: str | None, skip: bool) -> CheckResult:
+    if skip:
+        return CheckResult("HF Space deploys + ping", True, "Skipped by --skip-space")
+
+    if not space_url:
+        return CheckResult("HF Space deploys + ping", False, "Provide --space-url (or use --skip-space for local-only checks)")
+
+    base = space_url.rstrip("/")
+    try:
+        with httpx.Client(timeout=20.0) as client:
+            reset = client.post(f"{base}/reset", json={"task_id": "easy_password_reset"})
+            if reset.status_code != 200:
+                return CheckResult("HF Space deploys + ping", False, f"POST /reset returned {reset.status_code}")
+
+            payload = reset.json()
+            if payload.get("task_id") != "easy_password_reset":
+                return CheckResult("HF Space deploys + ping", False, "reset() payload missing expected task_id")
+    except Exception as exc:
+        return CheckResult("HF Space deploys + ping", False, f"Ping failed: {exc}")
+
+    return CheckResult("HF Space deploys + ping", True, f"{base} returned 200 and reset() works")
+
+
+def check_organizer_script(space_url: str | None, skip: bool) -> CheckResult:
+    if skip:
+        return CheckResult("Organizer pre-validation script", True, "Skipped")
+
+    script_path = ROOT / "scripts" / "pre_validation_script.sh"
+    if not script_path.exists():
+        return CheckResult("Organizer pre-validation script", False, "scripts/pre_validation_script.sh not found")
+    if not space_url:
+        return CheckResult("Organizer pre-validation script", False, "Requires --space-url")
+
+    code, out, err = run_command(["bash", str(script_path), space_url, str(ROOT)], timeout=1800)
+    if code != 0:
+        tail = (out + "\n" + err).strip().splitlines()[-5:]
+        return CheckResult("Organizer pre-validation script", False, " | ".join(tail) if tail else "script failed")
+
+    return CheckResult("Organizer pre-validation script", True, "Organizer script passed")
+
+
+def run_all(args: argparse.Namespace) -> list[CheckResult]:
+    organizer_skip = args.skip_organizer_script or args.skip_space or args.skip_docker
+    return [
+        check_env_config(),
+        check_inference_file(),
+        check_openenv_compliance(),
+        check_task_graders(),
+        check_inference_repro(),
+        check_docker_build(skip=args.skip_docker),
+        check_space_ping(space_url=args.space_url, skip=args.skip_space),
+        check_organizer_script(space_url=args.space_url, skip=organizer_skip),
+    ]
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Pre-submission validator for Meta HF hackathon OpenEnv env.")
+    parser.add_argument("--space-url", default=os.getenv("SPACE_URL"), help="Deployed HF Space URL for ping checks")
+    parser.add_argument("--skip-docker", action="store_true", help="Skip docker build check")
+    parser.add_argument("--skip-space", action="store_true", help="Skip remote Space ping check")
+    parser.add_argument("--skip-organizer-script", action="store_true", help="Skip organizer-provided pre-validation script")
+    args = parser.parse_args()
+
+    results = run_all(args)
+
+    print("\n=== Pre-Submission Checklist Report ===")
+    for r in results:
+        status = "PASS" if r.passed else "FAIL"
+        print(f"[{status}] {r.name}: {r.detail}")
+
+    failed = [r for r in results if not r.passed]
+    print("\nSummary:")
+    print(f"- Total checks: {len(results)}")
+    print(f"- Passed: {len(results) - len(failed)}")
+    print(f"- Failed: {len(failed)}")
+
+    if failed:
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

pyproject.toml

@@ -0,0 +1,29 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "support-triage-openenv"
+version = "0.1.0"
+description = "OpenEnv-compliant customer support triage RL environment"
+readme = "README.md"
+requires-python = ">=3.10"
+authors = [{ name = "meta-hackathon-team" }]
+dependencies = [
+  "pydantic>=2.7.0",
+  "PyYAML>=6.0.1",
+  "openai>=1.40.0",
+  "fastapi>=0.115.0",
+  "uvicorn>=0.30.0",
+]
+
+[project.optional-dependencies]
+dev = [
+  "pytest>=8.2.0",
+]
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.setuptools.packages.find]
+where = ["src"]

requirements.txt

@@ -0,0 +1,2 @@
+-e .
+pytest>=8.2.0

scripts/bootstrap_remotes.sh

@@ -0,0 +1,83 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+REPO_NAME="${1:-support-triage-openenv}"
+GITHUB_VISIBILITY="${GITHUB_VISIBILITY:-public}"
+
+if [[ -z "${GITHUB_TOKEN:-}" || -z "${GITHUB_USERNAME:-}" ]]; then
+  echo "Missing GITHUB_TOKEN or GITHUB_USERNAME" >&2
+  exit 1
+fi
+
+if [[ -z "${HF_TOKEN:-}" || -z "${HF_USERNAME:-}" ]]; then
+  echo "Missing HF_TOKEN or HF_USERNAME" >&2
+  exit 1
+fi
+
+if ! command -v huggingface-cli >/dev/null 2>&1; then
+  echo "huggingface-cli is required but not installed." >&2
+  exit 1
+fi
+
+# 1) Create GitHub repo via REST API (works without gh CLI)
+create_payload=$(cat <<JSON
+{
+  "name": "${REPO_NAME}",
+  "private": $( [[ "${GITHUB_VISIBILITY}" == "private" ]] && echo true || echo false ),
+  "description": "OpenEnv customer support triage environment",
+  "auto_init": false
+}
+JSON
+)
+
+curl -sS -o /tmp/github_repo_create.json -w "%{http_code}" \
+  -H "Accept: application/vnd.github+json" \
+  -H "Authorization: Bearer ${GITHUB_TOKEN}" \
+  -H "X-GitHub-Api-Version: 2022-11-28" \
+  https://api.github.com/user/repos \
+  -d "${create_payload}" >/tmp/github_repo_create_status.txt
+
+status_code="$(cat /tmp/github_repo_create_status.txt)"
+if [[ "${status_code}" != "201" && "${status_code}" != "422" ]]; then
+  echo "GitHub repo creation failed with HTTP ${status_code}" >&2
+  cat /tmp/github_repo_create.json >&2
+  exit 1
+fi
+
+if git remote get-url origin >/dev/null 2>&1; then
+  git remote set-url origin "https://github.com/${GITHUB_USERNAME}/${REPO_NAME}.git"
+else
+  git remote add origin "https://github.com/${GITHUB_USERNAME}/${REPO_NAME}.git"
+fi
+
+# Authenticated push URL
+git remote set-url --push origin "https://${GITHUB_USERNAME}:${GITHUB_TOKEN}@github.com/${GITHUB_USERNAME}/${REPO_NAME}.git"
+
+git push -u origin main
+
+# Reset push URL to tokenless remote after push
+git remote set-url --push origin "https://github.com/${GITHUB_USERNAME}/${REPO_NAME}.git"
+
+# 2) Create HF Docker Space repo and push
+huggingface-cli repo create "${HF_USERNAME}/${REPO_NAME}" \
+  --repo-type space \
+  --space_sdk docker \
+  --token "${HF_TOKEN}" \
+  --exist-ok >/tmp/hf_repo_create.log
+
+if git remote get-url huggingface >/dev/null 2>&1; then
+  git remote set-url huggingface "https://huggingface.co/spaces/${HF_USERNAME}/${REPO_NAME}"
+else
+  git remote add huggingface "https://huggingface.co/spaces/${HF_USERNAME}/${REPO_NAME}"
+fi
+
+git remote set-url --push huggingface "https://user:${HF_TOKEN}@huggingface.co/spaces/${HF_USERNAME}/${REPO_NAME}"
+
+git push -u huggingface main
+
+# Reset push URL to tokenless remote after push
+git remote set-url --push huggingface "https://huggingface.co/spaces/${HF_USERNAME}/${REPO_NAME}"
+
+echo "Completed."
+echo "GitHub: https://github.com/${GITHUB_USERNAME}/${REPO_NAME}"
+echo "HF Space: https://huggingface.co/spaces/${HF_USERNAME}/${REPO_NAME}"

scripts/pre_validation_script.sh

@@ -0,0 +1,185 @@
+#!/usr/bin/env bash
+#
+# validate-submission.sh — OpenEnv Submission Validator
+#
+# Checks that your HF Space is live, Docker image builds, and openenv validate passes.
+#
+# Prerequisites:
+#   - Docker:       https://docs.docker.com/get-docker/
+#   - openenv-core: pip install openenv-core
+#   - curl (usually pre-installed)
+#
+# Run:
+#   curl -fsSL https://raw.githubusercontent.com/<owner>/<repo>/main/scripts/validate-submission.sh | bash -s -- <ping_url> [repo_dir]
+#
+#   Or download and run locally:
+#     chmod +x validate-submission.sh
+#     ./validate-submission.sh <ping_url> [repo_dir]
+#
+# Arguments:
+#   ping_url   Your HuggingFace Space URL (e.g. https://your-space.hf.space)
+#   repo_dir   Path to your repo (default: current directory)
+#
+# Examples:
+#   ./validate-submission.sh https://my-team.hf.space
+#   ./validate-submission.sh https://my-team.hf.space ./my-repo
+#
+
+set -uo pipefail
+
+DOCKER_BUILD_TIMEOUT=600
+if [ -t 1 ]; then
+  RED='\033[0;31m'
+  GREEN='\033[0;32m'
+  YELLOW='\033[1;33m'
+  BOLD='\033[1m'
+  NC='\033[0m'
+else
+  RED='' GREEN='' YELLOW='' BOLD='' NC=''
+fi
+
+run_with_timeout() {
+  local secs="$1"; shift
+  if command -v timeout &>/dev/null; then
+    timeout "$secs" "$@"
+  elif command -v gtimeout &>/dev/null; then
+    gtimeout "$secs" "$@"
+  else
+    "$@" &
+    local pid=$!
+    ( sleep "$secs" && kill "$pid" 2>/dev/null ) &
+    local watcher=$!
+    wait "$pid" 2>/dev/null
+    local rc=$?
+    kill "$watcher" 2>/dev/null
+    wait "$watcher" 2>/dev/null
+    return $rc
+  fi
+}
+
+portable_mktemp() {
+  local prefix="${1:-validate}"
+  mktemp "${TMPDIR:-/tmp}/${prefix}-XXXXXX" 2>/dev/null || mktemp
+}
+
+CLEANUP_FILES=()
+cleanup() { rm -f "${CLEANUP_FILES[@]+"${CLEANUP_FILES[@]}"}"; }
+trap cleanup EXIT
+
+PING_URL="${1:-}"
+REPO_DIR="${2:-.}"
+
+if [ -z "$PING_URL" ]; then
+  printf "Usage: %s <ping_url> [repo_dir]\n" "$0"
+  printf "\n"
+  printf "  ping_url   Your HuggingFace Space URL (e.g. https://your-space.hf.space)\n"
+  printf "  repo_dir   Path to your repo (default: current directory)\n"
+  exit 1
+fi
+
+if ! REPO_DIR="$(cd "$REPO_DIR" 2>/dev/null && pwd)"; then
+  printf "Error: directory '%s' not found\n" "${2:-.}"
+  exit 1
+fi
+PING_URL="${PING_URL%/}"
+export PING_URL
+PASS=0
+
+log()  { printf "[%s] %b\n" "$(date -u +%H:%M:%S)" "$*"; }
+pass() { log "${GREEN}PASSED${NC} -- $1"; PASS=$((PASS + 1)); }
+fail() { log "${RED}FAILED${NC} -- $1"; }
+hint() { printf "  ${YELLOW}Hint:${NC} %b\n" "$1"; }
+stop_at() {
+  printf "\n"
+  printf "${RED}${BOLD}Validation stopped at %s.${NC} Fix the above before continuing.\n" "$1"
+  exit 1
+}
+
+printf "\n"
+printf "${BOLD}========================================${NC}\n"
+printf "${BOLD}  OpenEnv Submission Validator${NC}\n"
+printf "${BOLD}========================================${NC}\n"
+log "Repo:     $REPO_DIR"
+log "Ping URL: $PING_URL"
+printf "\n"
+
+log "${BOLD}Step 1/3: Pinging HF Space${NC} ($PING_URL/reset) ..."
+
+CURL_OUTPUT=$(portable_mktemp "validate-curl")
+CLEANUP_FILES+=("$CURL_OUTPUT")
+HTTP_CODE=$(curl -s -o "$CURL_OUTPUT" -w "%{http_code}" -X POST \
+  -H "Content-Type: application/json" -d '{}' \
+  "$PING_URL/reset" --max-time 30 2>"$CURL_OUTPUT" || printf "000")
+
+if [ "$HTTP_CODE" = "200" ]; then
+  pass "HF Space is live and responds to /reset"
+elif [ "$HTTP_CODE" = "000" ]; then
+  fail "HF Space not reachable (connection failed or timed out)"
+  hint "Check your network connection and that the Space is running."
+  hint "Try: curl -s -o /dev/null -w '%%{http_code}' -X POST $PING_URL/reset"
+  stop_at "Step 1"
+else
+  fail "HF Space /reset returned HTTP $HTTP_CODE (expected 200)"
+  hint "Make sure your Space is running and the URL is correct."
+  hint "Try opening $PING_URL in your browser first."
+  stop_at "Step 1"
+fi
+
+log "${BOLD}Step 2/3: Running docker build${NC} ..."
+
+if ! command -v docker &>/dev/null; then
+  fail "docker command not found"
+  hint "Install Docker: https://docs.docker.com/get-docker/"
+  stop_at "Step 2"
+fi
+
+if [ -f "$REPO_DIR/Dockerfile" ]; then
+  DOCKER_CONTEXT="$REPO_DIR"
+elif [ -f "$REPO_DIR/server/Dockerfile" ]; then
+  DOCKER_CONTEXT="$REPO_DIR/server"
+else
+  fail "No Dockerfile found in repo root or server/ directory"
+  stop_at "Step 2"
+fi
+
+log "  Found Dockerfile in $DOCKER_CONTEXT"
+
+BUILD_OK=false
+BUILD_OUTPUT=$(run_with_timeout "$DOCKER_BUILD_TIMEOUT" docker build "$DOCKER_CONTEXT" 2>&1) && BUILD_OK=true
+
+if [ "$BUILD_OK" = true ]; then
+  pass "Docker build succeeded"
+else
+  fail "Docker build failed (timeout=${DOCKER_BUILD_TIMEOUT}s)"
+  printf "%s\n" "$BUILD_OUTPUT" | tail -20
+  stop_at "Step 2"
+fi
+
+log "${BOLD}Step 3/3: Running openenv validate${NC} ..."
+
+if ! command -v openenv &>/dev/null; then
+  fail "openenv command not found"
+  hint "Install it: pip install openenv-core"
+  stop_at "Step 3"
+fi
+
+VALIDATE_OK=false
+VALIDATE_OUTPUT=$(cd "$REPO_DIR" && openenv validate 2>&1) && VALIDATE_OK=true
+
+if [ "$VALIDATE_OK" = true ]; then
+  pass "openenv validate passed"
+  [ -n "$VALIDATE_OUTPUT" ] && log "  $VALIDATE_OUTPUT"
+else
+  fail "openenv validate failed"
+  printf "%s\n" "$VALIDATE_OUTPUT"
+  stop_at "Step 3"
+fi
+
+printf "\n"
+printf "${BOLD}========================================${NC}\n"
+printf "${GREEN}${BOLD}  All 3/3 checks passed!${NC}\n"
+printf "${GREEN}${BOLD}  Your submission is ready to submit.${NC}\n"
+printf "${BOLD}========================================${NC}\n"
+printf "\n"
+
+exit 0

scripts/run_baseline.py

@@ -0,0 +1,197 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import argparse
+import json
+import os
+from dataclasses import asdict, dataclass
+from pathlib import Path
+from typing import Any
+
+from openai import OpenAI
+
+from support_triage_openenv import Action, SupportTriageEnv
+
+
+SYSTEM_PROMPT = """You are an agent solving a customer-support triage environment.
+Return exactly one JSON object for the next action with keys:
+- action_type: read_ticket | classify_ticket | draft_reply | resolve_ticket
+- ticket_id (required for read/classify/resolve)
+- priority, category, needs_escalation (for classify)
+- message (for draft_reply)
+No markdown, no extra text."""
+
+
+@dataclass
+class EpisodeResult:
+    task_id: str
+    steps: int
+    grader_score: float
+    reward: float
+    done_reason: str
+
+
+RULE_POLICY: dict[str, list[dict[str, Any]]] = {
+    "easy_password_reset": [
+        {"action_type": "read_ticket", "ticket_id": "T-1001"},
+        {
+            "action_type": "classify_ticket",
+            "ticket_id": "T-1001",
+            "priority": "medium",
+            "category": "account",
+            "needs_escalation": False,
+        },
+        {
+            "action_type": "draft_reply",
+            "message": (
+                "We will send a reset link to your email. For security, confirm the request "
+                "from your registered email before using the reset link."
+            ),
+        },
+        {"action_type": "resolve_ticket", "ticket_id": "T-1001"},
+    ],
+    "medium_billing_dispute": [
+        {"action_type": "read_ticket", "ticket_id": "T-2001"},
+        {"action_type": "read_ticket", "ticket_id": "T-2002"},
+        {
+            "action_type": "classify_ticket",
+            "ticket_id": "T-2001",
+            "priority": "high",
+            "category": "billing",
+            "needs_escalation": False,
+        },
+        {
+            "action_type": "draft_reply",
+            "message": (
+                "We confirmed a duplicate charge. We are issuing a refund and will share the invoice update. "
+                "Refund processing typically takes 3-5 business days."
+            ),
+        },
+        {"action_type": "resolve_ticket", "ticket_id": "T-2001"},
+    ],
+    "hard_outage_incident": [
+        {"action_type": "read_ticket", "ticket_id": "T-3001"},
+        {"action_type": "read_ticket", "ticket_id": "T-3002"},
+        {"action_type": "read_ticket", "ticket_id": "T-3003"},
+        {
+            "action_type": "classify_ticket",
+            "ticket_id": "T-3001",
+            "priority": "urgent",
+            "category": "technical",
+            "needs_escalation": True,
+        },
+        {
+            "action_type": "draft_reply",
+            "message": (
+                "We have escalated this incident and are investigating now. "
+                "The status page will carry updates while we continue incident response."
+            ),
+        },
+        {"action_type": "resolve_ticket", "ticket_id": "T-3001"},
+    ],
+}
+
+
+def _extract_json(text: str) -> str:
+    text = text.strip()
+    start = text.find("{")
+    end = text.rfind("}")
+    if start == -1 or end == -1 or end <= start:
+        raise ValueError("No JSON object found in model response")
+    return text[start : end + 1]
+
+
+def llm_action(client: OpenAI, model: str, observation: dict[str, Any], state: dict[str, Any]) -> Action:
+    user_prompt = json.dumps(
+        {
+            "observation": observation,
+            "state": state,
+            "instruction": "Pick the best next single action to maximize final score.",
+        },
+        ensure_ascii=True,
+    )
+
+    response = client.responses.create(
+        model=model,
+        temperature=0,
+        top_p=1,
+        input=[
+            {"role": "system", "content": [{"type": "text", "text": SYSTEM_PROMPT}]},
+            {"role": "user", "content": [{"type": "text", "text": user_prompt}]},
+        ],
+    )
+
+    raw = response.output_text or ""
+    payload = json.loads(_extract_json(raw))
+    return Action.model_validate(payload)
+
+
+def heuristic_action(task_id: str, step_idx: int) -> Action:
+    plan = RULE_POLICY[task_id]
+    idx = min(step_idx, len(plan) - 1)
+    return Action.model_validate(plan[idx])
+
+
+def run_episode(env: SupportTriageEnv, task_id: str, mode: str, model: str, client: OpenAI | None) -> EpisodeResult:
+    obs = env.reset(task_id)
+    done = False
+    info: dict[str, Any] = {}
+    reward_value = 0.0
+
+    while not done:
+        step_idx = env.state()["step_count"]
+        if mode == "heuristic":
+            action = heuristic_action(task_id, step_idx)
+        else:
+            assert client is not None
+            try:
+                action = llm_action(client, model, obs.model_dump(), env.state())
+            except Exception:
+                # Deterministic fallback keeps run alive for reproducible scoring.
+                action = heuristic_action(task_id, step_idx)
+
+        obs, reward, done, info = env.step(action)
+        reward_value = reward.value
+
+    return EpisodeResult(
+        task_id=task_id,
+        steps=env.state()["step_count"],
+        grader_score=float(info["grader_score"]),
+        reward=reward_value,
+        done_reason=str(info["done_reason"]),
+    )
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Run baseline on support-triage-openenv tasks.")
+    parser.add_argument("--mode", choices=["openai", "heuristic"], default="openai")
+    parser.add_argument("--model", default="gpt-4.1-mini")
+    parser.add_argument("--output", default="scores/baseline_scores.json")
+    args = parser.parse_args()
+
+    client = None
+    if args.mode == "openai":
+        if not os.getenv("OPENAI_API_KEY"):
+            raise RuntimeError("OPENAI_API_KEY is required for --mode openai")
+        client = OpenAI()
+
+    env = SupportTriageEnv()
+    results = [run_episode(env, t, args.mode, args.model, client) for t in env.task_ids]
+
+    summary = {
+        "mode": args.mode,
+        "model": args.model,
+        "avg_grader_score": round(sum(r.grader_score for r in results) / len(results), 4),
+        "avg_final_reward": round(sum(r.reward for r in results) / len(results), 4),
+        "episodes": [asdict(r) for r in results],
+    }
+
+    output_path = Path(args.output)
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    output_path.write_text(json.dumps(summary, indent=2), encoding="utf-8")
+
+    print(json.dumps(summary, indent=2))
+
+
+if __name__ == "__main__":
+    main()

scripts/sample_inference_script.sh

@@ -0,0 +1,188 @@
+"""
+Inference Script Example
+===================================
+MANDATORY
+- Before submitting, ensure the following variables are defined in your environment configuration:
+    API_BASE_URL   The API endpoint for the LLM.
+    MODEL_NAME     The model identifier to use for inference.
+    HF_TOKEN       Your Hugging Face / API key.
+    LOCAL_IMAGE_NAME The name of the local image to use for the environment if you are using from_docker_image()
+                     method
+
+- Defaults are set only for API_BASE_URL and MODEL_NAME 
+    (and should reflect your active inference setup):
+    API_BASE_URL = os.getenv("API_BASE_URL", "<your-active-endpoint>")
+    MODEL_NAME = os.getenv("MODEL_NAME", "<your-active-model>")
+    
+- The inference script must be named `inference.py` and placed in the root directory of the project
+- Participants must use OpenAI Client for all LLM calls using above variables
+
+STDOUT FORMAT
+- The script must emit exactly three line types to stdout, in this order:
+
+    [START] task=<task_name> env=<benchmark> model=<model_name>
+    [STEP]  step=<n> action=<action_str> reward=<0.00> done=<true|false> error=<msg|null>
+    [END]   success=<true|false> steps=<n> score=<score> rewards=<r1,r2,...,rn>
+
+  Rules:
+    - One [START] line at episode begin.
+    - One [STEP] line per step, immediately after env.step() returns.
+    - One [END] line after env.close(), always emitted (even on exception).
+    - reward and rewards are formatted to 2 decimal places.
+    - done and success are lowercase booleans: true or false.
+    - error is the raw last_action_error string, or null if none.
+    - All fields on a single line with no newlines within a line.
+    - Each tasks should return score in [0, 1]
+
+  Example:
+    [START] task=click-test env=miniwob model=Qwen3-VL-30B
+    [STEP] step=1 action=click('123') reward=0.00 done=false error=null
+    [STEP] step=2 action=fill('456','text') reward=0.00 done=false error=null
+    [STEP] step=3 action=click('789') reward=1.00 done=true error=null
+    [END] success=true steps=3 score=1.00 rewards=0.00,0.00,1.00
+"""
+
+import asyncio
+import os
+import textwrap
+from typing import List, Optional
+
+from openai import OpenAI
+
+from my_env_v4 import MyEnvV4Action, MyEnvV4Env
+IMAGE_NAME = os.getenv("IMAGE_NAME") # If you are using docker image 
+API_KEY = os.getenv("HF_TOKEN") or os.getenv("API_KEY")
+
+API_BASE_URL = os.getenv("API_BASE_URL") or "https://router.huggingface.co/v1"
+MODEL_NAME = os.getenv("MODEL_NAME") or "Qwen/Qwen2.5-72B-Instruct"
+TASK_NAME = os.getenv("MY_ENV_V4_TASK", "echo")
+BENCHMARK = os.getenv("MY_ENV_V4_BENCHMARK", "my_env_v4")
+MAX_STEPS = 8
+TEMPERATURE = 0.7
+MAX_TOKENS = 150
+SUCCESS_SCORE_THRESHOLD = 0.1  # normalized score in [0, 1]
+
+# Max possible reward: each token contributes 0.1, across all steps
+_MAX_REWARD_PER_STEP = MAX_TOKENS * 0.1
+MAX_TOTAL_REWARD = MAX_STEPS * _MAX_REWARD_PER_STEP
+
+SYSTEM_PROMPT = textwrap.dedent(
+    """
+    You are interacting with a simple echo environment.
+    Each turn you must send a message. The environment will echo it back.
+    Reward is proportional to message length: reward = len(message) * 0.1
+    Your goal is to maximize total reward by sending meaningful, substantive messages.
+    Reply with exactly one message string — no quotes, no prefixes, just the message text.
+    """
+).strip()
+
+
+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: str, reward: float, done: bool, error: Optional[str]) -> None:
+    error_val = error if error else "null"
+    done_val = str(done).lower()
+    print(
+        f"[STEP] step={step} action={action} reward={reward:.2f} done={done_val} error={error_val}",
+        flush=True,
+    )
+
+
+def log_end(success: bool, steps: int, score: float, rewards: List[float]) -> None:
+    rewards_str = ",".join(f"{r:.2f}" for r in rewards)
+    print(f"[END] success={str(success).lower()} steps={steps} score={score:.3f} rewards={rewards_str}", flush=True)
+
+
+def build_user_prompt(step: int, last_echoed: str, last_reward: float, history: List[str]) -> str:
+    history_block = "\n".join(history[-4:]) if history else "None"
+    return textwrap.dedent(
+        f"""
+        Step: {step}
+        Last echoed message: {last_echoed!r}
+        Last reward: {last_reward:.2f}
+        Previous steps:
+        {history_block}
+        Send your next message.
+        """
+    ).strip()
+
+
+def get_model_message(client: OpenAI, step: int, last_echoed: str, last_reward: float, history: List[str]) -> str:
+    user_prompt = build_user_prompt(step, last_echoed, last_reward, history)
+    try:
+        completion = client.chat.completions.create(
+            model=MODEL_NAME,
+            messages=[
+                {"role": "system", "content": SYSTEM_PROMPT},
+                {"role": "user", "content": user_prompt},
+            ],
+            temperature=TEMPERATURE,
+            max_tokens=MAX_TOKENS,
+            stream=False,
+        )
+        text = (completion.choices[0].message.content or "").strip()
+        return text if text else "hello"
+    except Exception as exc:
+        print(f"[DEBUG] Model request failed: {exc}", flush=True)
+        return "hello"
+
+
+async def main() -> None:
+    client = OpenAI(base_url=API_BASE_URL, api_key=API_KEY)
+
+    env = await MyEnvV4Env.from_docker_image(IMAGE_NAME)
+
+    history: List[str] = []
+    rewards: List[float] = []
+    steps_taken = 0
+    score = 0.0
+    success = False
+
+    log_start(task=TASK_NAME, env=BENCHMARK, model=MODEL_NAME)
+
+    try:
+        result = await env.reset() # OpenENV.reset()
+        last_echoed = result.observation.echoed_message
+        last_reward = 0.0
+
+        for step in range(1, MAX_STEPS + 1):
+            if result.done:
+                break
+
+            message = get_model_message(client, step, last_echoed, last_reward, history)
+
+            result = await env.step(MyEnvV4Action(message=message))
+            obs = result.observation
+
+            reward = result.reward or 0.0
+            done = result.done
+            error = None
+
+            rewards.append(reward)
+            steps_taken = step
+            last_echoed = obs.echoed_message
+            last_reward = reward
+
+            log_step(step=step, action=message, reward=reward, done=done, error=error)
+
+            history.append(f"Step {step}: {message!r} -> reward {reward:+.2f}")
+
+            if done:
+                break
+
+        score = sum(rewards) / MAX_TOTAL_REWARD if MAX_TOTAL_REWARD > 0 else 0.0
+        score = min(max(score, 0.0), 1.0)  # clamp to [0, 1]
+        success = score >= SUCCESS_SCORE_THRESHOLD
+
+    finally:
+        try:
+            await env.close()
+        except Exception as e:
+            print(f"[DEBUG] env.close() error (container cleanup): {e}", flush=True)
+        log_end(success=success, steps=steps_taken, score=score, rewards=rewards)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

scripts/validate_env.py

@@ -0,0 +1,30 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import shutil
+import subprocess
+
+
+def run_local_checks() -> None:
+    commands = [
+        ["python", "-m", "pytest", "-q"],
+    ]
+
+    for cmd in commands:
+        print(f"$ {' '.join(cmd)}")
+        subprocess.run(cmd, check=True)
+
+
+def run_openenv_validate_if_available() -> None:
+    if shutil.which("openenv") is None:
+        print("openenv CLI not found; skipped `openenv validate`.")
+        return
+
+    cmd = ["openenv", "validate", "openenv.yaml"]
+    print(f"$ {' '.join(cmd)}")
+    subprocess.run(cmd, check=True)
+
+
+if __name__ == "__main__":
+    run_local_checks()
+    run_openenv_validate_if_available()

src/support_triage_openenv/__init__.py

@@ -0,0 +1,6 @@
+"""Support triage OpenEnv package."""
+
+from .env import SupportTriageEnv
+from .models import Action, Observation, Reward
+
+__all__ = ["SupportTriageEnv", "Observation", "Action", "Reward"]

src/support_triage_openenv/env.py

@@ -0,0 +1,229 @@
+from __future__ import annotations
+
+import copy
+from typing import Any
+
+from .graders import grade_task
+from .models import Action, Observation, Reward, StepInfo, TicketView
+from .tasks import TaskSpec, get_tasks
+
+
+class SupportTriageEnv:
+    """
+    OpenEnv-compatible environment for customer support ticket triage.
+
+    API:
+      - reset(task_id: str | None = None) -> Observation
+      - step(action: Action) -> tuple[Observation, Reward, bool, dict[str, Any]]
+      - state() -> dict[str, Any]
+    """
+
+    def __init__(self) -> None:
+        self._tasks: dict[str, TaskSpec] = {t.task_id: t for t in get_tasks()}
+        self._task_order = [t.task_id for t in get_tasks()]
+        self._task_index = 0
+        self._current_task: TaskSpec | None = None
+        self._state: dict[str, Any] = {}
+
+    @property
+    def task_ids(self) -> list[str]:
+        return list(self._task_order)
+
+    def reset(self, task_id: str | None = None) -> Observation:
+        if task_id is None:
+            task_id = self._task_order[self._task_index % len(self._task_order)]
+            self._task_index += 1
+        if task_id not in self._tasks:
+            raise ValueError(f"Unknown task_id '{task_id}'. Available: {sorted(self._tasks.keys())}")
+
+        self._current_task = self._tasks[task_id]
+        self._state = {
+            "step_count": 0,
+            "read_ticket_ids": set(),
+            "selected_ticket_id": None,
+            "classification": None,
+            "draft_reply": None,
+            "resolved": False,
+            "resolved_ticket_id": None,
+            "invalid_actions": 0,
+            "repeat_actions": 0,
+            "action_history": [],
+            "last_note": "Environment reset.",
+            "done": False,
+            "done_reason": "ongoing",
+        }
+        return self._build_observation()
+
+    def step(self, action: Action) -> tuple[Observation, Reward, bool, dict[str, Any]]:
+        if self._current_task is None:
+            raise RuntimeError("Call reset() before step().")
+        if self._state["done"]:
+            raise RuntimeError("Episode already done. Call reset() for a new episode.")
+
+        task = self._current_task
+        st = self._state
+        st["step_count"] += 1
+
+        action_fingerprint = action.model_dump_json()
+        if st["action_history"] and st["action_history"][-1] == action_fingerprint:
+            st["repeat_actions"] += 1
+        st["action_history"].append(action_fingerprint)
+
+        valid_ticket_ids = {t["ticket_id"] for t in task.tickets}
+        step_penalty = 0.0
+
+        if action.action_type in {"read_ticket", "classify_ticket", "resolve_ticket"}:
+            if not action.ticket_id or action.ticket_id not in valid_ticket_ids:
+                st["invalid_actions"] += 1
+                st["last_note"] = "Invalid or missing ticket_id."
+                step_penalty -= 0.03
+                if st["invalid_actions"] >= 3:
+                    st["done"] = True
+                    st["done_reason"] = "invalid_action"
+                return self._assemble_step_response(step_penalty)
+
+        if action.action_type == "read_ticket":
+            st["read_ticket_ids"].add(action.ticket_id)
+            st["selected_ticket_id"] = action.ticket_id
+            st["last_note"] = f"Read ticket {action.ticket_id}."
+
+        elif action.action_type == "classify_ticket":
+            if action.ticket_id != task.target_ticket_id:
+                step_penalty -= 0.01
+            st["classification"] = {
+                "ticket_id": action.ticket_id,
+                "priority": action.priority,
+                "category": action.category,
+                "needs_escalation": action.needs_escalation,
+            }
+            st["last_note"] = f"Saved classification for {action.ticket_id}."
+
+        elif action.action_type == "draft_reply":
+            text = (action.message or "").strip()
+            if not text:
+                st["invalid_actions"] += 1
+                st["last_note"] = "Draft reply is empty."
+                step_penalty -= 0.02
+            else:
+                st["draft_reply"] = text
+                st["last_note"] = "Draft reply saved."
+
+        elif action.action_type == "resolve_ticket":
+            st["resolved"] = True
+            st["resolved_ticket_id"] = action.ticket_id
+            st["done"] = True
+            st["done_reason"] = "resolved"
+            st["last_note"] = f"Resolved ticket {action.ticket_id}."
+
+        else:
+            st["invalid_actions"] += 1
+            st["last_note"] = f"Unknown action {action.action_type}."
+            step_penalty -= 0.03
+
+        if st["step_count"] >= task.max_steps and not st["done"]:
+            st["done"] = True
+            st["done_reason"] = "max_steps"
+            st["last_note"] = "Reached max_steps."
+
+        if st["repeat_actions"] > 0:
+            step_penalty -= min(0.04, 0.01 * st["repeat_actions"])
+
+        return self._assemble_step_response(step_penalty)
+
+    def state(self) -> dict[str, Any]:
+        if self._current_task is None:
+            raise RuntimeError("Environment not initialized. Call reset() first.")
+        visible = copy.deepcopy(self._state)
+        visible["read_ticket_ids"] = sorted(list(visible["read_ticket_ids"]))
+        visible["task_id"] = self._current_task.task_id
+        return visible
+
+    def _build_observation(self) -> Observation:
+        assert self._current_task is not None
+        task = self._current_task
+        st = self._state
+
+        content = None
+        if st.get("selected_ticket_id") in st["read_ticket_ids"]:
+            ticket = next(t for t in task.tickets if t["ticket_id"] == st["selected_ticket_id"])
+            content = ticket["content"]
+
+        inbox = [
+            TicketView(
+                ticket_id=t["ticket_id"],
+                subject=t["subject"],
+                customer_tier=t["customer_tier"],
+                age_minutes=t["age_minutes"],
+                read=t["ticket_id"] in st["read_ticket_ids"],
+            )
+            for t in task.tickets
+        ]
+
+        partial = grade_task(task, st)
+        return Observation(
+            task_id=task.task_id,
+            objective=task.objective,
+            step_count=st["step_count"],
+            max_steps=task.max_steps,
+            inbox=inbox,
+            current_ticket_content=content,
+            latest_system_note=st.get("last_note", ""),
+            score_hint={
+                "read": partial.read_score,
+                "classify": partial.classify_score,
+                "reply": partial.reply_score,
+                "resolve": partial.resolve_score,
+            },
+        )
+
+    def _assemble_step_response(self, step_penalty: float) -> tuple[Observation, Reward, bool, dict[str, Any]]:
+        assert self._current_task is not None
+        task = self._current_task
+        st = self._state
+
+        grade = grade_task(task, st)
+        progress_signal = 0.75 * grade.total
+        penalty_total = 0.0
+
+        penalties: dict[str, float] = {}
+        if st["invalid_actions"]:
+            penalties["invalid_actions"] = round(min(0.2, 0.04 * st["invalid_actions"]), 4)
+            penalty_total += penalties["invalid_actions"]
+        if st["repeat_actions"]:
+            penalties["repetition"] = round(min(0.15, 0.02 * st["repeat_actions"]), 4)
+            penalty_total += penalties["repetition"]
+        if step_penalty < 0:
+            penalties["step_penalty"] = round(abs(step_penalty), 4)
+            penalty_total += abs(step_penalty)
+
+        reward_value = progress_signal - penalty_total
+        if st["done"]:
+            reward_value = max(reward_value, grade.total)
+
+        reward_value = max(0.0, min(1.0, reward_value))
+
+        reward = Reward(
+            value=round(reward_value, 4),
+            components={
+                "progress_signal": round(progress_signal, 4),
+                "grade_total": grade.total,
+                "read_score": grade.read_score,
+                "classify_score": grade.classify_score,
+                "reply_score": grade.reply_score,
+                "resolve_score": grade.resolve_score,
+                "penalty_total": round(penalty_total, 4),
+            },
+            reasoning="Shaped reward from grader progress with penalties for invalid or looping actions.",
+        )
+
+        info = StepInfo(
+            task_id=task.task_id,
+            done_reason=st["done_reason"],
+            grader_score=grade.total,
+            reward_components=reward.components,
+            penalties=penalties,
+            state_snapshot=self.state(),
+        ).model_dump()
+
+        obs = self._build_observation()
+        return obs, reward, st["done"], info

src/support_triage_openenv/graders.py

@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from .tasks import TaskSpec
+
+
+@dataclass
+class GradeBreakdown:
+    read_score: float
+    classify_score: float
+    reply_score: float
+    resolve_score: float
+    total: float
+
+
+def _keyword_coverage(message: str, required: tuple[str, ...]) -> float:
+    if not required:
+        return 1.0
+    lowered = message.lower()
+    found = sum(1 for k in required if k.lower() in lowered)
+    return found / len(required)
+
+
+def _forbidden_penalty(message: str, forbidden: tuple[str, ...]) -> float:
+    lowered = message.lower()
+    count = sum(1 for k in forbidden if k.lower() in lowered)
+    return min(1.0, 0.5 * count)
+
+
+def grade_task(task: TaskSpec, env_state: dict) -> GradeBreakdown:
+    read_target = 1.0 if task.target_ticket_id in env_state["read_ticket_ids"] else 0.0
+    context_hits = sum(1 for tid in task.required_context_ticket_ids if tid in env_state["read_ticket_ids"])
+    context_total = len(task.required_context_ticket_ids)
+    context_score = context_hits / context_total if context_total else 1.0
+    read_score = 0.6 * read_target + 0.4 * context_score
+
+    classification = env_state.get("classification") or {}
+    fields_correct = 0
+    fields_total = 3
+    fields_correct += int(classification.get("priority") == task.expected_priority)
+    fields_correct += int(classification.get("category") == task.expected_category)
+    fields_correct += int(classification.get("needs_escalation") == task.expected_escalation)
+    classify_score = fields_correct / fields_total
+
+    draft = env_state.get("draft_reply") or ""
+    keyword_score = _keyword_coverage(draft, task.required_reply_keywords)
+    forbidden_penalty = _forbidden_penalty(draft, task.forbidden_reply_keywords)
+    reply_score = max(0.0, keyword_score - forbidden_penalty)
+
+    resolved = bool(env_state.get("resolved"))
+    resolved_target = env_state.get("resolved_ticket_id") == task.target_ticket_id
+    resolve_score = 1.0 if resolved and resolved_target else 0.0
+
+    total = (0.2 * read_score) + (0.35 * classify_score) + (0.3 * reply_score) + (0.15 * resolve_score)
+    total = max(0.0, min(1.0, total))
+
+    return GradeBreakdown(
+        read_score=round(read_score, 4),
+        classify_score=round(classify_score, 4),
+        reply_score=round(reply_score, 4),
+        resolve_score=round(resolve_score, 4),
+        total=round(total, 4),
+    )

src/support_triage_openenv/models.py

@@ -0,0 +1,53 @@
+from __future__ import annotations
+
+from typing import Any, Literal
+
+from pydantic import BaseModel, Field
+
+
+ActionType = Literal["read_ticket", "classify_ticket", "draft_reply", "resolve_ticket"]
+PriorityType = Literal["low", "medium", "high", "urgent"]
+CategoryType = Literal["account", "billing", "technical", "abuse", "general"]
+
+
+class TicketView(BaseModel):
+    ticket_id: str
+    subject: str
+    customer_tier: Literal["free", "pro", "enterprise"]
+    age_minutes: int
+    read: bool = False
+
+
+class Observation(BaseModel):
+    task_id: str
+    objective: str
+    step_count: int
+    max_steps: int
+    inbox: list[TicketView]
+    current_ticket_content: str | None = None
+    latest_system_note: str = ""
+    score_hint: dict[str, float] = Field(default_factory=dict)
+
+
+class Action(BaseModel):
+    action_type: ActionType
+    ticket_id: str | None = None
+    priority: PriorityType | None = None
+    category: CategoryType | None = None
+    needs_escalation: bool | None = None
+    message: str | None = None
+
+
+class Reward(BaseModel):
+    value: float = Field(ge=0.0, le=1.0)
+    components: dict[str, float] = Field(default_factory=dict)
+    reasoning: str = ""
+
+
+class StepInfo(BaseModel):
+    task_id: str
+    done_reason: Literal["ongoing", "resolved", "max_steps", "invalid_action"]
+    grader_score: float
+    reward_components: dict[str, float]
+    penalties: dict[str, float]
+    state_snapshot: dict[str, Any]

src/support_triage_openenv/tasks.py

@@ -0,0 +1,153 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+
+@dataclass(frozen=True)
+class TaskSpec:
+    task_id: str
+    difficulty: str
+    title: str
+    objective: str
+    max_steps: int
+    target_ticket_id: str
+    required_context_ticket_ids: tuple[str, ...]
+    expected_priority: str
+    expected_category: str
+    expected_escalation: bool
+    required_reply_keywords: tuple[str, ...]
+    forbidden_reply_keywords: tuple[str, ...]
+    tickets: tuple[dict[str, Any], ...]
+
+
+def get_tasks() -> list[TaskSpec]:
+    return [
+        TaskSpec(
+            task_id="easy_password_reset",
+            difficulty="easy",
+            title="Password reset triage",
+            objective=(
+                "Resolve customer lockout ticket by selecting correct category/priority and drafting "
+                "a secure response that includes a reset link workflow."
+            ),
+            max_steps=10,
+            target_ticket_id="T-1001",
+            required_context_ticket_ids=(),
+            expected_priority="medium",
+            expected_category="account",
+            expected_escalation=False,
+            required_reply_keywords=("reset link", "security", "confirm", "email"),
+            forbidden_reply_keywords=("share your password",),
+            tickets=(
+                {
+                    "ticket_id": "T-1001",
+                    "subject": "Cannot log in after phone change",
+                    "customer_tier": "pro",
+                    "age_minutes": 33,
+                    "content": (
+                        "I switched phones and now MFA fails. I need urgent access to my dashboard. "
+                        "Please help me reset safely."
+                    ),
+                },
+                {
+                    "ticket_id": "T-1002",
+                    "subject": "Feature request: dark mode",
+                    "customer_tier": "free",
+                    "age_minutes": 250,
+                    "content": "Could you add dark mode next quarter?",
+                },
+            ),
+        ),
+        TaskSpec(
+            task_id="medium_billing_dispute",
+            difficulty="medium",
+            title="Billing dispute and partial refund",
+            objective=(
+                "Assess a duplicate charge complaint, inspect context ticket, classify correctly, "
+                "and draft a policy-compliant refund response."
+            ),
+            max_steps=12,
+            target_ticket_id="T-2001",
+            required_context_ticket_ids=("T-2002",),
+            expected_priority="high",
+            expected_category="billing",
+            expected_escalation=False,
+            required_reply_keywords=("duplicate charge", "refund", "3-5 business days", "invoice"),
+            forbidden_reply_keywords=("guaranteed immediate refund",),
+            tickets=(
+                {
+                    "ticket_id": "T-2001",
+                    "subject": "Charged twice this month",
+                    "customer_tier": "enterprise",
+                    "age_minutes": 85,
+                    "content": (
+                        "We were charged twice for March. Finance needs confirmation and refund timeline today."
+                    ),
+                },
+                {
+                    "ticket_id": "T-2002",
+                    "subject": "Billing system log",
+                    "customer_tier": "enterprise",
+                    "age_minutes": 80,
+                    "content": "Payment gateway shows one charge capture and one duplicate authorization hold.",
+                },
+                {
+                    "ticket_id": "T-2003",
+                    "subject": "Onboarding docs typo",
+                    "customer_tier": "pro",
+                    "age_minutes": 700,
+                    "content": "There is a typo in page 3 of setup docs.",
+                },
+            ),
+        ),
+        TaskSpec(
+            task_id="hard_outage_incident",
+            difficulty="hard",
+            title="Incident comms under pressure",
+            objective=(
+                "Handle a potential security outage report by collecting key evidence from related tickets, "
+                "setting urgent escalation, and drafting a safe incident response message without over-promising."
+            ),
+            max_steps=14,
+            target_ticket_id="T-3001",
+            required_context_ticket_ids=("T-3002", "T-3003"),
+            expected_priority="urgent",
+            expected_category="technical",
+            expected_escalation=True,
+            required_reply_keywords=("incident", "investigating", "status page", "escalated"),
+            forbidden_reply_keywords=("issue is fully resolved", "ignore this"),
+            tickets=(
+                {
+                    "ticket_id": "T-3001",
+                    "subject": "API returning 500 for all EU requests",
+                    "customer_tier": "enterprise",
+                    "age_minutes": 18,
+                    "content": (
+                        "Since 08:10 UTC every API call fails. We suspect a region outage and possible data inconsistency."
+                    ),
+                },
+                {
+                    "ticket_id": "T-3002",
+                    "subject": "SOC alert summary",
+                    "customer_tier": "enterprise",
+                    "age_minutes": 15,
+                    "content": "Monitoring confirms spike in error rate and elevated auth failures in eu-west-1.",
+                },
+                {
+                    "ticket_id": "T-3003",
+                    "subject": "Status page draft",
+                    "customer_tier": "enterprise",
+                    "age_minutes": 11,
+                    "content": "Public message should acknowledge incident, investigation, and next update ETA.",
+                },
+                {
+                    "ticket_id": "T-3004",
+                    "subject": "Question about annual billing",
+                    "customer_tier": "free",
+                    "age_minutes": 1440,
+                    "content": "Can I switch to annual plan later?",
+                },
+            ),
+        ),
+    ]

tasks/TASKS.md

@@ -0,0 +1,25 @@
+# Task Details
+
+## easy_password_reset
+Objective: resolve a lockout request safely.
+Success signals:
+- Read the target ticket.
+- Classify as `priority=medium`, `category=account`, `needs_escalation=False`.
+- Draft reply mentions reset link and security confirmation.
+- Resolve correct ticket.
+
+## medium_billing_dispute
+Objective: handle duplicate charge dispute with refund communication.
+Success signals:
+- Read `T-2001` and context `T-2002`.
+- Classify as `priority=high`, `category=billing`, `needs_escalation=False`.
+- Reply references duplicate charge, refund, invoice, and `3-5 business days`.
+- Resolve `T-2001`.
+
+## hard_outage_incident
+Objective: process potential incident/outage with escalation and careful external comms.
+Success signals:
+- Read `T-3001`, `T-3002`, `T-3003` context.
+- Classify as `priority=urgent`, `category=technical`, `needs_escalation=True`.
+- Reply includes incident acknowledgement, active investigation, status page updates, escalation.
+- Resolve `T-3001`.

tests/test_api.py

@@ -0,0 +1,27 @@
+from fastapi.testclient import TestClient
+
+from app import app
+
+
+def test_health_and_reset_flow():
+    client = TestClient(app)
+
+    health = client.get('/health')
+    assert health.status_code == 200
+    assert health.json()['status'] == 'ok'
+
+    reset = client.post('/reset', json={'task_id': 'easy_password_reset'})
+    assert reset.status_code == 200
+    payload = reset.json()
+    assert payload['task_id'] == 'easy_password_reset'
+    assert payload['step_count'] == 0
+
+    step = client.post('/step', json={'action_type': 'read_ticket', 'ticket_id': 'T-1001'})
+    assert step.status_code == 200
+    body = step.json()
+    assert body['done'] is False
+    assert body['observation']['step_count'] == 1
+
+    state = client.get('/state')
+    assert state.status_code == 200
+    assert state.json()['task_id'] == 'easy_password_reset'

tests/test_env.py

@@ -0,0 +1,47 @@
+from support_triage_openenv.env import SupportTriageEnv
+from support_triage_openenv.models import Action
+
+
+def test_reset_and_state_cycle():
+    env = SupportTriageEnv()
+    obs = env.reset("easy_password_reset")
+    assert obs.task_id == "easy_password_reset"
+    assert obs.step_count == 0
+    state = env.state()
+    assert state["done"] is False
+
+
+def test_easy_task_can_reach_high_score():
+    env = SupportTriageEnv()
+    env.reset("easy_password_reset")
+    env.step(Action(action_type="read_ticket", ticket_id="T-1001"))
+    env.step(
+        Action(
+            action_type="classify_ticket",
+            ticket_id="T-1001",
+            priority="medium",
+            category="account",
+            needs_escalation=False,
+        )
+    )
+    env.step(
+        Action(
+            action_type="draft_reply",
+            message=(
+                "We will send a reset link to your email. For security, please confirm the request "
+                "from your device after receiving the reset link."
+            ),
+        )
+    )
+    _, reward, done, info = env.step(Action(action_type="resolve_ticket", ticket_id="T-1001"))
+    assert done is True
+    assert info["grader_score"] >= 0.9
+    assert reward.value >= 0.9
+
+
+def test_invalid_ticket_penalty_and_done_guard():
+    env = SupportTriageEnv()
+    env.reset("medium_billing_dispute")
+    _, reward, _, info = env.step(Action(action_type="read_ticket", ticket_id="NOT-REAL"))
+    assert reward.value < 0.5
+    assert info["penalties"]