initial

.hfignore-extra

@@ -0,0 +1,4 @@
+__pycache__/
+*.pyc
+support_ops_env/venv/
+.venv/

Dockerfile

@@ -0,0 +1,15 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+
+ENV PYTHONDONTWRITEBYTECODE=1
+ENV PYTHONUNBUFFERED=1
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY . .
+
+EXPOSE 7860
+
+CMD ["python", "app.py"]

README.md

@@ -0,0 +1,249 @@
+---
+title: SupportOpsEnv
+sdk: docker
+app_port: 7860
+tags:
+  - openenv
+  - customer-support
+  - evaluation
+---
+
+# SupportOpsEnv
+
+SupportOpsEnv is a multi-step environment for evaluating agents on realistic customer support operations. The agent behaves like a support analyst: it reviews ticket summaries, requests missing context, assigns priority, chooses the correct internal route, selects a resolution, escalates when needed, and finalizes the case. This models a genuine workflow used by support operations, trust and safety, monetization, and account-recovery teams.
+
+The environment is designed to score well against OpenEnv-style hackathon criteria:
+
+- Real-world task simulation instead of a toy game
+- Three deterministic tasks with easy, medium, and hard difficulty
+- Dense reward shaping across the trajectory
+- Typed observation, action, and reward models
+- Reproducible OpenAI baseline runner
+- Reproducible rule-based baseline runner that works with no API key
+- Dockerized deployment path for Hugging Face Spaces
+
+## Environment Motivation
+
+Support queue triage is one of the clearest real-world benchmarks for agent quality:
+
+- Humans perform it every day
+- It requires multi-step reasoning, not one-shot classification
+- Progress can be measured deterministically
+- It exposes practical agent failure modes such as premature resolution, wrong escalation, and poor prioritization
+
+## Observation Space
+
+`Observation` is a Pydantic model with:
+
+- `task_id`: active task identifier
+- `difficulty`: `easy`, `medium`, or `hard`
+- `title`: task title
+- `instruction`: natural-language objective
+- `queue_mode`: whether the task contains multiple tickets
+- `tickets`: list of ticket observations
+- `remaining_steps`: steps left in the episode
+- `available_actions`: valid action names
+- `current_queue_order`: current queue ranking, if any
+- `score_hint`: latest intermediate grader snapshot
+
+Each ticket observation contains:
+
+- `ticket_id`
+- `summary`
+- `visible_context`
+- `discovered_context`
+- `selected_priority`
+- `selected_route`
+- `selected_resolution`
+- `escalation_team`
+
+## Action Space
+
+`Action` is a Pydantic model with:
+
+- `action_type`
+- `target`
+- `value`
+
+Supported `action_type` values:
+
+- `inspect_ticket`
+- `request_context`
+- `set_priority`
+- `set_route`
+- `set_resolution`
+- `escalate`
+- `rank_queue`
+- `finalize`
+
+## Reward Design
+
+`RewardModel` is a Pydantic model with:
+
+- `value`
+- `components`
+- `rationale`
+
+Reward shaping is dense, not sparse:
+
+- positive reward for discovering required context
+- positive reward for correct intermediate decisions
+- positive reward for correct queue ranking progress
+- terminal reward from the deterministic grader score
+- penalties for invalid actions, redundant actions, and wasted steps
+
+This creates learning or evaluation signal over the full trajectory.
+
+## Tasks
+
+### Easy: Account Takeover Triage
+
+Objective: correctly handle an urgent suspected account takeover with unauthorized ad spend.
+
+Expected difficulty: easy.
+
+Success criteria:
+
+- request the right security and billing context
+- assign `urgent`
+- route to `account_security`
+- choose `temporary_lock_and_manual_recovery`
+- escalate to `security_specialist`
+
+### Medium: Monetization Payout Hold
+
+Objective: investigate a missing creator payout and avoid unsafe release of funds.
+
+Expected difficulty: medium.
+
+Success criteria:
+
+- discover tax-expiry and compliance-hold context
+- assign `high`
+- route to `monetization_compliance`
+- choose `request_tax_renewal`
+- avoid unnecessary escalation
+
+### Hard: Mixed Support Queue Triage
+
+Objective: prioritize and resolve a heterogeneous queue under SLA pressure.
+
+Expected difficulty: hard.
+
+Success criteria:
+
+- correctly rank the queue
+- assign route and priority for each ticket
+- choose correct resolutions
+- escalate only the security-critical case
+
+## Graders
+
+Each task has a deterministic grader that returns a score in `0.0` to `1.0`.
+
+- Easy grader weights context, priority, route, resolution, and escalation
+- Medium grader weights context and policy-safe resolution more heavily
+- Hard grader scores per-ticket handling and queue ranking
+
+Programmatic graders live in [support_ops_env/graders](/home/batman/Downloads/presentation_template/support_ops_env/support_ops_env/graders).
+
+## Setup
+
+```bash
+cd support_ops_env
+python -m venv .venv
+source .venv/bin/activate
+pip install -r requirements.txt
+```
+
+## Usage
+
+Run the local tests:
+
+```bash
+python -m unittest discover -s tests -p 'test_*.py'
+```
+
+Run the app locally:
+
+```bash
+python app.py
+```
+
+Run the default no-API baseline:
+
+```bash
+python scripts/run_rule_baseline.py
+```
+
+Run the OpenAI baseline if you have an API key:
+
+```bash
+export OPENAI_API_KEY=your_key_here
+python scripts/run_baseline.py --model gpt-4.1-mini
+```
+
+Validate metadata:
+
+```bash
+bash scripts/validate_env.sh
+```
+
+If the `openenv` CLI is installed, the script will also run `openenv validate openenv.yaml`.
+
+## Baseline Scores
+
+The repository now includes a deterministic baseline in [run_rule_baseline.py](/home/batman/Downloads/presentation_template/support_ops_env/scripts/run_rule_baseline.py), so you can produce reproducible scores without any external API.
+
+In this workspace, use:
+
+```bash
+python scripts/run_rule_baseline.py
+```
+
+This writes `rule_baseline_results.json` with per-task transcripts and the average score.
+
+The current deterministic baseline score from this workspace is:
+
+- `easy_account_takeover`: `1.0`
+- `medium_payout_hold`: `1.0`
+- `hard_queue_triage`: `1.0`
+- average: `1.0`
+
+The OpenAI baseline in [run_baseline.py](/home/batman/Downloads/presentation_template/support_ops_env/scripts/run_baseline.py) is still available as an optional comparison path after installing dependencies and setting `OPENAI_API_KEY`.
+
+## Hugging Face Space Deployment
+
+This repository includes:
+
+- `Dockerfile`
+- `app.py`
+- `openenv.yaml`
+
+To deploy as a Docker Space:
+
+1. Create a new Hugging Face Space with SDK set to Docker.
+2. Upload this repository.
+3. Add the `openenv` tag in the Space metadata.
+4. Optionally set `OPENAI_API_KEY` as a Space secret for baseline experiments.
+
+## Project Structure
+
+```text
+support_ops_env/
+├── support_ops_env/
+│   ├── env.py
+│   ├── models.py
+│   ├── reward.py
+│   ├── state.py
+│   ├── data/
+│   ├── graders/
+│   └── tasks/
+├── scripts/
+├── tests/
+├── app.py
+├── openenv.yaml
+├── Dockerfile
+├── requirements.txt
+└── README.md
+```

__init__.py

@@ -0,0 +1 @@
+"""SupportOpsEnv project root package marker for OpenEnv tooling."""

app.py

@@ -0,0 +1,71 @@
+from __future__ import annotations
+
+import json
+import os
+
+import gradio as gr
+
+from support_ops_env.env import SupportOpsEnv
+from support_ops_env.models import Action
+from support_ops_env.tasks import list_task_ids
+
+
+ENV = SupportOpsEnv()
+
+
+def reset_env(task_id: str) -> str:
+    observation = ENV.reset(task_id=task_id)
+    return json.dumps(observation.model_dump(), indent=2)
+
+
+def step_env(task_id: str, action_type: str, target: str, value: str) -> tuple[str, str]:
+    if ENV.state().task_id != task_id or ENV.state().step_count == 0 and not ENV.state().done:
+        ENV.reset(task_id=task_id)
+    action = Action(action_type=action_type, target=target or "T1", value=value or None)
+    observation, reward, done, info = ENV.step(action)
+    payload = {
+        "reward": reward.model_dump(),
+        "done": done,
+        "info": info,
+    }
+    return json.dumps(observation.model_dump(), indent=2), json.dumps(payload, indent=2)
+
+
+with gr.Blocks(title="SupportOpsEnv") as demo:
+    gr.Markdown("# SupportOpsEnv")
+    gr.Markdown("Multi-step support triage benchmark with deterministic graders.")
+
+    task_id = gr.Dropdown(choices=list_task_ids(), value=list_task_ids()[0], label="Task")
+    action_type = gr.Dropdown(
+        choices=[
+            "inspect_ticket",
+            "request_context",
+            "set_priority",
+            "set_route",
+            "set_resolution",
+            "escalate",
+            "rank_queue",
+            "finalize",
+        ],
+        value="inspect_ticket",
+        label="Action Type",
+    )
+    target = gr.Textbox(value="T1", label="Target Ticket")
+    value = gr.Textbox(label="Value")
+    observation_output = gr.Code(label="Observation", language="json")
+    result_output = gr.Code(label="Step Result", language="json")
+
+    reset_button = gr.Button("Reset")
+    step_button = gr.Button("Step")
+
+    reset_button.click(reset_env, inputs=[task_id], outputs=[observation_output])
+    step_button.click(
+        step_env,
+        inputs=[task_id, action_type, target, value],
+        outputs=[observation_output, result_output],
+    )
+
+
+if __name__ == "__main__":
+    port = int(os.getenv("PORT", os.getenv("GRADIO_SERVER_PORT", "7860")))
+    demo.launch(server_name="0.0.0.0", server_port=port)

client.py

@@ -0,0 +1,31 @@
+"""Root-level client wrapper for OpenEnv packaging."""
+
+from typing import Dict
+
+from openenv.core import EnvClient
+from openenv.core.client_types import StepResult
+from openenv.core.env_server.types import State
+
+from models import Action, Observation
+
+
+class SupportOpsEnvClient(EnvClient[Action, Observation, State]):
+    def _step_payload(self, action: Action) -> Dict:
+        return action.model_dump()
+
+    def _parse_result(self, payload: Dict) -> StepResult[Observation]:
+        observation = Observation.model_validate(payload.get("observation", {}))
+        return StepResult(
+            observation=observation,
+            reward=payload.get("reward"),
+            done=payload.get("done", False),
+        )
+
+    def _parse_state(self, payload: Dict) -> State:
+        return State(
+            episode_id=payload.get("episode_id"),
+            step_count=payload.get("step_count", 0),
+        )
+
+
+__all__ = ["SupportOpsEnvClient"]

inference.py

@@ -0,0 +1,152 @@
+import json
+import os
+import textwrap
+from typing import List, Optional
+
+from openai import OpenAI
+
+from support_ops_env.env import SupportOpsEnv
+from support_ops_env.models import Action, Observation
+from support_ops_env.tasks import list_task_ids
+
+
+LOCAL_IMAGE_NAME = os.getenv("LOCAL_IMAGE_NAME")
+API_KEY = os.getenv("HF_TOKEN") or os.getenv("OPENAI_API_KEY") or os.getenv("API_KEY")
+API_BASE_URL = os.getenv("API_BASE_URL", "https://router.huggingface.co/v1")
+MODEL_NAME = os.getenv("MODEL_NAME", "Qwen/Qwen2.5-72B-Instruct")
+TASK_NAME = os.getenv("SUPPORT_OPS_TASK", "easy_account_takeover")
+BENCHMARK = os.getenv("SUPPORT_OPS_BENCHMARK", "support_ops_env")
+MAX_STEPS = int(os.getenv("MAX_STEPS", "16"))
+TEMPERATURE = float(os.getenv("TEMPERATURE", "0.1"))
+MAX_TOKENS = int(os.getenv("MAX_TOKENS", "220"))
+SUCCESS_SCORE_THRESHOLD = float(os.getenv("SUCCESS_SCORE_THRESHOLD", "0.8"))
+
+
+SYSTEM_PROMPT = textwrap.dedent(
+    """
+    You are operating a customer support triage environment.
+    Return exactly one JSON object with keys: action_type, target, value.
+    Allowed action_type values:
+    - inspect_ticket
+    - request_context
+    - set_priority
+    - set_route
+    - set_resolution
+    - escalate
+    - rank_queue
+    - finalize
+    Choose only valid ticket ids from the observation.
+    Use concise string values.
+    Finalize only after enough evidence is gathered.
+    """
+).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"{reward:.2f}" for reward in rewards)
+    print(
+        f"[END] success={str(success).lower()} steps={steps} score={score:.3f} rewards={rewards_str}",
+        flush=True,
+    )
+
+
+def build_user_prompt(observation: Observation, step: int, rewards: List[float]) -> str:
+    reward_history = ",".join(f"{reward:.2f}" for reward in rewards[-5:]) if rewards else "none"
+    return textwrap.dedent(
+        f"""
+        Step: {step}
+        Task: {observation.task_id}
+        Difficulty: {observation.difficulty}
+        Reward history: {reward_history}
+        Observation JSON:
+        {json.dumps(observation.model_dump(), indent=2, sort_keys=True)}
+        Return one JSON action.
+        """
+    ).strip()
+
+
+def get_model_action(client: OpenAI, observation: Observation, step: int, rewards: List[float]) -> tuple[Action, Optional[str]]:
+    user_prompt = build_user_prompt(observation, step, rewards)
+    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,
+        )
+        content = (completion.choices[0].message.content or "").strip()
+        payload = json.loads(content)
+        action = Action.model_validate(payload)
+        return action, None
+    except Exception as exc:
+        fallback = Action(action_type="finalize")
+        return fallback, str(exc).replace("\n", " ")
+
+
+def ensure_known_task(task_name: str) -> str:
+    if task_name in list_task_ids():
+        return task_name
+    return list_task_ids()[0]
+
+
+def main() -> None:
+    task_name = ensure_known_task(TASK_NAME)
+    client = OpenAI(base_url=API_BASE_URL, api_key=API_KEY)
+    env = SupportOpsEnv(task_id=task_name)
+
+    rewards: List[float] = []
+    steps_taken = 0
+    score = 0.0
+    success = False
+
+    log_start(task=task_name, env=BENCHMARK, model=MODEL_NAME)
+
+    try:
+        observation = env.reset(task_id=task_name)
+
+        for step in range(1, MAX_STEPS + 1):
+            action, action_error = get_model_action(client, observation, step, rewards)
+            action_str = json.dumps(action.model_dump(), separators=(",", ":"))
+
+            observation, reward, done, info = env.step(action)
+            reward_value = reward.value
+            rewards.append(reward_value)
+            steps_taken = step
+
+            log_step(
+                step=step,
+                action=action_str,
+                reward=reward_value,
+                done=done,
+                error=action_error,
+            )
+
+            score = float(info.get("task_score", 0.0))
+            if done:
+                break
+
+        score = min(max(score, 0.0), 1.0)
+        success = score >= SUCCESS_SCORE_THRESHOLD
+    finally:
+        log_end(success=success, steps=steps_taken, score=score, rewards=rewards)
+
+
+if __name__ == "__main__":
+    main()

models.py

@@ -0,0 +1,27 @@
+"""Root-level model exports for OpenEnv packaging."""
+
+from support_ops_env.models import (
+    Action,
+    BaselineResult,
+    Observation,
+    RewardModel,
+    StateModel,
+    StepInfo,
+    TaskGrade,
+    TaskSpec,
+    TicketObservation,
+    TicketSpec,
+)
+
+__all__ = [
+    "Action",
+    "BaselineResult",
+    "Observation",
+    "RewardModel",
+    "StateModel",
+    "StepInfo",
+    "TaskGrade",
+    "TaskSpec",
+    "TicketObservation",
+    "TicketSpec",
+]

openenv.yaml

@@ -0,0 +1,22 @@
+name: support-ops-env
+description: Multi-step customer support triage and escalation benchmark for OpenEnv-style agents.
+version: 0.1.0
+tags:
+  - openenv
+  - customer-support
+  - triage
+  - evaluation
+entrypoint: support_ops_env.env:SupportOpsEnv
+observation_model: support_ops_env.models:Observation
+action_model: support_ops_env.models:Action
+reward_model: support_ops_env.models:RewardModel
+tasks:
+  - id: easy_account_takeover
+    difficulty: easy
+  - id: medium_payout_hold
+    difficulty: medium
+  - id: hard_queue_triage
+    difficulty: hard
+hf_space:
+  sdk: docker
+  suggested_app_file: app.py

pyproject.toml

@@ -0,0 +1,25 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "support-ops-env"
+version = "0.1.0"
+description = "Multi-step customer support triage and escalation benchmark for OpenEnv-style evaluation."
+readme = "README.md"
+requires-python = ">=3.11"
+dependencies = [
+  "openenv-core[core]>=0.2.2",
+  "pydantic>=2.7,<3",
+  "openai>=1.30.0",
+  "gradio>=4.44.0",
+]
+
+[project.scripts]
+server = "server.app:main"
+
+[tool.setuptools]
+include-package-data = true
+
+[tool.setuptools.packages.find]
+include = ["support_ops_env*"]

requirements.txt

@@ -0,0 +1,3 @@
+pydantic>=2.7,<3
+openai>=1.30.0
+gradio>=4.44.0

rule_baseline_results.json

@@ -0,0 +1,524 @@
+{
+  "baseline": "rule_based",
+  "average_score": 1.0,
+  "results": [
+    {
+      "task_id": "easy_account_takeover",
+      "difficulty": "easy",
+      "score": 1.0,
+      "steps": 7,
+      "transcript": [
+        {
+          "action": {
+            "action_type": "request_context",
+            "target": "T1",
+            "value": "account_security"
+          },
+          "reward": {
+            "value": 0.11,
+            "components": {
+              "step_penalty": -0.01,
+              "required_context_found": 0.12
+            },
+            "rationale": "Processed request_context."
+          },
+          "task_score": 0.1,
+          "done": false
+        },
+        {
+          "action": {
+            "action_type": "request_context",
+            "target": "T1",
+            "value": "billing_activity"
+          },
+          "reward": {
+            "value": 0.11,
+            "components": {
+              "step_penalty": -0.01,
+              "required_context_found": 0.12
+            },
+            "rationale": "Processed request_context."
+          },
+          "task_score": 0.2,
+          "done": false
+        },
+        {
+          "action": {
+            "action_type": "set_priority",
+            "target": "T1",
+            "value": "urgent"
+          },
+          "reward": {
+            "value": 0.07,
+            "components": {
+              "step_penalty": -0.01,
+              "priority_match": 0.08
+            },
+            "rationale": "Processed set_priority."
+          },
+          "task_score": 0.4,
+          "done": false
+        },
+        {
+          "action": {
+            "action_type": "set_route",
+            "target": "T1",
+            "value": "account_security"
+          },
+          "reward": {
+            "value": 0.09,
+            "components": {
+              "step_penalty": -0.01,
+              "route_match": 0.1
+            },
+            "rationale": "Processed set_route."
+          },
+          "task_score": 0.65,
+          "done": false
+        },
+        {
+          "action": {
+            "action_type": "set_resolution",
+            "target": "T1",
+            "value": "temporary_lock_and_manual_recovery"
+          },
+          "reward": {
+            "value": 0.11,
+            "components": {
+              "step_penalty": -0.01,
+              "resolution_match": 0.12
+            },
+            "rationale": "Processed set_resolution."
+          },
+          "task_score": 0.85,
+          "done": false
+        },
+        {
+          "action": {
+            "action_type": "escalate",
+            "target": "T1",
+            "value": "security_specialist"
+          },
+          "reward": {
+            "value": 0.09,
+            "components": {
+              "step_penalty": -0.01,
+              "correct_escalation": 0.1
+            },
+            "rationale": "Processed escalate."
+          },
+          "task_score": 1.0,
+          "done": false
+        },
+        {
+          "action": {
+            "action_type": "finalize",
+            "target": "T1",
+            "value": null
+          },
+          "reward": {
+            "value": 0.99,
+            "components": {
+              "step_penalty": -0.01,
+              "terminal_grade": 1.0
+            },
+            "rationale": "Final task grade applied."
+          },
+          "task_score": 1.0,
+          "done": true
+        }
+      ]
+    },
+    {
+      "task_id": "medium_payout_hold",
+      "difficulty": "medium",
+      "score": 1.0,
+      "steps": 6,
+      "transcript": [
+        {
+          "action": {
+            "action_type": "request_context",
+            "target": "T1",
+            "value": "tax_status"
+          },
+          "reward": {
+            "value": 0.11,
+            "components": {
+              "step_penalty": -0.01,
+              "required_context_found": 0.12
+            },
+            "rationale": "Processed request_context."
+          },
+          "task_score": 0.225,
+          "done": false
+        },
+        {
+          "action": {
+            "action_type": "request_context",
+            "target": "T1",
+            "value": "payout_hold"
+          },
+          "reward": {
+            "value": 0.11,
+            "components": {
+              "step_penalty": -0.01,
+              "required_context_found": 0.12
+            },
+            "rationale": "Processed request_context."
+          },
+          "task_score": 0.35,
+          "done": false
+        },
+        {
+          "action": {
+            "action_type": "set_priority",
+            "target": "T1",
+            "value": "high"
+          },
+          "reward": {
+            "value": 0.07,
+            "components": {
+              "step_penalty": -0.01,
+              "priority_match": 0.08
+            },
+            "rationale": "Processed set_priority."
+          },
+          "task_score": 0.5,
+          "done": false
+        },
+        {
+          "action": {
+            "action_type": "set_route",
+            "target": "T1",
+            "value": "monetization_compliance"
+          },
+          "reward": {
+            "value": 0.09,
+            "components": {
+              "step_penalty": -0.01,
+              "route_match": 0.1
+            },
+            "rationale": "Processed set_route."
+          },
+          "task_score": 0.75,
+          "done": false
+        },
+        {
+          "action": {
+            "action_type": "set_resolution",
+            "target": "T1",
+            "value": "request_tax_renewal"
+          },
+          "reward": {
+            "value": 0.11,
+            "components": {
+              "step_penalty": -0.01,
+              "resolution_match": 0.12
+            },
+            "rationale": "Processed set_resolution."
+          },
+          "task_score": 1.0,
+          "done": false
+        },
+        {
+          "action": {
+            "action_type": "finalize",
+            "target": "T1",
+            "value": null
+          },
+          "reward": {
+            "value": 0.99,
+            "components": {
+              "step_penalty": -0.01,
+              "terminal_grade": 1.0
+            },
+            "rationale": "Final task grade applied."
+          },
+          "task_score": 1.0,
+          "done": true
+        }
+      ]
+    },
+    {
+      "task_id": "hard_queue_triage",
+      "difficulty": "hard",
+      "score": 1.0,
+      "steps": 16,
+      "transcript": [
+        {
+          "action": {
+            "action_type": "rank_queue",
+            "target": "T1",
+            "value": "T2,T3,T1"
+          },
+          "reward": {
+            "value": 0.11,
+            "components": {
+              "step_penalty": -0.01,
+              "queue_progress": 0.12
+            },
+            "rationale": "Processed rank_queue."
+          },
+          "task_score": 0.2167,
+          "done": false
+        },
+        {
+          "action": {
+            "action_type": "request_context",
+            "target": "T1",
+            "value": "payment_status"
+          },
+          "reward": {
+            "value": 0.11,
+            "components": {
+              "step_penalty": -0.01,
+              "required_context_found": 0.12
+            },
+            "rationale": "Processed request_context."
+          },
+          "task_score": 0.25,
+          "done": false
+        },
+        {
+          "action": {
+            "action_type": "request_context",
+            "target": "T2",
+            "value": "account_security"
+          },
+          "reward": {
+            "value": 0.11,
+            "components": {
+              "step_penalty": -0.01,
+              "required_context_found": 0.12
+            },
+            "rationale": "Processed request_context."
+          },
+          "task_score": 0.2667,
+          "done": false
+        },
+        {
+          "action": {
+            "action_type": "request_context",
+            "target": "T2",
+            "value": "billing_activity"
+          },
+          "reward": {
+            "value": 0.11,
+            "components": {
+              "step_penalty": -0.01,
+              "required_context_found": 0.12
+            },
+            "rationale": "Processed request_context."
+          },
+          "task_score": 0.2834,
+          "done": false
+        },
+        {
+          "action": {
+            "action_type": "request_context",
+            "target": "T3",
+            "value": "appeal_state"
+          },
+          "reward": {
+            "value": 0.11,
+            "components": {
+              "step_penalty": -0.01,
+              "required_context_found": 0.12
+            },
+            "rationale": "Processed request_context."
+          },
+          "task_score": 0.3,
+          "done": false
+        },
+        {
+          "action": {
+            "action_type": "request_context",
+            "target": "T3",
+            "value": "campaign_deadline"
+          },
+          "reward": {
+            "value": 0.11,
+            "components": {
+              "step_penalty": -0.01,
+              "required_context_found": 0.12
+            },
+            "rationale": "Processed request_context."
+          },
+          "task_score": 0.3167,
+          "done": false
+        },
+        {
+          "action": {
+            "action_type": "set_priority",
+            "target": "T1",
+            "value": "normal"
+          },
+          "reward": {
+            "value": 0.07,
+            "components": {
+              "step_penalty": -0.01,
+              "priority_match": 0.08
+            },
+            "rationale": "Processed set_priority."
+          },
+          "task_score": 0.3834,
+          "done": false
+        },
+        {
+          "action": {
+            "action_type": "set_priority",
+            "target": "T2",
+            "value": "urgent"
+          },
+          "reward": {
+            "value": 0.07,
+            "components": {
+              "step_penalty": -0.01,
+              "priority_match": 0.08
+            },
+            "rationale": "Processed set_priority."
+          },
+          "task_score": 0.45,
+          "done": false
+        },
+        {
+          "action": {
+            "action_type": "set_priority",
+            "target": "T3",
+            "value": "high"
+          },
+          "reward": {
+            "value": 0.07,
+            "components": {
+              "step_penalty": -0.01,
+              "priority_match": 0.08
+            },
+            "rationale": "Processed set_priority."
+          },
+          "task_score": 0.5167,
+          "done": false
+        },
+        {
+          "action": {
+            "action_type": "set_route",
+            "target": "T1",
+            "value": "billing_refunds"
+          },
+          "reward": {
+            "value": 0.09,
+            "components": {
+              "step_penalty": -0.01,
+              "route_match": 0.1
+            },
+            "rationale": "Processed set_route."
+          },
+          "task_score": 0.6,
+          "done": false
+        },
+        {
+          "action": {
+            "action_type": "set_route",
+            "target": "T2",
+            "value": "account_security"
+          },
+          "reward": {
+            "value": 0.09,
+            "components": {
+              "step_penalty": -0.01,
+              "route_match": 0.1
+            },
+            "rationale": "Processed set_route."
+          },
+          "task_score": 0.6834,
+          "done": false
+        },
+        {
+          "action": {
+            "action_type": "set_route",
+            "target": "T3",
+            "value": "policy_appeals"
+          },
+          "reward": {
+            "value": 0.09,
+            "components": {
+              "step_penalty": -0.01,
+              "route_match": 0.1
+            },
+            "rationale": "Processed set_route."
+          },
+          "task_score": 0.7667,
+          "done": false
+        },
+        {
+          "action": {
+            "action_type": "set_resolution",
+            "target": "T1",
+            "value": "approve_refund"
+          },
+          "reward": {
+            "value": 0.11,
+            "components": {
+              "step_penalty": -0.01,
+              "resolution_match": 0.12
+            },
+            "rationale": "Processed set_resolution."
+          },
+          "task_score": 0.8334,
+          "done": false
+        },
+        {
+          "action": {
+            "action_type": "set_resolution",
+            "target": "T2",
+            "value": "temporary_lock_and_manual_recovery"
+          },
+          "reward": {
+            "value": 0.11,
+            "components": {
+              "step_penalty": -0.01,
+              "resolution_match": 0.12
+            },
+            "rationale": "Processed set_resolution."
+          },
+          "task_score": 0.9,
+          "done": false
+        },
+        {
+          "action": {
+            "action_type": "set_resolution",
+            "target": "T3",
+            "value": "expedited_human_review"
+          },
+          "reward": {
+            "value": 0.11,
+            "components": {
+              "step_penalty": -0.01,
+              "resolution_match": 0.12
+            },
+            "rationale": "Processed set_resolution."
+          },
+          "task_score": 0.9667,
+          "done": false
+        },
+        {
+          "action": {
+            "action_type": "escalate",
+            "target": "T2",
+            "value": "security_specialist"
+          },
+          "reward": {
+            "value": 1.09,
+            "components": {
+              "step_penalty": -0.01,
+              "correct_escalation": 0.1,
+              "timeout_grade": 1.0
+            },
+            "rationale": "Processed escalate."
+          },
+          "task_score": 1.0,
+          "done": true
+        }
+      ]
+    }
+  ]
+}

scripts/run_baseline.py

@@ -0,0 +1,103 @@
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import sys
+from pathlib import Path
+from typing import Dict, List
+
+ROOT = Path(__file__).resolve().parent.parent
+if str(ROOT) not in sys.path:
+    sys.path.insert(0, str(ROOT))
+
+from openai import OpenAI
+
+from support_ops_env.env import SupportOpsEnv
+from support_ops_env.models import Action, BaselineResult
+from support_ops_env.tasks import list_task_ids
+
+
+SYSTEM_PROMPT = """You are evaluating a support operations environment.
+Return exactly one JSON object with keys: action_type, target, value.
+Choose from action_type:
+- inspect_ticket
+- request_context
+- set_priority
+- set_route
+- set_resolution
+- escalate
+- rank_queue
+- finalize
+Be concise and deterministic. Only use ticket ids that appear in the observation.
+When enough evidence is gathered, finalize."""
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Run a reproducible baseline over all SupportOpsEnv tasks.")
+    parser.add_argument("--model", default="gpt-4.1-mini", help="OpenAI model name")
+    parser.add_argument("--output", default="baseline_results.json", help="Path to write JSON results")
+    args = parser.parse_args()
+
+    api_key = os.getenv("OPENAI_API_KEY")
+    if not api_key:
+        raise SystemExit("OPENAI_API_KEY is required.")
+
+    client = OpenAI(api_key=api_key)
+    results: List[BaselineResult] = []
+
+    for task_id in list_task_ids():
+        env = SupportOpsEnv(task_id=task_id)
+        observation = env.reset()
+        done = False
+        transcript: List[Dict[str, object]] = []
+        last_info: Dict[str, object] = {}
+
+        while not done:
+            response = client.responses.create(
+                model=args.model,
+                temperature=0,
+                input=[
+                    {"role": "system", "content": SYSTEM_PROMPT},
+                    {
+                        "role": "user",
+                        "content": json.dumps(observation.model_dump(), indent=2, sort_keys=True),
+                    },
+                ],
+            )
+            raw = response.output_text.strip()
+            payload = json.loads(raw)
+            action = Action.model_validate(payload)
+            observation, reward, done, info = env.step(action)
+            transcript.append(
+                {
+                    "action": action.model_dump(),
+                    "reward": reward.model_dump(),
+                    "task_score": info["task_score"],
+                    "done": done,
+                }
+            )
+            last_info = info
+
+        results.append(
+            BaselineResult(
+                task_id=task_id,
+                difficulty=observation.difficulty,
+                score=float(last_info.get("task_score", 0.0)),
+                steps=int(last_info.get("step_count", 0)),
+                transcript=transcript,
+            )
+        )
+
+    output_path = Path(args.output)
+    payload = {
+        "model": args.model,
+        "average_score": round(sum(item.score for item in results) / len(results), 4),
+        "results": [item.model_dump() for item in results],
+    }
+    output_path.write_text(json.dumps(payload, indent=2), encoding="utf-8")
+    print(json.dumps(payload, indent=2))
+
+
+if __name__ == "__main__":
+    main()

scripts/run_rule_baseline.py

@@ -0,0 +1,238 @@
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+from typing import Dict, List
+
+ROOT = Path(__file__).resolve().parent.parent
+if str(ROOT) not in sys.path:
+    sys.path.insert(0, str(ROOT))
+
+from support_ops_env.env import SupportOpsEnv
+from support_ops_env.models import Action, BaselineResult, Observation, TicketObservation
+from support_ops_env.tasks import list_task_ids
+
+
+CONTEXT_PRIORITY = [
+    "account_security",
+    "billing_activity",
+    "tax_status",
+    "payout_hold",
+    "appeal_state",
+    "campaign_deadline",
+    "payment_status",
+]
+
+
+def choose_next_action(observation: Observation) -> Action:
+    if observation.queue_mode and not observation.current_queue_order:
+        ranking = rank_tickets(observation.tickets)
+        return Action(action_type="rank_queue", value=",".join(ranking))
+
+    for ticket in observation.tickets:
+        next_context = missing_high_value_context(ticket)
+        if next_context:
+            return Action(action_type="request_context", target=ticket.ticket_id, value=next_context)
+
+    for ticket in observation.tickets:
+        priority = infer_priority(ticket)
+        if ticket.selected_priority != priority:
+            return Action(action_type="set_priority", target=ticket.ticket_id, value=priority)
+
+    for ticket in observation.tickets:
+        route = infer_route(ticket)
+        if ticket.selected_route != route:
+            return Action(action_type="set_route", target=ticket.ticket_id, value=route)
+
+    for ticket in observation.tickets:
+        resolution = infer_resolution(ticket)
+        if ticket.selected_resolution != resolution:
+            return Action(action_type="set_resolution", target=ticket.ticket_id, value=resolution)
+
+    for ticket in observation.tickets:
+        escalation = infer_escalation(ticket)
+        if ticket.escalation_team != escalation:
+            return Action(action_type="escalate", target=ticket.ticket_id, value=escalation)
+
+    return Action(action_type="finalize")
+
+
+def missing_high_value_context(ticket: TicketObservation) -> str | None:
+    discovered = set(ticket.discovered_context)
+    haystack = flattened_text(ticket)
+
+    candidates: List[str] = infer_required_context(ticket)
+
+    for key in CONTEXT_PRIORITY:
+        if key in candidates and key not in discovered:
+            return key
+    return None
+
+
+def infer_required_context(ticket: TicketObservation) -> List[str]:
+    text = flattened_text(ticket)
+    if "payout" in text or "w-9" in text or "bank details" in text or "funds released" in text:
+        return ["tax_status", "payout_hold"]
+    if "appeal" in text or "auto-removed" in text or "monetization is paused" in text:
+        return ["appeal_state", "campaign_deadline"]
+    if "duplicate charge" in text or "refund" in text:
+        return ["payment_status"]
+    if (
+        "login" in text
+        or "ad spend" in text
+        or "unfamiliar campaigns" in text
+        or "taken over" in text
+        or "recovery email was changed" in text
+    ):
+        return ["account_security", "billing_activity"]
+    return []
+
+
+def infer_priority(ticket: TicketObservation) -> str:
+    text = flattened_text(ticket)
+    if (
+        "critical" in text
+        or "$1,900" in text
+        or "unauthorized ad spend" in text
+        or "impossible travel" in text
+        or "recovery email was changed" in text
+    ):
+        return "urgent"
+    if "campaign begins in 18 hours" in text or "monetization is paused" in text:
+        return "high"
+    if "w-9 expired" in text or "monthly payout" in text:
+        return "high"
+    return "normal"
+
+
+def infer_route(ticket: TicketObservation) -> str:
+    text = flattened_text(ticket)
+    if (
+        "account takeover" in text
+        or "new devices" in text
+        or "recovery email was changed" in text
+        or "unfamiliar campaigns" in text
+        or "unauthorized ad spend" in text
+        or "losing access" in text
+    ):
+        return "account_security"
+    if "w-9 expired" in text or "compliance hold" in text:
+        return "monetization_compliance"
+    if "auto-removed" in text or "human yet" in text:
+        return "policy_appeals"
+    if "duplicate charge" in text or "automatically refundable" in text:
+        return "billing_refunds"
+    return "general_support"
+
+
+def infer_resolution(ticket: TicketObservation) -> str:
+    text = flattened_text(ticket)
+    if (
+        "account takeover" in text
+        or "new devices" in text
+        or "impossible travel" in text
+        or "unfamiliar campaigns" in text
+        or "losing access" in text
+    ):
+        return "temporary_lock_and_manual_recovery"
+    if "w-9 expired" in text or "compliance hold" in text:
+        return "request_tax_renewal"
+    if "auto-removed" in text or "sponsored campaign begins" in text:
+        return "expedited_human_review"
+    if "duplicate charge" in text or "automatically refundable" in text:
+        return "approve_refund"
+    return "request_more_info"
+
+
+def infer_escalation(ticket: TicketObservation) -> str | None:
+    text = flattened_text(ticket)
+    if (
+        "account takeover" in text
+        or "critical" in text
+        or "impossible travel" in text
+        or "unfamiliar campaigns" in text
+        or "losing access" in text
+    ):
+        return "security_specialist"
+    return None
+
+
+def rank_tickets(tickets: List[TicketObservation]) -> List[str]:
+    scored = []
+    for ticket in tickets:
+        text = flattened_text(ticket)
+        score = 0
+        if "critical" in text or "account takeover" in text or "$1,900" in text or "unfamiliar campaigns" in text:
+            score += 100
+        if "campaign begins in 18 hours" in text or "sponsored campaign" in text:
+            score += 60
+        if "duplicate charge" in text:
+            score += 20
+        if ticket.visible_context.get("sla_hours_remaining") == "1":
+            score += 30
+        if ticket.visible_context.get("sla_hours_remaining") == "4":
+            score += 10
+        scored.append((score, ticket.ticket_id))
+    scored.sort(key=lambda item: (-item[0], item[1]))
+    return [ticket_id for _, ticket_id in scored]
+
+
+def flattened_text(ticket: TicketObservation) -> str:
+    parts = [
+        ticket.summary,
+        json.dumps(ticket.visible_context, sort_keys=True),
+        json.dumps(ticket.discovered_context, sort_keys=True),
+    ]
+    return " ".join(parts).lower()
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Run a deterministic rule-based baseline over all tasks.")
+    parser.add_argument("--output", default="rule_baseline_results.json", help="Path to write JSON results")
+    args = parser.parse_args()
+
+    results: List[BaselineResult] = []
+    for task_id in list_task_ids():
+        env = SupportOpsEnv(task_id=task_id)
+        observation = env.reset()
+        done = False
+        transcript: List[Dict[str, object]] = []
+        last_info: Dict[str, object] = {}
+
+        while not done:
+            action = choose_next_action(observation)
+            observation, reward, done, info = env.step(action)
+            transcript.append(
+                {
+                    "action": action.model_dump(),
+                    "reward": reward.model_dump(),
+                    "task_score": info["task_score"],
+                    "done": done,
+                }
+            )
+            last_info = info
+
+        results.append(
+            BaselineResult(
+                task_id=task_id,
+                difficulty=observation.difficulty,
+                score=float(last_info.get("task_score", 0.0)),
+                steps=int(last_info.get("step_count", 0)),
+                transcript=transcript,
+            )
+        )
+
+    payload = {
+        "baseline": "rule_based",
+        "average_score": round(sum(item.score for item in results) / len(results), 4),
+        "results": [item.model_dump() for item in results],
+    }
+    output_path = Path(args.output)
+    output_path.write_text(json.dumps(payload, indent=2), encoding="utf-8")
+    print(json.dumps(payload, indent=2))
+
+
+if __name__ == "__main__":
+    main()

scripts/validate_env.sh

@@ -0,0 +1,10 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+python -m unittest discover -s tests -p 'test_*.py'
+
+if command -v openenv >/dev/null 2>&1; then
+  openenv validate openenv.yaml
+else
+  echo "openenv CLI not installed; skipped 'openenv validate openenv.yaml'."
+fi

server/__init__.py

@@ -0,0 +1 @@
+"""OpenEnv server package."""

server/app.py

@@ -0,0 +1,36 @@
+from __future__ import annotations
+
+from fastapi import FastAPI
+
+
+app = FastAPI(
+    title="SupportOpsEnv Server",
+    description="Minimal server entry point for OpenEnv validation and deployment hooks.",
+    version="0.1.0",
+)
+
+
+@app.get("/")
+def root() -> dict[str, str]:
+    return {
+        "name": "support-ops-env",
+        "status": "ok",
+        "message": "SupportOpsEnv server entry point is available.",
+    }
+
+
+@app.get("/health")
+def health() -> dict[str, str]:
+    return {"status": "healthy"}
+
+
+def main(host: str = "0.0.0.0", port: int = 8000) -> None:
+    import uvicorn
+
+    uvicorn.run(app, host=host, port=port)
+
+def uv_main():
+	return app
+
+if __name__ == "__main__":
+    main()

support_ops_env/__init__.py

@@ -0,0 +1,13 @@
+"""SupportOpsEnv package."""
+
+from .env import SupportOpsEnv
+from .models import Action, Observation, RewardModel, StateModel, TaskGrade
+
+__all__ = [
+    "Action",
+    "Observation",
+    "RewardModel",
+    "StateModel",
+    "SupportOpsEnv",
+    "TaskGrade",
+]

support_ops_env/data/easy_cases.json

@@ -0,0 +1,37 @@
+[
+  {
+    "task_id": "easy_account_takeover",
+    "difficulty": "easy",
+    "title": "Account Takeover Triage",
+    "description": "Route an urgent support ticket involving suspected account takeover and unauthorized ad spend.",
+    "instruction": "Review the ticket, request any missing high-value context, set priority, choose the correct route, select a resolution, and escalate only if warranted.",
+    "max_steps": 8,
+    "queue_mode": false,
+    "grader_name": "easy_support_routing",
+    "tickets": [
+      {
+        "ticket_id": "T1",
+        "summary": "Creator reports losing access to their account after repeated login attempts. They also noticed unfamiliar ad spend starting this morning.",
+        "visible_context": {
+          "customer_tier": "managed_creator",
+          "surface": "ads_manager",
+          "sla_hours_remaining": "2"
+        },
+        "hidden_context": {
+          "account_security": "Impossible travel and two failed password-reset attempts were flagged overnight.",
+          "billing_activity": "A new ad campaign spent $420 in the last 2 hours from a new IP block.",
+          "recovery_channel": "A verified backup email is on file and can receive a recovery code.",
+          "prior_cases": "No previous enforcement or abuse flags are on record."
+        },
+        "required_context": [
+          "account_security",
+          "billing_activity"
+        ],
+        "gold_priority": "urgent",
+        "gold_route": "account_security",
+        "gold_resolution": "temporary_lock_and_manual_recovery",
+        "gold_escalation_team": "security_specialist"
+      }
+    ]
+  }
+]

support_ops_env/data/hard_cases.json

@@ -0,0 +1,84 @@
+[
+  {
+    "task_id": "hard_queue_triage",
+    "difficulty": "hard",
+    "title": "Mixed Support Queue Triage",
+    "description": "Prioritize a small queue of heterogeneous support tickets under SLA pressure and route each one correctly.",
+    "instruction": "Inspect the queue, gather missing context where useful, assign the right priority and route for each ticket, set a valid resolution, rank the queue from most urgent to least urgent, and finalize.",
+    "max_steps": 16,
+    "queue_mode": true,
+    "gold_queue_order": [
+      "T2",
+      "T3",
+      "T1"
+    ],
+    "grader_name": "hard_support_queue",
+    "tickets": [
+      {
+        "ticket_id": "T1",
+        "summary": "Customer reports a duplicate charge on a subscription renewal and asks when the refund will land.",
+        "visible_context": {
+          "customer_tier": "consumer",
+          "surface": "subscriptions",
+          "sla_hours_remaining": "24"
+        },
+        "hidden_context": {
+          "payment_status": "The duplicate charge was confirmed and is automatically refundable.",
+          "refund_status": "No refund has been issued yet.",
+          "risk_flags": "No fraud indicators or account compromise signals are present."
+        },
+        "required_context": [
+          "payment_status"
+        ],
+        "gold_priority": "normal",
+        "gold_route": "billing_refunds",
+        "gold_resolution": "approve_refund",
+        "gold_escalation_team": null
+      },
+      {
+        "ticket_id": "T2",
+        "summary": "Advertiser cannot log in, says unfamiliar campaigns are spending rapidly, and fears the account was taken over.",
+        "visible_context": {
+          "customer_tier": "managed_advertiser",
+          "surface": "ads_manager",
+          "sla_hours_remaining": "1"
+        },
+        "hidden_context": {
+          "account_security": "Two new devices were added and recovery email was changed 30 minutes ago.",
+          "billing_activity": "Spending accelerated to $1,900 in the last hour.",
+          "risk_flags": "Account takeover risk score is critical."
+        },
+        "required_context": [
+          "account_security",
+          "billing_activity"
+        ],
+        "gold_priority": "urgent",
+        "gold_route": "account_security",
+        "gold_resolution": "temporary_lock_and_manual_recovery",
+        "gold_escalation_team": "security_specialist"
+      },
+      {
+        "ticket_id": "T3",
+        "summary": "Verified creator appeals a content moderation decision because a sponsored campaign launches tomorrow and monetization is paused.",
+        "visible_context": {
+          "customer_tier": "verified_creator",
+          "surface": "content_appeals",
+          "sla_hours_remaining": "4"
+        },
+        "hidden_context": {
+          "appeal_state": "The content was auto-removed for policy ambiguity and has not been reviewed by a human yet.",
+          "campaign_deadline": "The sponsored campaign begins in 18 hours.",
+          "account_history": "No previous policy strikes or abuse reports."
+        },
+        "required_context": [
+          "appeal_state",
+          "campaign_deadline"
+        ],
+        "gold_priority": "high",
+        "gold_route": "policy_appeals",
+        "gold_resolution": "expedited_human_review",
+        "gold_escalation_team": null
+      }
+    ]
+  }
+]

support_ops_env/data/medium_cases.json

@@ -0,0 +1,37 @@
+[
+  {
+    "task_id": "medium_payout_hold",
+    "difficulty": "medium",
+    "title": "Monetization Payout Hold",
+    "description": "Handle a creator support issue where a monthly payout is missing and policy-compliance context is incomplete.",
+    "instruction": "Investigate the payout problem, request the most relevant missing context, decide the correct route, and choose a safe resolution without unnecessary escalation.",
+    "max_steps": 9,
+    "queue_mode": false,
+    "grader_name": "medium_support_resolution",
+    "tickets": [
+      {
+        "ticket_id": "T1",
+        "summary": "A small business creator says their monthly payout did not arrive. They mention changing bank details recently and want the funds released immediately.",
+        "visible_context": {
+          "customer_tier": "business_creator",
+          "surface": "creator_monetization",
+          "sla_hours_remaining": "12"
+        },
+        "hidden_context": {
+          "tax_status": "The W-9 expired last month and must be renewed before payout release.",
+          "payout_hold": "An automated compliance hold is active until tax renewal is confirmed.",
+          "bank_change": "The new bank account passed verification 3 days ago.",
+          "contract_status": "The creator remains in good standing with no strikes."
+        },
+        "required_context": [
+          "tax_status",
+          "payout_hold"
+        ],
+        "gold_priority": "high",
+        "gold_route": "monetization_compliance",
+        "gold_resolution": "request_tax_renewal",
+        "gold_escalation_team": null
+      }
+    ]
+  }
+]

support_ops_env/env.py

@@ -0,0 +1,237 @@
+from __future__ import annotations
+
+from typing import Dict, List, Optional, Tuple
+
+from .graders import grade_task
+from .models import Action, Observation, RewardModel, StateModel, StepInfo, TaskSpec, TicketObservation
+from .reward import STEP_PENALTY, build_reward
+from .state import discovered_for_ticket, initial_tracking, update_mapping
+from .tasks import get_all_tasks, get_task
+
+
+class SupportOpsEnv:
+    """OpenEnv-shaped benchmark for support operations workflows."""
+
+    def __init__(self, task_id: Optional[str] = None):
+        self._tasks = {task.task_id: task for task in get_all_tasks()}
+        self._task_order = sorted(self._tasks)
+        self._task_id = task_id or self._task_order[0]
+        self._task: TaskSpec = self._tasks[self._task_id]
+        self._state: StateModel = initial_tracking(self._task)
+
+    def reset(self, task_id: Optional[str] = None) -> Observation:
+        if task_id is not None:
+            self._task = get_task(task_id)
+            self._task_id = task_id
+        self._state = initial_tracking(self._task)
+        return self._build_observation()
+
+    def state(self) -> StateModel:
+        return self._state.model_copy(deep=True)
+
+    def step(self, action: Action) -> Tuple[Observation, RewardModel, bool, Dict[str, object]]:
+        if self._state.done:
+            reward = build_reward({"invalid_after_done": -0.1}, "Episode already finished.")
+            info = StepInfo(
+                task_id=self._task.task_id,
+                step_count=self._state.step_count,
+                task_score=self._state.latest_score.get("task_score", 0.0),
+                done_reason="already_done",
+                event="invalid_after_done",
+                event_score=reward.components,
+            )
+            return self._build_observation(), reward, True, info.model_dump()
+
+        self._state.step_count += 1
+        event_scores: Dict[str, float] = {"step_penalty": STEP_PENALTY}
+        event_name = action.action_type
+        done_reason = None
+
+        if action.action_type == "inspect_ticket":
+            event_scores.update(self._handle_inspect(action))
+        elif action.action_type == "request_context":
+            event_scores.update(self._handle_request_context(action))
+        elif action.action_type == "set_priority":
+            event_scores.update(self._handle_priority(action))
+        elif action.action_type == "set_route":
+            event_scores.update(self._handle_route(action))
+        elif action.action_type == "set_resolution":
+            event_scores.update(self._handle_resolution(action))
+        elif action.action_type == "escalate":
+            event_scores.update(self._handle_escalation(action))
+        elif action.action_type == "rank_queue":
+            event_scores.update(self._handle_rank_queue(action))
+        elif action.action_type == "finalize":
+            self._state.done = True
+            done_reason = "agent_finalized"
+            grade = grade_task(self._task, self._state)
+            self._state.latest_score = {"task_score": grade.score, **grade.component_scores}
+            event_scores["terminal_grade"] = grade.score
+            reward = build_reward(event_scores, "Final task grade applied.")
+            self._state.cumulative_reward = round(self._state.cumulative_reward + reward.value, 4)
+            info = StepInfo(
+                task_id=self._task.task_id,
+                step_count=self._state.step_count,
+                task_score=grade.score,
+                done_reason=done_reason,
+                grade=grade,
+                event=event_name,
+                event_score=reward.components,
+            )
+            return self._build_observation(), reward, True, info.model_dump()
+        else:
+            event_scores["invalid_action"] = -0.1
+            event_name = "invalid_action"
+
+        grade = grade_task(self._task, self._state)
+        self._state.latest_score = {"task_score": grade.score, **grade.component_scores}
+
+        if self._state.step_count >= self._task.max_steps and not self._state.done:
+            self._state.done = True
+            done_reason = "max_steps"
+            event_scores["timeout_grade"] = grade.score
+
+        reward = build_reward(event_scores, f"Processed {event_name}.")
+        self._state.cumulative_reward = round(self._state.cumulative_reward + reward.value, 4)
+        info = StepInfo(
+            task_id=self._task.task_id,
+            step_count=self._state.step_count,
+            task_score=grade.score,
+            done_reason=done_reason,
+            grade=grade if self._state.done else None,
+            event=event_name,
+            event_score=reward.components,
+        )
+        return self._build_observation(), reward, self._state.done, info.model_dump()
+
+    def _build_observation(self) -> Observation:
+        tickets: List[TicketObservation] = []
+        for ticket in self._task.tickets:
+            keys = self._state.discovered_keys.get(ticket.ticket_id, [])
+            discovered_context = {key: ticket.hidden_context[key] for key in keys}
+            tickets.append(
+                TicketObservation(
+                    ticket_id=ticket.ticket_id,
+                    summary=ticket.summary,
+                    visible_context=ticket.visible_context,
+                    discovered_context=discovered_context,
+                    selected_priority=self._state.priorities.get(ticket.ticket_id),
+                    selected_route=self._state.routes.get(ticket.ticket_id),
+                    selected_resolution=self._state.resolutions.get(ticket.ticket_id),
+                    escalation_team=self._state.escalations.get(ticket.ticket_id),
+                )
+            )
+
+        return Observation(
+            task_id=self._task.task_id,
+            difficulty=self._task.difficulty,
+            title=self._task.title,
+            instruction=self._task.instruction,
+            queue_mode=self._task.queue_mode,
+            tickets=tickets,
+            remaining_steps=max(self._task.max_steps - self._state.step_count, 0),
+            available_actions=[
+                "inspect_ticket",
+                "request_context",
+                "set_priority",
+                "set_route",
+                "set_resolution",
+                "escalate",
+                "rank_queue",
+                "finalize",
+            ],
+            current_queue_order=self._state.queue_order,
+            score_hint=self._state.latest_score,
+        )
+
+    def _find_ticket(self, ticket_id: str):
+        for ticket in self._task.tickets:
+            if ticket.ticket_id == ticket_id:
+                return ticket
+        return None
+
+    def _handle_inspect(self, action: Action) -> Dict[str, float]:
+        ticket = self._find_ticket(action.target)
+        if ticket is None:
+            return {"invalid_ticket": -0.1}
+        key = f"inspected::{ticket.ticket_id}"
+        notes = self._state.latest_score.setdefault("inspections", 0.0)
+        if notes and key in self._state.latest_score:
+            return {"redundant_inspect": -0.03}
+        self._state.latest_score[key] = 1.0
+        return {"inspect": 0.03}
+
+    def _handle_request_context(self, action: Action) -> Dict[str, float]:
+        ticket = self._find_ticket(action.target)
+        if ticket is None or not action.value:
+            return {"invalid_context_request": -0.1}
+        if action.value not in ticket.hidden_context:
+            return {"unknown_context_key": -0.08}
+
+        discovered = discovered_for_ticket(self._state.discovered_keys, ticket.ticket_id)
+        if action.value in discovered:
+            return {"redundant_context_request": -0.05}
+
+        discovered.append(action.value)
+        if action.value in ticket.required_context:
+            return {"required_context_found": 0.12}
+        return {"optional_context_found": 0.04}
+
+    def _handle_priority(self, action: Action) -> Dict[str, float]:
+        ticket = self._find_ticket(action.target)
+        if ticket is None or not action.value:
+            return {"invalid_priority": -0.1}
+        current = self._state.priorities.get(ticket.ticket_id)
+        update_mapping(self._state.priorities, ticket.ticket_id, action.value)
+        if action.value == current:
+            return {"redundant_priority": -0.03}
+        return {"priority_match": 0.08 if action.value == ticket.gold_priority else -0.04}
+
+    def _handle_route(self, action: Action) -> Dict[str, float]:
+        ticket = self._find_ticket(action.target)
+        if ticket is None or not action.value:
+            return {"invalid_route": -0.1}
+        current = self._state.routes.get(ticket.ticket_id)
+        update_mapping(self._state.routes, ticket.ticket_id, action.value)
+        if action.value == current:
+            return {"redundant_route": -0.03}
+        return {"route_match": 0.1 if action.value == ticket.gold_route else -0.06}
+
+    def _handle_resolution(self, action: Action) -> Dict[str, float]:
+        ticket = self._find_ticket(action.target)
+        if ticket is None or not action.value:
+            return {"invalid_resolution": -0.1}
+        current = self._state.resolutions.get(ticket.ticket_id)
+        update_mapping(self._state.resolutions, ticket.ticket_id, action.value)
+        if action.value == current:
+            return {"redundant_resolution": -0.03}
+        return {"resolution_match": 0.12 if action.value == ticket.gold_resolution else -0.08}
+
+    def _handle_escalation(self, action: Action) -> Dict[str, float]:
+        ticket = self._find_ticket(action.target)
+        if ticket is None:
+            return {"invalid_escalation": -0.1}
+        team = action.value
+        current = self._state.escalations.get(ticket.ticket_id)
+        update_mapping(self._state.escalations, ticket.ticket_id, team)
+        if team == current:
+            return {"redundant_escalation": -0.03}
+
+        if team == ticket.gold_escalation_team:
+            return {"correct_escalation": 0.1}
+        if ticket.gold_escalation_team is None and team is None:
+            return {"correct_no_escalation": 0.03}
+        return {"incorrect_escalation": -0.1}
+
+    def _handle_rank_queue(self, action: Action) -> Dict[str, float]:
+        if not self._task.queue_mode or not action.value:
+            return {"invalid_queue_ranking": -0.1}
+        ranked = [item.strip() for item in action.value.split(",") if item.strip()]
+        valid_ticket_ids = {ticket.ticket_id for ticket in self._task.tickets}
+        if set(ranked) != valid_ticket_ids:
+            return {"malformed_queue_ranking": -0.08}
+        self._state.queue_order = ranked
+        correct_positions = sum(
+            1 for observed, expected in zip(ranked, self._task.gold_queue_order) if observed == expected
+        )
+        return {"queue_progress": round((correct_positions / len(ranked)) * 0.12, 4)}

support_ops_env/graders/__init__.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+
+from typing import Callable, Dict
+
+from ..models import StateModel, TaskGrade, TaskSpec
+from .easy import grade as easy_grade
+from .hard import grade as hard_grade
+from .medium import grade as medium_grade
+
+
+GRADERS: Dict[str, Callable[[TaskSpec, StateModel], TaskGrade]] = {
+    "easy_support_routing": easy_grade,
+    "medium_support_resolution": medium_grade,
+    "hard_support_queue": hard_grade,
+}
+
+
+def grade_task(task: TaskSpec, state: StateModel) -> TaskGrade:
+    return GRADERS[task.grader_name](task, state)

support_ops_env/graders/common.py

@@ -0,0 +1,106 @@
+from __future__ import annotations
+
+from typing import Dict, List
+
+from ..models import StateModel, TaskGrade, TaskSpec, TicketSpec
+
+
+def _ticket_component(
+    ticket: TicketSpec,
+    state: StateModel,
+    weights: Dict[str, float],
+) -> Dict[str, float]:
+    discovered = set(state.discovered_keys.get(ticket.ticket_id, []))
+    required = set(ticket.required_context)
+    context_score = 1.0 if not required else len(discovered & required) / len(required)
+    escalation_value = state.escalations.get(ticket.ticket_id)
+    gold_escalation = ticket.gold_escalation_team
+    escalation_score = 1.0 if escalation_value == gold_escalation else 0.0
+    if gold_escalation is None and escalation_value is None:
+        escalation_score = 1.0
+
+    raw = {
+        "context": context_score,
+        "priority": 1.0 if state.priorities.get(ticket.ticket_id) == ticket.gold_priority else 0.0,
+        "route": 1.0 if state.routes.get(ticket.ticket_id) == ticket.gold_route else 0.0,
+        "resolution": 1.0 if state.resolutions.get(ticket.ticket_id) == ticket.gold_resolution else 0.0,
+        "escalation": escalation_score,
+    }
+    return {name: raw[name] * weights.get(name, 0.0) for name in raw}
+
+
+def grade_single_ticket(
+    task: TaskSpec,
+    state: StateModel,
+    weights: Dict[str, float],
+) -> TaskGrade:
+    ticket = task.tickets[0]
+    weighted = _ticket_component(ticket, state, weights)
+    score = round(sum(weighted.values()), 4)
+    notes = _notes_for_ticket(ticket, state)
+    return TaskGrade(
+        task_id=task.task_id,
+        score=score,
+        passed=score >= 0.8,
+        component_scores=weighted,
+        notes=notes,
+    )
+
+
+def grade_queue_task(
+    task: TaskSpec,
+    state: StateModel,
+    weights: Dict[str, float],
+) -> TaskGrade:
+    ticket_scores: List[float] = []
+    component_sums = {
+        "context": 0.0,
+        "priority": 0.0,
+        "route": 0.0,
+        "resolution": 0.0,
+        "escalation": 0.0,
+    }
+    notes: List[str] = []
+    for ticket in task.tickets:
+        weighted = _ticket_component(ticket, state, weights)
+        for name, value in weighted.items():
+            component_sums[name] += value
+        ticket_scores.append(sum(weighted.values()))
+        notes.extend(_notes_for_ticket(ticket, state))
+
+    divisor = max(len(task.tickets), 1)
+    averaged = {name: round(value / divisor, 4) for name, value in component_sums.items()}
+
+    ranking_score = 0.0
+    if task.gold_queue_order:
+        matches = sum(
+            1 for observed, expected in zip(state.queue_order, task.gold_queue_order) if observed == expected
+        )
+        ranking_score = round((matches / len(task.gold_queue_order)) * weights.get("ranking", 0.0), 4)
+
+    averaged["ranking"] = ranking_score
+    score = round(sum(averaged.values()), 4)
+    return TaskGrade(
+        task_id=task.task_id,
+        score=score,
+        passed=score >= 0.8,
+        component_scores=averaged,
+        notes=notes,
+    )
+
+
+def _notes_for_ticket(ticket: TicketSpec, state: StateModel) -> List[str]:
+    notes: List[str] = []
+    if state.priorities.get(ticket.ticket_id) != ticket.gold_priority:
+        notes.append(f"{ticket.ticket_id}: incorrect priority")
+    if state.routes.get(ticket.ticket_id) != ticket.gold_route:
+        notes.append(f"{ticket.ticket_id}: incorrect route")
+    if state.resolutions.get(ticket.ticket_id) != ticket.gold_resolution:
+        notes.append(f"{ticket.ticket_id}: incorrect resolution")
+    if state.escalations.get(ticket.ticket_id) != ticket.gold_escalation_team:
+        if not (ticket.gold_escalation_team is None and state.escalations.get(ticket.ticket_id) is None):
+            notes.append(f"{ticket.ticket_id}: incorrect escalation")
+    missing = set(ticket.required_context) - set(state.discovered_keys.get(ticket.ticket_id, []))
+    if missing:
+        notes.append(f"{ticket.ticket_id}: missing required context {sorted(missing)}")
+    return notes

support_ops_env/graders/easy.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+from ..models import StateModel, TaskGrade, TaskSpec
+from .common import grade_single_ticket
+
+
+WEIGHTS = {
+    "context": 0.2,
+    "priority": 0.2,
+    "route": 0.25,
+    "resolution": 0.2,
+    "escalation": 0.15,
+}
+
+
+def grade(task: TaskSpec, state: StateModel) -> TaskGrade:
+    return grade_single_ticket(task, state, WEIGHTS)

support_ops_env/graders/hard.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+from ..models import StateModel, TaskGrade, TaskSpec
+from .common import grade_queue_task
+
+
+WEIGHTS = {
+    "context": 0.1,
+    "priority": 0.2,
+    "route": 0.25,
+    "resolution": 0.2,
+    "escalation": 0.1,
+    "ranking": 0.15,
+}
+
+
+def grade(task: TaskSpec, state: StateModel) -> TaskGrade:
+    return grade_queue_task(task, state, WEIGHTS)

support_ops_env/graders/medium.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+from ..models import StateModel, TaskGrade, TaskSpec
+from .common import grade_single_ticket
+
+
+WEIGHTS = {
+    "context": 0.25,
+    "priority": 0.15,
+    "route": 0.25,
+    "resolution": 0.25,
+    "escalation": 0.1,
+}
+
+
+def grade(task: TaskSpec, state: StateModel) -> TaskGrade:
+    return grade_single_ticket(task, state, WEIGHTS)

support_ops_env/models.py

@@ -0,0 +1,119 @@
+from __future__ import annotations
+
+from typing import Any, Dict, List, Literal, Optional
+
+from pydantic import BaseModel, Field
+
+
+ActionType = Literal[
+    "inspect_ticket",
+    "request_context",
+    "set_priority",
+    "set_route",
+    "set_resolution",
+    "escalate",
+    "rank_queue",
+    "finalize",
+]
+
+
+class RewardModel(BaseModel):
+    value: float
+    components: Dict[str, float] = Field(default_factory=dict)
+    rationale: str = ""
+
+
+class Action(BaseModel):
+    action_type: ActionType
+    target: str = "T1"
+    value: Optional[str] = None
+
+
+class TicketObservation(BaseModel):
+    ticket_id: str
+    summary: str
+    visible_context: Dict[str, str]
+    discovered_context: Dict[str, str] = Field(default_factory=dict)
+    selected_priority: Optional[str] = None
+    selected_route: Optional[str] = None
+    selected_resolution: Optional[str] = None
+    escalation_team: Optional[str] = None
+
+
+class Observation(BaseModel):
+    task_id: str
+    difficulty: Literal["easy", "medium", "hard"]
+    title: str
+    instruction: str
+    queue_mode: bool
+    tickets: List[TicketObservation]
+    remaining_steps: int
+    available_actions: List[str]
+    current_queue_order: List[str] = Field(default_factory=list)
+    score_hint: Dict[str, float] = Field(default_factory=dict)
+
+
+class StateModel(BaseModel):
+    task_id: str
+    step_count: int
+    done: bool
+    discovered_keys: Dict[str, List[str]]
+    priorities: Dict[str, Optional[str]]
+    routes: Dict[str, Optional[str]]
+    resolutions: Dict[str, Optional[str]]
+    escalations: Dict[str, Optional[str]]
+    queue_order: List[str]
+    cumulative_reward: float
+    latest_score: Dict[str, float] = Field(default_factory=dict)
+
+
+class TicketSpec(BaseModel):
+    ticket_id: str
+    summary: str
+    visible_context: Dict[str, str]
+    hidden_context: Dict[str, str]
+    required_context: List[str]
+    gold_priority: str
+    gold_route: str
+    gold_resolution: str
+    gold_escalation_team: Optional[str] = None
+
+
+class TaskSpec(BaseModel):
+    task_id: str
+    difficulty: Literal["easy", "medium", "hard"]
+    title: str
+    description: str
+    instruction: str
+    max_steps: int
+    queue_mode: bool = False
+    tickets: List[TicketSpec]
+    gold_queue_order: List[str] = Field(default_factory=list)
+    grader_name: str
+    reward_weights: Dict[str, float] = Field(default_factory=dict)
+
+
+class TaskGrade(BaseModel):
+    task_id: str
+    score: float
+    passed: bool
+    component_scores: Dict[str, float]
+    notes: List[str] = Field(default_factory=list)
+
+
+class StepInfo(BaseModel):
+    task_id: str
+    step_count: int
+    task_score: float
+    done_reason: Optional[str] = None
+    grade: Optional[TaskGrade] = None
+    event: str = ""
+    event_score: Dict[str, float] = Field(default_factory=dict)
+
+
+class BaselineResult(BaseModel):
+    task_id: str
+    difficulty: str
+    score: float
+    steps: int
+    transcript: List[Dict[str, Any]]

support_ops_env/reward.py

@@ -0,0 +1,13 @@
+from __future__ import annotations
+
+from typing import Dict
+
+from .models import RewardModel
+
+
+STEP_PENALTY = -0.01
+
+
+def build_reward(components: Dict[str, float], rationale: str) -> RewardModel:
+    value = round(sum(components.values()), 4)
+    return RewardModel(value=value, components=components, rationale=rationale)

support_ops_env/state.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+from typing import Dict, List, Optional
+
+from .models import StateModel, TaskSpec
+
+
+def initial_tracking(task: TaskSpec) -> StateModel:
+    return StateModel(
+        task_id=task.task_id,
+        step_count=0,
+        done=False,
+        discovered_keys={ticket.ticket_id: [] for ticket in task.tickets},
+        priorities={ticket.ticket_id: None for ticket in task.tickets},
+        routes={ticket.ticket_id: None for ticket in task.tickets},
+        resolutions={ticket.ticket_id: None for ticket in task.tickets},
+        escalations={ticket.ticket_id: None for ticket in task.tickets},
+        queue_order=[],
+        cumulative_reward=0.0,
+        latest_score={},
+    )
+
+
+def update_mapping(
+    current: Dict[str, Optional[str]],
+    ticket_id: str,
+    value: Optional[str],
+) -> Dict[str, Optional[str]]:
+    current[ticket_id] = value
+    return current
+
+
+def discovered_for_ticket(discovered_keys: Dict[str, List[str]], ticket_id: str) -> List[str]:
+    return discovered_keys.setdefault(ticket_id, [])

support_ops_env/tasks/__init__.py

@@ -0,0 +1,3 @@
+from .loader import get_all_tasks, get_task, list_task_ids
+
+__all__ = ["get_all_tasks", "get_task", "list_task_ids"]

support_ops_env/tasks/loader.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Dict, List
+
+from ..models import TaskSpec
+
+
+DATA_DIR = Path(__file__).resolve().parent.parent / "data"
+
+
+def _load_file(name: str) -> List[TaskSpec]:
+    path = DATA_DIR / name
+    with path.open("r", encoding="utf-8") as handle:
+        raw = json.load(handle)
+    return [TaskSpec.model_validate(item) for item in raw]
+
+
+def get_all_tasks() -> List[TaskSpec]:
+    tasks: List[TaskSpec] = []
+    for filename in ("easy_cases.json", "medium_cases.json", "hard_cases.json"):
+        tasks.extend(_load_file(filename))
+    return tasks
+
+
+def get_task(task_id: str) -> TaskSpec:
+    for task in get_all_tasks():
+        if task.task_id == task_id:
+            return task
+    raise KeyError(f"Unknown task_id: {task_id}")
+
+
+def list_task_ids() -> List[str]:
+    return [task.task_id for task in get_all_tasks()]