Upload folder using huggingface_hub

Dockerfile

@@ -1,14 +1,83 @@
-FROM python:3.11-slim
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
 
-ENV PYTHONDONTWRITEBYTECODE=1
-ENV PYTHONUNBUFFERED=1
+# Multi-stage build using openenv-base
+# This Dockerfile is flexible and works for both:
+# - In-repo environments (with local OpenEnv sources)
+# - Standalone environments (with openenv from PyPI/Git)
+# The build script (openenv build) handles context detection and sets appropriate build args.
+
+ARG BASE_IMAGE=ghcr.io/meta-pytorch/openenv-base:latest
+FROM ${BASE_IMAGE} AS builder
 
 WORKDIR /app
 
-COPY . /app
-RUN pip install --no-cache-dir --upgrade pip && pip install --no-cache-dir -r /app/requirements.txt
+# Ensure git is available (required for installing dependencies from VCS)
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends git && \
+    rm -rf /var/lib/apt/lists/*
 
-EXPOSE 8000
+# Build argument to control whether we're building standalone or in-repo
+ARG BUILD_MODE=in-repo
+ARG ENV_NAME=supportdesk_env
+
+# Copy environment code (always at root of build context)
+COPY . /app/env
+
+# For in-repo builds, openenv is already vendored in the build context
+# For standalone builds, openenv will be installed via pyproject.toml
+WORKDIR /app/env
+
+# Ensure uv is available (for local builds where base image lacks it)
+RUN if ! command -v uv >/dev/null 2>&1; then \
+        curl -LsSf https://astral.sh/uv/install.sh | sh && \
+        mv /root/.local/bin/uv /usr/local/bin/uv && \
+        mv /root/.local/bin/uvx /usr/local/bin/uvx; \
+    fi
 
+# Install dependencies using uv sync
+# If uv.lock exists, use it; otherwise resolve on the fly
+RUN --mount=type=cache,target=/root/.cache/uv \
+    if [ -f uv.lock ]; then \
+        uv sync --frozen --no-install-project --no-editable; \
+    else \
+        uv sync --no-install-project --no-editable; \
+    fi
+
+RUN --mount=type=cache,target=/root/.cache/uv \
+    if [ -f uv.lock ]; then \
+        uv sync --frozen --no-editable; \
+    else \
+        uv sync --no-editable; \
+    fi
+
+# Final runtime stage
+FROM ${BASE_IMAGE}
+
+WORKDIR /app
+
+# Copy the virtual environment from builder
+COPY --from=builder /app/env/.venv /app/.venv
+
+# Copy the environment code
+COPY --from=builder /app/env /app/env
+
+# Set PATH to use the virtual environment
+ENV PATH="/app/.venv/bin:$PATH"
+
+# Set PYTHONPATH so imports work correctly
+ENV PYTHONPATH="/app/env:$PYTHONPATH"
 ENV ENABLE_WEB_INTERFACE=true
-CMD ["python", "-m", "supportdesk_env.server.app"]
+
+EXPOSE 8000
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
+    CMD curl -f http://localhost:8000/health || exit 1
+
+# Run the FastAPI server
+# The module path is constructed to work with this repo's package layout.
+CMD ["sh", "-c", "cd /app/env && uvicorn supportdesk_env.server.app:app --host 0.0.0.0 --port 8000"]

README.md

@@ -11,75 +11,42 @@ base_path: /web
 
 # HyperBrickCaseOps
 
-SupportDesk is best thought of as an enterprise operations-desk environment, not a generic support classifier.
+HyperBrickCaseOps is an OpenEnv environment for enterprise support operations. The agent gets a real support ticket, a few policy snippets, and the current case state. From there it has to do the same kind of work a human support or operations teammate would do: route the case, set urgency, ask for missing details, write the customer reply, leave an internal note, and decide whether the case should stay open, be resolved, or be escalated.
 
-SupportDesk is a real-world RL environment for enterprise support operations. The agent receives a realistic inbound ticket, a small internal knowledge base, and the live case state. It must route the case, set the right priority, decide whether to request more information, draft the customer response, add an internal note, and submit the case with the correct final status.
+The main idea is simple: good support work is not just writing a polite reply. It also means making the right operational decision.
 
-One-sentence summary: HyperBrickCaseOps is a deterministic OpenEnv customer-support operations environment that evaluates whether an agent can triage, communicate, escalate, and resolve enterprise cases correctly end to end.
+## Environment description and motivation
 
-This environment is intentionally built around work humans actually do every day in B2B SaaS support queues. It is not a toy chat task and it is not a game. The environment includes enterprise mechanics such as SLA countdowns, business-impact context, and distracting secondary concerns, so the agent has to prioritize the primary operational issue instead of just pattern-matching keywords.
+This environment was built around a gap that shows up in a lot of support benchmarks. Many benchmarks check whether a model can produce a plausible response, but real support work also needs correct routing, escalation, information gathering, and final case handling.
 
-## Environment Description and Motivation
+HyperBrickCaseOps is meant to test that full workflow.
 
-The goal of this environment is to model a real operational gap in agent evaluation: many support benchmarks only test whether a model can produce a plausible reply, but real support work also requires correct routing, escalation, information gathering, and final disposition decisions. SupportDesk is designed to evaluate whether an agent can handle enterprise support operations end to end rather than just generate support-sounding text.
+It is not a toy game and it is not a chat-only task. The cases include things like:
 
-This makes the environment useful for both:
+- SLA pressure
+- affected user counts
+- customer tier
+- secondary concerns that should not distract the agent from the main issue
+- delayed customer follow-up turns
+- unsafe requests that should not be approved just because the customer sounds urgent
 
-- training agents to improve multi-step support operations behavior
-- evaluating whether an agent can make safe and business-correct support decisions under pressure
+## OpenEnv interface
 
-## Why this should score well
+The environment uses the standard OpenEnv flow:
 
-- Real-world utility: customer support triage is a real production workflow with immediate evaluation value.
-- Deterministic grading: every task has an explicit gold queue, priority, issue type, required follow-up fields, reply markers, note markers, status, and resolution code.
-- Dense rewards: each step gets rewarded from the delta in the deterministic grader, which gives partial progress rather than only a binary terminal signal.
-- Reproducible baseline: `inference.py` runs all tasks in a fixed order and falls back to a deterministic heuristic policy if model credentials are unavailable.
-- Novel mechanics: observations expose SLA pressure, business impact, and secondary concerns, which makes the environment closer to an enterprise operations desk than a plain support classifier.
+- `reset()` starts a new case and returns the first observation
+- `step(action)` applies one typed action and returns the next observation
+- `state()` returns the current typed internal state
 
-## Architecture Diagram
+The metadata is defined in `openenv.yaml`, and the HTTP app is created through `create_app(...)`.
 
-```text
-Inbound Task Spec + Ticket + KB
-            |
-            v
-  SupportDeskEnvironment
-  - reset()
-  - step(action)
-  - state()
-            |
-            +--> SupportDeskObservation
-            +--> dense reward shaping
-            +--> episode termination
-            |
-            v
-     Deterministic Grader
-     - queue correctness
-     - priority correctness
-     - issue type correctness
-     - requested fields
-     - reply coverage
-     - internal note coverage
-     - status / resolution
-            |
-            v
-   Baseline in inference.py
-   - OpenAI-compatible client path
-   - deterministic fallback path
-```
-
-## Why this is more novel than a standard support benchmark
-
-- It is not just routing or intent classification. The agent has to combine queueing, urgency, customer communication, internal notes, and final disposition in one trajectory.
-- It models primary-vs-secondary issue prioritization. The hardest task includes a tempting compliance side-question that should not override the live outage.
-- It encodes enterprise pressure directly in the observation through SLA countdowns, affected-user counts, and business-impact context.
-- It evaluates operational judgment, not just answer quality. A polished reply with the wrong queue, wrong escalation choice, or premature resolution still scores poorly.
-- It is built specifically for OpenEnv-style agent learning and evaluation, where the same environment can be used for baseline runs, external agents, and RL experiments.
+## Action space
 
-## Action Space
+Each step takes a typed `SupportDeskAction`.
 
-Each `step()` takes a typed `SupportDeskAction` with:
+Fields:
 
-- `operation`: one of `classify`, `request_info`, `draft_reply`, `add_internal_note`, `submit`
+- `operation`
 - `queue`
 - `priority`
 - `issue_type`
@@ -89,166 +56,282 @@ Each `step()` takes a typed `SupportDeskAction` with:
 - `reply`
 - `internal_note`
 
-The environment allows the agent to update multiple fields in one structured action, which keeps the workflow realistic and helps training.
-
-## Observation Space
-
-Each observation contains:
+Supported operations:
+
+- `classify`
+  Sets `queue`, `priority`, and `issue_type`.
+- `request_info`
+  Requests missing fields from the customer.
+- `draft_reply`
+  Writes the customer-facing reply.
+- `add_internal_note`
+  Writes the internal note for handoff or auditability.
+- `submit`
+  Sets the final `status` and `resolution_code`.
+- `wait`
+  Advances the environment when a customer follow-up is pending.
+
+Example action:
+
+```json
+{
+  "operation": "classify",
+  "queue": "trust_and_safety",
+  "priority": "urgent",
+  "issue_type": "account_compromise",
+  "status": null,
+  "resolution_code": null,
+  "requested_fields": [],
+  "reply": null,
+  "internal_note": null
+}
+```
 
-- `task_id`, `difficulty`, and the agent objective
-- the inbound `ticket`
-- ticket-level urgency metadata such as `affected_users`, `sla_minutes_remaining`, `business_impact`, and `secondary_concerns`
-- `knowledge_base` policy snippets
-- allowed queues, priorities, statuses, and issue types
-- the mutable `case` snapshot
+## Observation space
+
+Each observation is a typed `SupportDeskObservation`.
+
+Main fields:
+
+- `task_id`
+- `difficulty`
+- `objective`
+- `ticket`
+- `knowledge_base`
+- `available_queues`
+- `available_priorities`
+- `available_statuses`
+- `available_issue_types`
+- `case`
+- `current_sla_minutes_remaining`
+- `workflow_stage`
+- `required_next_actions`
+- `risk_flags`
 - `action_history`
 - `feedback`
 - `remaining_steps`
-- the standard OpenEnv `reward` and `done`
+- `reward`
+- `done`
+
+The `case` object is the mutable operational state. It contains:
+
+- current queue, priority, and issue type
+- requested fields
+- reply draft
+- internal note
+- final status and resolution code
+- customer follow-up state
+
+Customer follow-up can move through:
+
+- `none`
+- `pending`
+- `partial`
+- `complete`
+- `incorrect`
+
+The observation is designed to help the agent reason about process, not just text:
+
+- `workflow_stage` shows whether the agent is still classifying, waiting on a reply, drafting communication, or ready to submit
+- `required_next_actions` tells the agent which steps are still missing
+- `risk_flags` surfaces urgency and safety issues like SLA risk, unsafe unlock pressure, and irrelevant customer follow-up
+
+## State space
+
+`state()` returns the typed `SupportDeskState`.
+
+Main fields:
+
+- `episode_id`
+- `task_id`
+- `difficulty`
+- `step_count`
+- `reward`
+- `done`
+- `current_score`
+- `max_steps`
+- `case`
+- `current_sla_minutes_remaining`
+- `workflow_stage`
+- `required_next_actions`
+- `risk_flags`
+- `action_history`
+- `completed_milestones`
+- `last_feedback`
+
+## Task descriptions
+
+There are four deterministic tasks in a fixed order.
+
+### 1. `billing_refund_easy`
+
+Difficulty: easy
+
+A customer was charged twice after cancellation. The right workflow is to route the case to billing, confirm the refund path, leave a useful note, and resolve the case without asking for unnecessary extra information.
+
+### 2. `account_takeover_medium`
+
+Difficulty: medium
 
-## OpenEnv Interface
+This is a suspicious-login recovery case. The agent has to route it to trust and safety, request verification details, handle a delayed partial follow-up from the customer, and keep the case open until the missing information is provided. Unlocking the account immediately would be unsafe.
 
-The environment implements the standard OpenEnv API:
+### 3. `api_incident_hard`
 
-- `reset()` returns the initial typed observation for a new case
-- `step(action)` returns the next typed observation together with reward and done status
-- `state()` returns the current typed environment state
-- `openenv.yaml` provides environment metadata used by validators and deployment tooling
+Difficulty: hard
 
-The implementation uses typed Pydantic models for action, observation, and state.
+This task simulates a live enterprise API incident. The ticket includes a secondary compliance concern, but the primary issue is the outage. The agent needs to escalate to engineering, request the right diagnostics, communicate clearly, and keep the incident open rather than marking it resolved.
 
-## Task Descriptions with Expected Difficulty
+### 4. `regulated_export_exception_hard`
 
-1. `billing_refund_easy` - Expected difficulty: easy
-   Duplicate-charge billing ticket. The correct path is immediate billing routing, a refund confirmation, and case resolution.
-2. `account_takeover_medium` - Expected difficulty: medium
-   Suspicious-login security ticket. The agent must escalate to trust and safety, request verification details, and keep the case waiting on the customer.
-3. `api_incident_hard` - Expected difficulty: hard
-   Enterprise production API incident with a distracting compliance mention. The agent must escalate to platform engineering, request the right diagnostics, and open the incident instead of resolving it.
+Difficulty: hard
 
-What makes these tasks less generic than ordinary support-routing demos:
+This is a regulated exception request. The customer wants a shortcut around an export restriction, but the correct workflow is to route the case to compliance, request legal approval details, and keep the case open pending review. Sending it straight to engineering for a workaround is the wrong move.
 
-- They mix queueing, priority, customer communication, internal note-taking, and close-vs-escalate decisions in one trajectory.
-- They include operational context like customer tier, affected-user count, SLA pressure, and business impact.
-- The harder tasks contain conflicting or distracting signals, so a frontier model has to identify the primary issue instead of treating every mention as equally important.
+## Reward and grader design
 
-## Deterministic Graders
+Each task has a deterministic grader that returns a score in `[0.0, 1.0]`.
 
-The final task score is a weighted total in `[0.0, 1.0]`:
+The grader checks:
 
-- Queue correctness: `0.15`
-- Priority correctness: `0.10`
-- Issue-type correctness: `0.10`
-- Requested-fields correctness: `0.15`
-- Reply coverage: `0.25`
-- Internal-note coverage: `0.10`
-- Final status: `0.10`
-- Resolution code: `0.05`
+- queue correctness
+- priority correctness
+- issue type correctness
+- requested fields
+- reply coverage
+- internal note coverage
+- final status
+- resolution code
 
-The same grader also drives dense reward shaping during the episode by comparing the current score to the previous score and then subtracting small penalties for no-op or low-signal actions.
+The environment uses the grader score delta as the main dense reward signal. On top of that, it adds smaller process-aware bonuses and penalties so that the full trajectory matters, not just the final snapshot.
 
-## Project Layout
+Examples:
+
+- bonus for early correct routing on urgent tasks
+- bonus for moving through the workflow in the right order
+- bonus when `wait` correctly reveals a scripted customer follow-up
+- penalty for premature submit
+- penalty for over-escalation
+- penalty for mixed or sloppy actions
+- penalty when the SLA gets critically low
+
+## Project layout
 
 ```text
 .
 |-- inference.py
 |-- openenv.yaml
 |-- pyproject.toml
-|-- requirements.txt
+|-- Dockerfile
+|-- uv.lock
 |-- supportdesk_env
 |   |-- __init__.py
-|   |-- client.py
 |   |-- graders.py
 |   |-- models.py
+|   |-- policies.py
 |   |-- tasks.py
 |   `-- server
 |       |-- app.py
 |       `-- supportdesk_environment.py
 |-- tests
 |   `-- test_supportdesk.py
-`-- uv.lock
+`-- examples
+    `-- rl
+        `-- train_q_agent.py
 ```
 
-## Local Setup
+## Setup instructions
+
+### Option 1: pip
 
 ```bash
 pip install -r requirements.txt
 ```
 
-Or with uv:
+### Option 2: uv
 
 ```bash
 uv sync
 ```
 
-Optional environment variables for the baseline:
+## Usage instructions
+
+Validate the repo:
 
 ```bash
-export API_BASE_URL="https://router.huggingface.co/v1"
-export MODEL_NAME="openai/gpt-oss-120b"
-export OPENAI_API_KEY="sk-..."  # Or use HF_TOKEN with a compatible router
-export HF_TOKEN="hf_..."
+python -m openenv.cli validate .
 ```
 
-The baseline uses the OpenAI Python client and supports both `OPENAI_API_KEY` and `HF_TOKEN`.
-
-## Setup and Usage Instructions
-
-Typical local workflow:
+Start the local server:
 
 ```bash
-pip install -r requirements.txt
-python -m openenv.cli validate .
-python inference.py
 python -m supportdesk_env.server.app
 ```
 
-## Local RL Playground
-
-If you want to import the package directly and train against the local environment without going through the HTTP server, use the tabular Q-learning example:
+Or use the entrypoint:
 
 ```bash
-python examples/rl/train_q_agent.py
+server
 ```
 
-This script imports the package, instantiates `SupportDeskEnvironment` directly, trains a tiny Q-learning agent over a compact discrete action library, and then prints greedy evaluation results for all three tasks. It is meant as a local experimentation playground, not as the official submission baseline.
-
-## Run the Server
+Run the baseline:
 
 ```bash
-python -m supportdesk_env.server.app
+python inference.py
 ```
 
-Or with the OpenEnv entrypoint:
+There is also a small local RL example:
 
 ```bash
-server
+python examples/rl/train_q_agent.py
 ```
 
-## Run the Baseline
+## Baseline and environment variables
+
+`inference.py` uses the OpenAI Python client when model configuration is supplied externally at runtime.
+
+Supported variables:
+
+- `API_BASE_URL`
+- `MODEL_NAME`
+- `HF_TOKEN`
+- `OPENAI_API_KEY`
+- `MAX_STEPS`
+- `TEMPERATURE`
+
+Example:
 
 ```bash
+export API_BASE_URL="https://router.huggingface.co/v1"
+export MODEL_NAME="openai/gpt-4.1-mini"
+export HF_TOKEN="your-token-here"
 python inference.py
 ```
 
-When model credentials are present, the script uses the OpenAI client against `API_BASE_URL` and `MODEL_NAME`. If credentials are missing or a request fails, it falls back to a deterministic heuristic policy so the script still completes and prints reproducible scores.
+Important:
+
+- the repo does not depend on hardcoded credentials
+- the expected evaluation setup is environment-variable driven
+- if credentials are missing or the model call fails, the baseline falls back to a deterministic heuristic policy so the script still completes
 
 ## Docker
 
+Build:
+
 ```bash
 docker build -t supportdesk-env .
-docker run -p 8000:8000 supportdesk-env
 ```
 
-## Hugging Face Space Deployment
+Run:
 
-Deploy this repo as a Docker Space and keep it public for submission. The Space should include the `openenv` tag and the following environment configuration values:
+```bash
+docker run -p 8000:8000 supportdesk-env
+```
 
-- `API_BASE_URL`
-- `MODEL_NAME`
-- `HF_TOKEN`
+## Hugging Face Space deployment
+
+This repo is meant to run as a Docker Space. Keep both the GitHub repository and the Hugging Face Space public for submission.
 
-If the OpenEnv CLI is installed, deployment can be done with:
+If you have the OpenEnv CLI installed, a typical deployment command is:
 
 ```bash
 openenv push --repo-id your-username/HyperBrickCaseOps
@@ -256,32 +339,44 @@ openenv push --repo-id your-username/HyperBrickCaseOps
 
 ## Validation
 
+Local validation:
+
 ```bash
 openenv validate .
 ```
 
-For a full pre-submission pass against a deployed Space:
+Validation against a running environment:
+
+```bash
+openenv validate http://127.0.0.1:8000
+```
+
+Pre-submission script:
 
 ```bash
 ./scripts/validate-submission.sh https://your-space.hf.space .
 ```
 
-## Submission Checklist
+## Submission checklist
 
-- Public GitHub repository with this codebase
-- Root `inference.py`
-- Working Docker build
-- Deployed Hugging Face Docker Space tagged `openenv`
-- Space secrets configured: `API_BASE_URL`, `MODEL_NAME`, `HF_TOKEN`
-- README present with environment overview, action/observation definitions, tasks, setup, and baseline scores
+- real-world environment, not a toy or game
+- typed OpenEnv action, observation, and state models
+- working `reset`, `step`, and `state`
+- at least 3 tasks with deterministic graders
+- meaningful reward over the trajectory
+- root `inference.py`
+- working `Dockerfile`
+- `openenv.yaml` present
+- README includes environment description, motivation, action space, observation space, task descriptions, setup instructions, and baseline scores
 
-## Baseline Scores
+## Baseline scores
 
-Expected deterministic fallback baseline:
+Current deterministic fallback baseline:
 
 - `billing_refund_easy`: `1.00`
 - `account_takeover_medium`: `1.00`
 - `api_incident_hard`: `1.00`
-- Average: `1.00`
+- `regulated_export_exception_hard`: `1.00`
+- average: `1.00`
 
-These scores are deliberately reproducible because the fallback policy follows the gold workflow exactly. A model-backed run will typically be lower unless the prompt or model is improved, which makes the environment useful for both training and evaluation.
+These scores are intentionally reproducible. The fallback policy exists to show that the environment, reward shaping, and graders all work end to end. Model-backed runs can be lower, which is useful for evaluation.

inference.py

@@ -2,26 +2,41 @@
 
 from __future__ import annotations
 
+import asyncio
 import json
 import os
 import re
-from statistics import mean
+from dataclasses import dataclass
+from typing import Any
 
 try:
     from openai import OpenAI
 except ImportError:  # pragma: no cover - local fallback mode
     OpenAI = None  # type: ignore[assignment]
 
+from supportdesk_env.client import SupportDeskEnv
 from supportdesk_env.graders import grade_case
 from supportdesk_env.models import SupportDeskAction, SupportDeskObservation
 from supportdesk_env.policies import heuristic_action
 from supportdesk_env.server.supportdesk_environment import SupportDeskEnvironment
 from supportdesk_env.tasks import get_task, list_task_ids
 
+API_BASE_URL = os.getenv("API_BASE_URL", "https://router.huggingface.co/v1")
+MODEL_NAME = os.getenv("MODEL_NAME", "gpt-4.1-mini")
+HF_TOKEN = os.getenv("HF_TOKEN")
+API_KEY = HF_TOKEN
+LOCAL_IMAGE_NAME = os.getenv("LOCAL_IMAGE_NAME")
+TASK_NAME = os.getenv("SUPPORTDESK_TASK_ID", "billing_refund_easy")
+BENCHMARK = os.getenv("SUPPORTDESK_BENCHMARK", "supportdesk_env")
+MAX_STEPS = int(os.getenv("MAX_STEPS", "8"))
+TEMPERATURE = float(os.getenv("TEMPERATURE", "0"))
+MAX_TOKENS = int(os.getenv("MAX_TOKENS", "300"))
+SUCCESS_SCORE_THRESHOLD = float(os.getenv("SUCCESS_SCORE_THRESHOLD", "0.1"))
+
 SYSTEM_PROMPT = """You are a support operations agent solving one triage ticket.
 Return exactly one JSON object with this schema:
 {
-  "operation": "classify|request_info|draft_reply|add_internal_note|submit",
+  "operation": "classify|request_info|draft_reply|add_internal_note|submit|wait",
   "queue": string or null,
   "priority": string or null,
   "issue_type": string or null,
@@ -35,25 +50,23 @@ Return exactly one JSON object with this schema:
 Use the policy snippets in the observation. Keep customer replies short, precise, and professional.
 """
 
-MODEL_NAME = os.getenv("MODEL_NAME", "gpt-4.1-mini")
-API_BASE_URL = os.getenv("API_BASE_URL")
-API_KEY = os.getenv("OPENAI_API_KEY") or os.getenv("HF_TOKEN") or "not-set"
-MAX_STEPS = int(os.getenv("MAX_STEPS", "6"))
-TEMPERATURE = float(os.getenv("TEMPERATURE", "0"))
+
+@dataclass
+class EpisodeResult:
+    """Compact result used for final success logging."""
+
+    final_score: float
+    steps_taken: int
+    rewards: list[float]
 
 
 def _build_client() -> OpenAI | None:
-    if OpenAI is None:
+    if OpenAI is None or not API_KEY:
         return None
-    if API_KEY == "not-set":
-        return None
-    kwargs = {"api_key": API_KEY}
-    if API_BASE_URL:
-        kwargs["base_url"] = API_BASE_URL
-    return OpenAI(**kwargs)
+    return OpenAI(base_url=API_BASE_URL, api_key=API_KEY)
 
 
-def _extract_json(text: str) -> dict:
+def _extract_json(text: str) -> dict[str, Any]:
     try:
         return json.loads(text)
     except json.JSONDecodeError:
@@ -65,7 +78,8 @@ def _extract_json(text: str) -> dict:
 
 def _observation_prompt(observation: SupportDeskObservation) -> str:
     kb_lines = "\n".join(
-        f"- {snippet.article_id}: {snippet.title}: {snippet.content}" for snippet in observation.knowledge_base
+        f"- {snippet.article_id}: {snippet.title}: {snippet.content}"
+        for snippet in observation.knowledge_base
     )
     history_lines = "\n".join(
         f"- step {entry.step}: {entry.summary} ({entry.reward_delta:+.2f})"
@@ -79,7 +93,7 @@ Ticket body: {observation.ticket.body}
 Customer tier: {observation.ticket.customer_tier}
 Region: {observation.ticket.region}
 Affected users: {observation.ticket.affected_users}
-SLA minutes remaining: {observation.ticket.sla_minutes_remaining}
+SLA minutes remaining: {observation.current_sla_minutes_remaining}
 Business impact: {observation.ticket.business_impact}
 Secondary concerns: {observation.ticket.secondary_concerns}
 
@@ -95,7 +109,11 @@ Current case state:
 - requested_fields: {observation.case.requested_fields}
 - reply: {observation.case.reply}
 - internal_note: {observation.case.internal_note}
+- customer_follow_up: {observation.case.customer_follow_up.status}
 
+Workflow stage: {observation.workflow_stage}
+Required next actions: {observation.required_next_actions}
+Risk flags: {observation.risk_flags}
 Feedback: {observation.feedback}
 Remaining steps: {observation.remaining_steps}
 
@@ -112,6 +130,7 @@ def _model_action(client: OpenAI | None, observation: SupportDeskObservation) ->
         completion = client.chat.completions.create(
             model=MODEL_NAME,
             temperature=TEMPERATURE,
+            max_tokens=MAX_TOKENS,
             messages=[
                 {"role": "system", "content": SYSTEM_PROMPT},
                 {"role": "user", "content": _observation_prompt(observation)},
@@ -124,28 +143,147 @@ def _model_action(client: OpenAI | None, observation: SupportDeskObservation) ->
         return heuristic_action(observation)
 
 
-def run_task(task_id: str, client: OpenAI | None) -> float:
+def _action_to_log_string(action: SupportDeskAction) -> str:
+    if hasattr(action, "model_dump_json"):
+        payload = action.model_dump(
+            exclude_none=True,
+            exclude_defaults=True,
+            exclude={"metadata"},
+        )
+    else:
+        payload = action.dict(
+            exclude_none=True,
+            exclude_defaults=True,
+        )
+        payload.pop("metadata", None)
+    return json.dumps(payload, separators=(",", ":"))
+
+
+def _log_start(task: str) -> None:
+    print(f"[START] task={task} env={BENCHMARK} model={MODEL_NAME}", flush=True)
+
+
+def _log_step(step: int, action_str: str, reward: float, done: bool, error: str | None) -> None:
+    error_value = error if error else "null"
+    print(
+        f"[STEP] step={step} action={action_str} reward={reward:.2f} "
+        f"done={str(done).lower()} error={error_value}",
+        flush=True,
+    )
+
+
+def _log_end(success: bool, steps: int, rewards: list[float]) -> None:
+    reward_text = ",".join(f"{reward:.2f}" for reward in rewards)
+    print(
+        f"[END] success={str(success).lower()} steps={steps} rewards={reward_text}",
+        flush=True,
+    )
+
+
+def _run_local_episode(task_id: str, client: OpenAI | None) -> EpisodeResult:
     env = SupportDeskEnvironment(task_id=task_id)
     observation = env.reset()
+    rewards: list[float] = []
+    steps_taken = 0
 
     try:
-        for _ in range(MAX_STEPS):
-            action = _model_action(client, observation)
-            observation = env.step(action)
+        for step in range(1, MAX_STEPS + 1):
             if observation.done:
                 break
+
+            action = _model_action(client, observation)
+            action_str = _action_to_log_string(action)
+
+            try:
+                observation = env.step(action)
+                reward = observation.reward or 0.0
+                done = observation.done
+                error = None
+            except Exception as exc:
+                raise RuntimeError(str(exc)) from exc
+
+            _log_step(step, action_str, reward, done, error)
+            rewards.append(reward)
+            steps_taken = step
+
+            if done:
+                break
+
         final_grade = grade_case(get_task(task_id), env.state.case)
-        print(f"{task_id}: score={final_grade.total_score:.2f} reward={env.state.reward:.2f}")
-        return final_grade.total_score
+        return EpisodeResult(
+            final_score=final_grade.total_score,
+            steps_taken=steps_taken,
+            rewards=rewards,
+        )
     finally:
         env.close()
 
 
-def main() -> None:
+async def _run_docker_episode(task_id: str, client: OpenAI | None) -> EpisodeResult:
+    env = await SupportDeskEnv.from_docker_image(
+        LOCAL_IMAGE_NAME,
+        env_vars={"SUPPORTDESK_TASK_ID": task_id},
+    )
+    rewards: list[float] = []
+    steps_taken = 0
+
+    try:
+        result = await env.reset()
+        observation = result.observation
+
+        for step in range(1, MAX_STEPS + 1):
+            if result.done:
+                break
+
+            action = _model_action(client, observation)
+            action_str = _action_to_log_string(action)
+
+            try:
+                result = await env.step(action)
+                observation = result.observation
+                reward = result.reward or 0.0
+                done = result.done
+                error = None
+            except Exception as exc:
+                raise RuntimeError(str(exc)) from exc
+
+            _log_step(step, action_str, reward, done, error)
+            rewards.append(reward)
+            steps_taken = step
+
+            if done:
+                break
+
+        state = await env.state()
+        final_grade = grade_case(get_task(task_id), state.case)
+        return EpisodeResult(
+            final_score=final_grade.total_score,
+            steps_taken=steps_taken,
+            rewards=rewards,
+        )
+    finally:
+        await env.close()
+
+
+async def main() -> None:
     client = _build_client()
-    scores = [run_task(task_id, client) for task_id in list_task_ids()]
-    print(f"average_score={mean(scores):.3f}")
+    success = False
+    steps_taken = 0
+    rewards: list[float] = []
+
+    _log_start(TASK_NAME)
+
+    try:
+        if LOCAL_IMAGE_NAME:
+            episode = await _run_docker_episode(TASK_NAME, client)
+        else:
+            episode = _run_local_episode(TASK_NAME, client)
+        success = episode.final_score >= SUCCESS_SCORE_THRESHOLD
+        steps_taken = episode.steps_taken
+        rewards = episode.rewards
+    finally:
+        _log_end(success=success, steps=steps_taken, rewards=rewards)
 
 
 if __name__ == "__main__":
-    main()
+    asyncio.run(main())

openenv.yaml

@@ -1,3 +1,8 @@
+spec_version: 1
 name: HyperBrickCaseOps
 env_name: supportdesk_env
+type: space
+runtime: fastapi
+app: supportdesk_env.server.app:app
+port: 8000
 description: Enterprise support operations environment with SLA pressure, business-impact aware triage, and primary-vs-secondary issue prioritization.

pyproject.toml

@@ -1,29 +1,41 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+[build-system]
+requires = ["setuptools>=45", "wheel"]
+build-backend = "setuptools.build_meta"
+
 [project]
 name = "supportdesk-env"
 version = "0.1.0"
-description = "A real-world OpenEnv environment for customer support triage and escalation."
+description = "Enterprise support operations environment for OpenEnv"
+requires-python = ">=3.10"
 authors = [{ name = "HyperBrick" }]
 dependencies = [
-  "fastapi>=0.115.0",
-  "openai>=1.54.0",
-  "openenv-core>=0.2.0",
-  "pydantic>=2.9.0",
-  "requests>=2.32.0",
-  "uvicorn>=0.30.0",
+    # Core OpenEnv runtime (provides FastAPI server + HTTP client types)
+    "openenv-core[core]>=0.2.2",
+    # Environment-specific dependencies
+    "fastapi>=0.115.0",
+    "openai>=1.54.0",
+    "pydantic>=2.9.0",
+    "requests>=2.32.0",
+    "uvicorn>=0.30.0",
 ]
-requires-python = ">=3.10"
 
 [project.optional-dependencies]
 dev = [
-  "pytest>=8.3.0",
+    "pytest>=8.0.0",
+    "pytest-cov>=4.0.0",
 ]
 
 [project.scripts]
-server = "main:main"
-
-[build-system]
-requires = ["setuptools"]
-build-backend = "setuptools.build_meta"
+# Server entry point - enables running via: uv run --project . server
+# or: python -m supportdesk_env.server.app
+server = "supportdesk_env.server.app:main"
 
 [tool.setuptools]
+include-package-data = true
 packages = ["supportdesk_env", "supportdesk_env.server"]

pytest.ini

@@ -0,0 +1,3 @@
+[pytest]
+addopts = -p no:cacheprovider
+testpaths = tests

supportdesk_env/client.py

@@ -15,6 +15,13 @@ def _validate(model_cls, payload):
 class SupportDeskEnv(EnvClient[SupportDeskAction, SupportDeskObservation, SupportDeskState]):
     """Typed client for a locally running or deployed OpenEnv server."""
 
+    def _step_payload(self, action: SupportDeskAction) -> dict:
+        """Convert a typed action into the JSON payload expected by the server."""
+
+        if hasattr(action, "model_dump"):
+            return action.model_dump()
+        return action.dict()
+
     def _parse_state(self, payload) -> SupportDeskState:
         return _validate(SupportDeskState, payload)
 

supportdesk_env/models.py

@@ -42,6 +42,15 @@ class ActionHistoryEntry(BaseModel):
     reward_delta: float = 0.0
 
 
+class CustomerFollowUp(BaseModel):
+    """A scripted customer response that arrives after a request for more information."""
+
+    status: Literal["none", "pending", "partial", "complete", "incorrect"] = "none"
+    message: str | None = None
+    provided_fields: list[str] = Field(default_factory=list)
+    wrong_fields: list[str] = Field(default_factory=list)
+
+
 class SupportCaseProgress(BaseModel):
     """Mutable case state that graders score against."""
 
@@ -53,12 +62,13 @@ class SupportCaseProgress(BaseModel):
     requested_fields: list[str] = Field(default_factory=list)
     reply: str | None = None
     internal_note: str | None = None
+    customer_follow_up: CustomerFollowUp = Field(default_factory=CustomerFollowUp)
 
 
 class SupportDeskAction(Action):
     """One structured action the agent can take at each step."""
 
-    operation: Literal["classify", "request_info", "draft_reply", "add_internal_note", "submit"]
+    operation: Literal["classify", "request_info", "draft_reply", "add_internal_note", "submit", "wait"]
     queue: str | None = None
     priority: str | None = None
     issue_type: str | None = None
@@ -82,6 +92,10 @@ class SupportDeskObservation(Observation):
     available_statuses: list[str]
     available_issue_types: list[str]
     case: SupportCaseProgress
+    current_sla_minutes_remaining: int | None = None
+    workflow_stage: str
+    required_next_actions: list[str] = Field(default_factory=list)
+    risk_flags: list[str] = Field(default_factory=list)
     action_history: list[ActionHistoryEntry] = Field(default_factory=list)
     feedback: str = ""
     remaining_steps: int = 0
@@ -99,6 +113,10 @@ class SupportDeskState(State):
     current_score: float = 0.0
     max_steps: int = 0
     case: SupportCaseProgress
+    current_sla_minutes_remaining: int | None = None
+    workflow_stage: str
+    required_next_actions: list[str] = Field(default_factory=list)
+    risk_flags: list[str] = Field(default_factory=list)
     action_history: list[ActionHistoryEntry] = Field(default_factory=list)
     completed_milestones: list[str] = Field(default_factory=list)
     last_feedback: str = ""

supportdesk_env/policies.py

@@ -20,6 +20,12 @@ def default_reply(task_id: str) -> str:
             "device for malware, and reply with your workspace_id, last successful login time, "
             "and billing email so we can verify the account safely."
         )
+    if task_id == "regulated_export_exception_hard":
+        return (
+            "We cannot provide a bypass or temporary unlock yet. Our compliance team is running "
+            "a compliance review, and we need your tenant_region, dpa_amendment_id, and "
+            "legal_contact_email to continue that review."
+        )
     return (
         "We are treating this as an active incident and our on-call engineering team is engaged. "
         "Please send the affected request IDs, UTC timestamps, and the impacted region so we can "
@@ -34,6 +40,11 @@ def default_note(task_id: str) -> str:
         return "Duplicate charge confirmed from attached invoice; refund approved."
     if task_id == "account_takeover_medium":
         return "Suspicious login alert reported and customer is locked out."
+    if task_id == "regulated_export_exception_hard":
+        return (
+            "Audit-driven export exception request tied to an EU residency policy block; "
+            "customer asked for a manual bypass before legal approval."
+        )
     return "EU data residency rollout hit intermittent HTTP 500s and the customer launches tonight."
 
 
@@ -55,10 +66,11 @@ def heuristic_action(observation: SupportDeskObservation) -> SupportDeskAction:
         return SupportDeskAction(
             operation="request_info",
             requested_fields=list(task.required_requested_fields),
-            status=task.gold_status,
-            reply=default_reply(observation.task_id),
         )
 
+    if case.customer_follow_up.status == "pending":
+        return SupportDeskAction(operation="wait")
+
     if not case.reply:
         return SupportDeskAction(operation="draft_reply", reply=default_reply(observation.task_id))
 

supportdesk_env/server/app.py

@@ -1,4 +1,33 @@
-"""FastAPI app entrypoint for the SupportDesk environment."""
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+"""
+FastAPI application for the SupportDesk environment.
+
+This module creates an HTTP server that exposes the SupportDeskEnvironment
+over HTTP and WebSocket endpoints, compatible with EnvClient.
+
+Endpoints:
+    - POST /reset: Reset the environment
+    - POST /step: Execute an action
+    - GET /state: Get current environment state
+    - GET /schema: Get action/observation schemas
+    - WS /ws: WebSocket endpoint for persistent sessions
+    - GET /tasks: Get task catalog metadata
+
+Usage:
+    # Development (with auto-reload):
+    uvicorn supportdesk_env.server.app:app --reload --host 0.0.0.0 --port 8000
+
+    # Production:
+    uvicorn supportdesk_env.server.app:app --host 0.0.0.0 --port 8000 --workers 4
+
+    # Or run directly:
+    python -m supportdesk_env.server.app
+"""
 
 from __future__ import annotations
 
@@ -16,14 +45,17 @@ from supportdesk_env.models import SupportDeskAction, SupportDeskObservation, Su
 from supportdesk_env.server.supportdesk_environment import SupportDeskEnvironment
 from supportdesk_env.tasks import TASKS
 
+# Bind the default OpenEnv /state route to the full typed state model.
 openenv_http_server.State = SupportDeskState
 create_app = openenv_http_server.create_app
 
+# Create the app with web interface and README integration.
 app = create_app(
     SupportDeskEnvironment,
-    action_cls=SupportDeskAction,
-    observation_cls=SupportDeskObservation,
+    SupportDeskAction,
+    SupportDeskObservation,
     env_name="supportdesk_env",
+    max_concurrent_envs=1,  # increase this number to allow more concurrent WebSocket sessions
 )
 
 
@@ -61,12 +93,32 @@ def list_tasks() -> dict[str, Any]:
     }
 
 
-def main() -> None:
-    """Run the local HTTP server."""
+def main(host: str = "0.0.0.0", port: int = 8000) -> None:
+    """
+    Entry point for direct execution via uv run or python -m.
+
+    This function enables running the server without Docker:
+        uv run --project . server
+        uv run --project . server --port 8001
+        python -m supportdesk_env.server.app
+
+    Args:
+        host: Host address to bind to (default: "0.0.0.0")
+        port: Port number to listen on (default: 8000)
 
-    port = int(os.getenv("PORT", "8000"))
-    uvicorn.run("supportdesk_env.server.app:app", host="0.0.0.0", port=port)
+    For production deployments, consider using uvicorn directly with
+    multiple workers:
+        uvicorn supportdesk_env.server.app:app --workers 4
+    """
+
+    uvicorn.run("supportdesk_env.server.app:app", host=host, port=port)
 
 
 if __name__ == "__main__":
-    main()
+    import argparse
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--host", default=os.getenv("HOST", "0.0.0.0"))
+    parser.add_argument("--port", type=int, default=int(os.getenv("PORT", "8000")))
+    args = parser.parse_args()
+    main(host=args.host, port=args.port)

supportdesk_env/server/supportdesk_environment.py

@@ -10,6 +10,7 @@ from pathlib import Path
 from supportdesk_env.graders import grade_case
 from supportdesk_env.models import (
     ActionHistoryEntry,
+    CustomerFollowUp,
     SupportCaseProgress,
     SupportDeskAction,
     SupportDeskObservation,
@@ -43,10 +44,14 @@ class SupportDeskEnvironment(
     _shared_episode_id: str | None = None
     _shared_score = 0.0
     _shared_completed_milestones: list[str] = []
+    _shared_current_sla_minutes_remaining: int | None = None
+    _shared_reset_counter = 0
 
     def __init__(self, task_id: str | None = None):
         super().__init__()
-        requested_task = task_id or os.getenv("SUPPORTDESK_TASK_ID") or list_task_ids()[0]
+        env_task_id = os.getenv("SUPPORTDESK_TASK_ID")
+        self._explicit_task_id = task_id is not None or env_task_id is not None
+        requested_task = task_id or env_task_id or list_task_ids()[0]
         self.task: SupportTaskSpec = get_task(requested_task)
         self._max_steps = self.task.max_steps
         self._step_count = 0
@@ -56,6 +61,7 @@ class SupportDeskEnvironment(
         self._history: list[ActionHistoryEntry] = []
         self._case = SupportCaseProgress()
         self._episode_id: str | None = None
+        self._current_sla_minutes_remaining = self.task.ticket.sla_minutes_remaining
         initial_grade = grade_case(self.task, self._case)
         self._score = initial_grade.total_score
         self._completed_milestones = list(initial_grade.completed_milestones)
@@ -82,6 +88,7 @@ class SupportDeskEnvironment(
         cls._shared_episode_id = episode_id
         cls._shared_score = initial_grade.total_score
         cls._shared_completed_milestones = list(initial_grade.completed_milestones)
+        cls._shared_current_sla_minutes_remaining = task.ticket.sla_minutes_remaining
 
     @classmethod
     def _ensure_shared_state(cls, task: SupportTaskSpec) -> None:
@@ -102,6 +109,7 @@ class SupportDeskEnvironment(
         self._episode_id = self.__class__._shared_episode_id
         self._score = self.__class__._shared_score
         self._completed_milestones = list(self.__class__._shared_completed_milestones)
+        self._current_sla_minutes_remaining = self.__class__._shared_current_sla_minutes_remaining
 
     def _sync_to_shared(self) -> None:
         self.__class__._shared_task_id = self.task.task_id
@@ -114,6 +122,7 @@ class SupportDeskEnvironment(
         self.__class__._shared_episode_id = self._episode_id
         self.__class__._shared_score = self._score
         self.__class__._shared_completed_milestones = list(self._completed_milestones)
+        self.__class__._shared_current_sla_minutes_remaining = self._current_sla_minutes_remaining
 
     @property
     def state(self) -> SupportDeskState:
@@ -129,6 +138,10 @@ class SupportDeskEnvironment(
                 current_score=round(self._score, 4),
                 max_steps=self._max_steps,
                 case=self._case.model_copy(deep=True),
+                current_sla_minutes_remaining=self._current_sla_minutes_remaining,
+                workflow_stage=self._workflow_stage(),
+                required_next_actions=self._required_next_actions(),
+                risk_flags=self._risk_flags(),
                 action_history=[entry.model_copy(deep=True) for entry in self._history],
                 completed_milestones=list(self._completed_milestones),
                 last_feedback=self._last_feedback,
@@ -141,6 +154,12 @@ class SupportDeskEnvironment(
         **kwargs,
     ) -> SupportDeskObservation:
         with self.__class__._state_lock:
+            if not self._explicit_task_id:
+                task_ids = list_task_ids()
+                next_task_id = task_ids[self.__class__._shared_reset_counter % len(task_ids)]
+                self.__class__._shared_reset_counter += 1
+                self.task = get_task(next_task_id)
+                self._max_steps = self.task.max_steps
             self.__class__._initialize_shared_state(
                 self.task,
                 episode_id=episode_id or f"{self.task.task_id}-{uuid.uuid4().hex[:8]}",
@@ -165,11 +184,15 @@ class SupportDeskEnvironment(
                 )
 
             previous_grade = grade_case(self.task, self._case)
+            previous_stage = self._workflow_stage()
             self._apply_action(action)
             self._step_count += 1
+            self._advance_external_events(action)
+            self._degrade_sla()
 
             current_grade = grade_case(self.task, self._case)
             reward = current_grade.total_score - previous_grade.total_score
+            reward += self._process_bonus(action, previous_stage, current_grade.total_score)
             reward += self._action_penalty(
                 action,
                 current_grade.total_score,
@@ -219,8 +242,8 @@ class SupportDeskEnvironment(
         return EnvironmentMetadata(
             name="supportdesk_env",
             description=(
-                "A policy-heavy enterprise support operations environment with deterministic "
-                "grading, dense rewards, SLA pressure, and escalating ticket difficulty."
+                "A policy-heavy enterprise operations desk with deterministic grading, delayed "
+                "customer follow-ups, SLA pressure, escalation tradeoffs, and sharper cross-functional triage."
             ),
             readme_content=readme_content,
             version="0.1.0",
@@ -228,24 +251,56 @@ class SupportDeskEnvironment(
         )
 
     def _apply_action(self, action: SupportDeskAction) -> None:
-        if action.queue is not None:
-            self._case.queue = action.queue
-        if action.priority is not None:
-            self._case.priority = action.priority
-        if action.issue_type is not None:
-            self._case.issue_type = action.issue_type
-        if action.status is not None:
-            self._case.status = action.status
-        if action.resolution_code is not None:
-            self._case.resolution_code = action.resolution_code
-        if action.reply is not None:
-            self._case.reply = action.reply
-        if action.internal_note is not None:
-            self._case.internal_note = action.internal_note
-        if action.requested_fields:
-            merged = {item for item in self._case.requested_fields}
-            merged.update(action.requested_fields)
-            self._case.requested_fields = sorted(merged)
+        if action.operation == "classify":
+            if action.queue is not None:
+                self._case.queue = action.queue
+            if action.priority is not None:
+                self._case.priority = action.priority
+            if action.issue_type is not None:
+                self._case.issue_type = action.issue_type
+            return
+
+        if action.operation == "request_info":
+            if action.requested_fields:
+                merged = {item for item in self._case.requested_fields}
+                merged.update(action.requested_fields)
+                self._case.requested_fields = sorted(merged)
+                if self.task.follow_up_outcome != "none" and self._case.customer_follow_up.status == "none":
+                    self._case.customer_follow_up = CustomerFollowUp(status="pending")
+            return
+
+        if action.operation == "draft_reply":
+            if action.reply is not None:
+                self._case.reply = action.reply
+            return
+
+        if action.operation == "add_internal_note":
+            if action.internal_note is not None:
+                self._case.internal_note = action.internal_note
+            return
+
+        if action.operation == "submit":
+            if action.status is not None:
+                self._case.status = action.status
+            if action.resolution_code is not None:
+                self._case.resolution_code = action.resolution_code
+
+    def _advance_external_events(self, action: SupportDeskAction) -> None:
+        if self._case.customer_follow_up.status == "pending" and action.operation == "wait":
+            self._case.customer_follow_up = CustomerFollowUp(
+                status=self.task.follow_up_outcome,
+                message=self.task.follow_up_message or None,
+                provided_fields=list(self.task.follow_up_provided_fields),
+                wrong_fields=list(self.task.follow_up_wrong_fields),
+            )
+
+    def _degrade_sla(self) -> None:
+        if self._current_sla_minutes_remaining is None:
+            return
+        self._current_sla_minutes_remaining = max(
+            0,
+            self._current_sla_minutes_remaining - self.task.sla_step_cost,
+        )
 
     def _action_penalty(
         self,
@@ -256,6 +311,8 @@ class SupportDeskEnvironment(
         penalty = 0.0
         if current_score <= previous_score:
             penalty -= 0.03
+        penalty -= self._mixed_action_penalty(action)
+        penalty -= self._escalation_tradeoff_penalty()
         if action.operation == "draft_reply" and not action.reply:
             penalty -= 0.03
         if action.operation == "request_info" and not action.requested_fields:
@@ -266,11 +323,27 @@ class SupportDeskEnvironment(
             [action.queue, action.priority, action.issue_type, action.status, action.resolution_code]
         ):
             penalty -= 0.03
+        if action.operation == "wait" and self._case.customer_follow_up.status != "pending":
+            penalty -= 0.02
+        if action.operation == "submit" and self._required_next_actions():
+            penalty -= 0.08
+        if (
+            self.task.under_escalation_deadline_step is not None
+            and self._step_count >= self.task.under_escalation_deadline_step
+            and (self._case.queue != self.task.gold_queue or self._case.priority != self.task.gold_priority)
+        ):
+            penalty -= 0.04
+        if self._current_sla_minutes_remaining is not None and self._current_sla_minutes_remaining <= 15:
+            penalty -= 0.02
         return round(penalty, 4)
 
     def _build_feedback(self, grade, reward: float) -> str:
         return (
             f"Reward delta {reward:+.2f}. Current score {grade.total_score:.2f}. "
+            f"SLA remaining: {self._current_sla_minutes_remaining if self._current_sla_minutes_remaining is not None else 'n/a'} minutes. "
+            f"Stage: {self._workflow_stage()}. "
+            f"Customer follow-up: {self._case.customer_follow_up.status}. "
+            f"Next actions: {', '.join(self._required_next_actions()) or 'none'}. "
             f"Completed milestones: {', '.join(grade.completed_milestones) or 'none yet'}."
         )
 
@@ -311,9 +384,135 @@ class SupportDeskEnvironment(
             available_statuses=list(ALL_STATUSES),
             available_issue_types=list(ALL_ISSUE_TYPES),
             case=self._case.model_copy(deep=True),
+            current_sla_minutes_remaining=self._current_sla_minutes_remaining,
+            workflow_stage=self._workflow_stage(),
+            required_next_actions=self._required_next_actions(),
+            risk_flags=self._risk_flags(),
             action_history=[entry.model_copy(deep=True) for entry in self._history],
             feedback=feedback or self._last_feedback,
             remaining_steps=max(self._max_steps - self._step_count, 0),
             reward=reward,
             done=done,
         )
+
+    def _workflow_stage(self) -> str:
+        if self._done:
+            return "closed"
+        if self._case.queue is None or self._case.priority is None or self._case.issue_type is None:
+            return "intake"
+        if self.task.required_requested_fields and sorted(self._case.requested_fields) != sorted(self.task.required_requested_fields):
+            return "verification"
+        if self._case.customer_follow_up.status == "pending":
+            return "awaiting_customer"
+        if self._case.customer_follow_up.status in {"partial", "incorrect"}:
+            return "follow_up_review"
+        if not self._case.reply:
+            return "customer_communication"
+        if not self._case.internal_note:
+            return "internal_handoff"
+        if self._case.status != self.task.gold_status or self._case.resolution_code != self.task.gold_resolution_code:
+            return "final_resolution"
+        return "ready_to_submit"
+
+    def _required_next_actions(self) -> list[str]:
+        if self._case.queue is None or self._case.priority is None or self._case.issue_type is None:
+            return ["classify"]
+        if self.task.required_requested_fields and sorted(self._case.requested_fields) != sorted(self.task.required_requested_fields):
+            return ["request_info"]
+        if self._case.customer_follow_up.status == "pending":
+            return ["wait"]
+        needed: list[str] = []
+        if not self._case.reply:
+            needed.append("draft_reply")
+        if not self._case.internal_note:
+            needed.append("add_internal_note")
+        if self._case.status != self.task.gold_status or self._case.resolution_code != self.task.gold_resolution_code:
+            needed.append("submit")
+        return needed
+
+    def _risk_flags(self) -> list[str]:
+        flags = list(self.task.risk_flags)
+        if self._current_sla_minutes_remaining is not None and self._current_sla_minutes_remaining <= 30:
+            flags.append("sla_breach_risk")
+        if self.task.ticket.affected_users and self.task.ticket.affected_users >= 1000:
+            flags.append("high_customer_impact")
+        if self.task.ticket.secondary_concerns:
+            flags.append("secondary_issue_present")
+        if self._case.customer_follow_up.status == "partial":
+            flags.append("customer_reply_incomplete")
+        if self._case.customer_follow_up.status == "incorrect":
+            flags.append("customer_reply_irrelevant")
+        return sorted(set(flags))
+
+    def _process_bonus(
+        self,
+        action: SupportDeskAction,
+        previous_stage: str,
+        current_score: float,
+    ) -> float:
+        bonus = 0.0
+        stage_rank = {
+            "intake": 0,
+            "verification": 1,
+            "awaiting_customer": 2,
+            "follow_up_review": 3,
+            "customer_communication": 4,
+            "internal_handoff": 5,
+            "final_resolution": 6,
+            "ready_to_submit": 7,
+            "closed": 8,
+        }
+        current_stage = self._workflow_stage()
+        if stage_rank.get(current_stage, 0) > stage_rank.get(previous_stage, 0):
+            bonus += 0.02
+        if action.operation == "classify" and self._step_count == 1:
+            if self._case.queue == self.task.gold_queue and self._case.priority == self.task.gold_priority:
+                bonus += 0.03
+        if action.operation == "request_info" and current_score > 0 and self.task.required_requested_fields:
+            bonus += 0.02
+        if action.operation == "wait" and self._case.customer_follow_up.status in {"partial", "complete", "incorrect"}:
+            bonus += 0.02
+        if action.operation == "submit" and not self._required_next_actions():
+            bonus += 0.03
+        if self._current_sla_minutes_remaining is not None and self._current_sla_minutes_remaining > 0:
+            if self.task.gold_priority == "urgent" and self._step_count <= 2 and self._case.queue == self.task.gold_queue:
+                bonus += 0.02
+        return round(bonus, 4)
+
+    def _mixed_action_penalty(self, action: SupportDeskAction) -> float:
+        allowed_fields = {
+            "classify": {"queue", "priority", "issue_type"},
+            "request_info": {"requested_fields"},
+            "draft_reply": {"reply"},
+            "add_internal_note": {"internal_note"},
+            "submit": {"status", "resolution_code"},
+            "wait": set(),
+        }
+        populated_fields = {
+            "queue": action.queue,
+            "priority": action.priority,
+            "issue_type": action.issue_type,
+            "status": action.status,
+            "resolution_code": action.resolution_code,
+            "requested_fields": action.requested_fields,
+            "reply": action.reply,
+            "internal_note": action.internal_note,
+        }
+        extras = 0
+        for field_name, value in populated_fields.items():
+            if field_name in allowed_fields[action.operation]:
+                continue
+            if value is None:
+                continue
+            if isinstance(value, list) and not value:
+                continue
+            if isinstance(value, str) and not value:
+                continue
+            extras += 1
+        return min(0.06, extras * 0.02)
+
+    def _escalation_tradeoff_penalty(self) -> float:
+        penalty = 0.0
+        if self._case.queue in self.task.over_escalation_queues and self._case.queue != self.task.gold_queue:
+            penalty += 0.06
+        return round(penalty, 4)

supportdesk_env/tasks.py

@@ -8,13 +8,20 @@ from typing import Literal
 from supportdesk_env.models import KnowledgeSnippet, SupportTicket
 
 
-ALL_QUEUES = ["billing_ops", "trust_and_safety", "platform_engineering", "general_support"]
+ALL_QUEUES = [
+    "billing_ops",
+    "trust_and_safety",
+    "platform_engineering",
+    "compliance_ops",
+    "general_support",
+]
 ALL_PRIORITIES = ["low", "normal", "high", "urgent"]
 ALL_STATUSES = ["new", "waiting_on_customer", "resolved", "escalated"]
 ALL_ISSUE_TYPES = [
     "duplicate_charge",
     "account_compromise",
     "production_incident",
+    "regulated_exception",
     "general_question",
 ]
 
@@ -38,6 +45,14 @@ class SupportTaskSpec:
     required_reply_markers: tuple[tuple[str, ...], ...]
     required_note_markers: tuple[tuple[str, ...], ...]
     forbidden_reply_markers: tuple[str, ...] = ()
+    risk_flags: tuple[str, ...] = ()
+    follow_up_outcome: Literal["none", "partial", "complete", "incorrect"] = "none"
+    follow_up_message: str = ""
+    follow_up_provided_fields: tuple[str, ...] = ()
+    follow_up_wrong_fields: tuple[str, ...] = ()
+    sla_step_cost: int = 15
+    over_escalation_queues: tuple[str, ...] = ()
+    under_escalation_deadline_step: int | None = None
     max_steps: int = 6
 
 
@@ -112,6 +127,10 @@ TASKS: dict[str, SupportTaskSpec] = {
             ("refund", "refund approved"),
         ),
         forbidden_reply_markers=("chargeback", "security team"),
+        risk_flags=("finance_close_risk", "avoid_unnecessary_back_and_forth"),
+        over_escalation_queues=("trust_and_safety", "platform_engineering", "compliance_ops"),
+        sla_step_cost=10,
+        max_steps=6,
     ),
     "account_takeover_medium": SupportTaskSpec(
         task_id="account_takeover_medium",
@@ -179,8 +198,18 @@ TASKS: dict[str, SupportTaskSpec] = {
         ),
         required_note_markers=(
             ("suspicious login", "strange login"),
-            ("locked out", "can’t get back", "cannot get back"),
+            ("locked out", "can't get back", "cannot get back"),
+        ),
+        risk_flags=("unsafe_unlock_request", "identity_verification_required"),
+        follow_up_outcome="partial",
+        follow_up_message=(
+            "Customer follow-up: workspace_id=ws_9021 and billing email confirmed, "
+            "but they could not provide the last successful login time yet."
         ),
+        follow_up_provided_fields=("workspace_id", "billing_email"),
+        sla_step_cost=18,
+        under_escalation_deadline_step=2,
+        max_steps=7,
     ),
     "api_incident_hard": SupportTaskSpec(
         task_id="api_incident_hard",
@@ -261,6 +290,101 @@ TASKS: dict[str, SupportTaskSpec] = {
             ("500", "http 500"),
             ("launch tonight", "tonight"),
         ),
+        risk_flags=("sev1_launch_risk", "secondary_issue_distraction", "engineering_escalation_required"),
+        follow_up_outcome="complete",
+        follow_up_message=(
+            "Customer follow-up: request_ids=req_991, req_998; UTC timestamps=2026-04-01T19:20Z, "
+            "2026-04-01T19:27Z; region=eu-west-1."
+        ),
+        follow_up_provided_fields=("request_ids", "timestamp_utc", "region"),
+        sla_step_cost=25,
+        under_escalation_deadline_step=2,
+        max_steps=8,
+    ),
+    "regulated_export_exception_hard": SupportTaskSpec(
+        task_id="regulated_export_exception_hard",
+        difficulty="hard",
+        title="Regulated export exception triage",
+        objective=(
+            "Handle a regulated export-access request where the customer wants a manual bypass. "
+            "The agent must avoid escalating to engineering just because an export error is mentioned, "
+            "route to compliance operations, request the right legal details, and keep the case open "
+            "until the required approvals are supplied."
+        ),
+        ticket=SupportTicket(
+            customer_name="Dr. Elena Kovacs",
+            customer_tier="enterprise",
+            company="NorthSea Clinics",
+            subject="Need urgent export unlock before audit review",
+            body=(
+                "Our audit team needs tonight's export package, but after enabling EU residency the "
+                "export workflow now shows a policy block. Can you temporarily disable the restriction "
+                "or give us a manual bypass just for this audit? We are under pressure and can share "
+                "screenshots if needed."
+            ),
+            region="eu-central-1",
+            affected_users=240,
+            sla_minutes_remaining=55,
+            business_impact="A regulated healthcare audit review may slip tonight if the export path remains blocked.",
+            secondary_concerns=[
+                "The customer suggests an engineering workaround, but legal approval is the real gating factor."
+            ],
+            attachments=["policy_block.png"],
+        ),
+        knowledge_base=(
+            KnowledgeSnippet(
+                article_id="CMP-401",
+                title="Export policy exceptions",
+                content=(
+                    "Requests to bypass region or export restrictions route to compliance_ops. "
+                    "Do not promise a manual engineering workaround before approvals are verified."
+                ),
+            ),
+            KnowledgeSnippet(
+                article_id="CMP-402",
+                title="Minimum legal details for export review",
+                content=(
+                    "Ask for the tenant_region, dpa_amendment_id, and legal_contact_email before "
+                    "compliance can review an export exception."
+                ),
+            ),
+            KnowledgeSnippet(
+                article_id="CMP-403",
+                title="Customer response rules for regulated exceptions",
+                content=(
+                    "Replies must explain that no temporary bypass can be granted yet, mention the "
+                    "compliance review, and request the required legal approval details."
+                ),
+            ),
+        ),
+        gold_queue="compliance_ops",
+        gold_priority="high",
+        gold_issue_type="regulated_exception",
+        gold_status="waiting_on_customer",
+        gold_resolution_code="legal_approval_required",
+        required_requested_fields=("tenant_region", "dpa_amendment_id", "legal_contact_email"),
+        required_reply_markers=(
+            ("no temporary bypass", "cannot provide a bypass", "can’t provide a bypass"),
+            ("compliance review", "compliance team"),
+            ("tenant_region", "tenant region"),
+            ("dpa_amendment_id", "dpa amendment", "amendment id"),
+        ),
+        required_note_markers=(
+            ("audit", "audit review"),
+            ("eu residency", "policy block"),
+            ("manual bypass", "workaround"),
+        ),
+        forbidden_reply_markers=("engineering workaround", "disable the restriction", "temporary unlock approved"),
+        risk_flags=("regulated_data_risk", "unsafe_shortcut_pressure", "over_escalation_risk"),
+        follow_up_outcome="incorrect",
+        follow_up_message=(
+            "Customer follow-up: sent a screenshot and export job ID, but did not include the DPA "
+            "amendment ID or legal contact."
+        ),
+        follow_up_wrong_fields=("screenshot", "job_id"),
+        sla_step_cost=16,
+        over_escalation_queues=("platform_engineering",),
+        max_steps=8,
     ),
 }
 

tests/test_supportdesk.py

@@ -18,6 +18,7 @@ def test_all_tasks_are_registered():
         "billing_refund_easy",
         "account_takeover_medium",
         "api_incident_hard",
+        "regulated_export_exception_hard",
     ]
 
 
@@ -25,6 +26,9 @@ def test_environment_reset_and_state():
     env = SupportDeskEnvironment(task_id="billing_refund_easy")
     observation = env.reset()
     assert observation.task_id == "billing_refund_easy"
+    assert observation.workflow_stage == "intake"
+    assert "classify" in observation.required_next_actions
+    assert observation.current_sla_minutes_remaining == 240
     assert env.state.step_count == 0
     assert env.state.current_score == 0.15
 
@@ -75,7 +79,7 @@ def test_max_steps_ends_episode():
 
 
 def test_grade_is_bounded_between_zero_and_one():
-    task = get_task("api_incident_hard")
+    task = get_task("regulated_export_exception_hard")
     env = SupportDeskEnvironment(task_id=task.task_id)
     env.reset()
     breakdown = grade_case(task, env.state.case)
@@ -86,6 +90,46 @@ def test_state_includes_episode_id_after_reset():
     env = SupportDeskEnvironment(task_id="billing_refund_easy")
     env.reset(episode_id="episode-123")
     assert env.state.episode_id == "episode-123"
+    assert env.state.workflow_stage == "intake"
+    assert "finance_close_risk" in env.state.risk_flags
+
+
+def test_premature_submit_gets_penalized():
+    env = SupportDeskEnvironment(task_id="api_incident_hard")
+    env.reset()
+    observation = env.step(
+        SupportDeskAction(
+            operation="submit",
+            status="resolved",
+            resolution_code="incident_opened",
+        )
+    )
+    assert observation.reward < 0
+    assert observation.done is True
+
+
+def test_follow_up_arrives_after_wait():
+    env = SupportDeskEnvironment(task_id="account_takeover_medium")
+    env.reset()
+    env.step(
+        SupportDeskAction(
+            operation="classify",
+            queue="trust_and_safety",
+            priority="urgent",
+            issue_type="account_compromise",
+        )
+    )
+    observation = env.step(
+        SupportDeskAction(
+            operation="request_info",
+            requested_fields=["workspace_id", "last_successful_login", "billing_email"],
+        )
+    )
+    assert observation.case.customer_follow_up.status == "pending"
+
+    observation = env.step(SupportDeskAction(operation="wait"))
+    assert observation.case.customer_follow_up.status == "partial"
+    assert "customer_reply_incomplete" in observation.risk_flags
 
 
 @pytest.mark.skipif(TestClient is None, reason="httpx is not installed for FastAPI TestClient")

uv.lock

@@ -475,6 +475,124 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" },
 ]
 
+[[package]]
+name = "coverage"
+version = "7.13.5"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/9d/e0/70553e3000e345daff267cec284ce4cbf3fc141b6da229ac52775b5428f1/coverage-7.13.5.tar.gz", hash = "sha256:c81f6515c4c40141f83f502b07bbfa5c240ba25bbe73da7b33f1e5b6120ff179", size = 915967, upload-time = "2026-03-17T10:33:18.341Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/69/33/e8c48488c29a73fd089f9d71f9653c1be7478f2ad6b5bc870db11a55d23d/coverage-7.13.5-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:e0723d2c96324561b9aa76fb982406e11d93cdb388a7a7da2b16e04719cf7ca5", size = 219255, upload-time = "2026-03-17T10:29:51.081Z" },
+    { url = "https://files.pythonhosted.org/packages/da/bd/b0ebe9f677d7f4b74a3e115eec7ddd4bcf892074963a00d91e8b164a6386/coverage-7.13.5-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:52f444e86475992506b32d4e5ca55c24fc88d73bcbda0e9745095b28ef4dc0cf", size = 219772, upload-time = "2026-03-17T10:29:52.867Z" },
+    { url = "https://files.pythonhosted.org/packages/48/cc/5cb9502f4e01972f54eedd48218bb203fe81e294be606a2bc93970208013/coverage-7.13.5-cp310-cp310-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:704de6328e3d612a8f6c07000a878ff38181ec3263d5a11da1db294fa6a9bdf8", size = 246532, upload-time = "2026-03-17T10:29:54.688Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/d8/3217636d86c7e7b12e126e4f30ef1581047da73140614523af7495ed5f2d/coverage-7.13.5-cp310-cp310-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:a1a6d79a14e1ec1832cabc833898636ad5f3754a678ef8bb4908515208bf84f4", size = 248333, upload-time = "2026-03-17T10:29:56.221Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/30/2002ac6729ba2d4357438e2ed3c447ad8562866c8c63fc16f6dfc33afe56/coverage-7.13.5-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:79060214983769c7ba3f0cee10b54c97609dca4d478fa1aa32b914480fd5738d", size = 250211, upload-time = "2026-03-17T10:29:57.938Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/85/552496626d6b9359eb0e2f86f920037c9cbfba09b24d914c6e1528155f7d/coverage-7.13.5-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:356e76b46783a98c2a2fe81ec79df4883a1e62895ea952968fb253c114e7f930", size = 252125, upload-time = "2026-03-17T10:29:59.388Z" },
+    { url = "https://files.pythonhosted.org/packages/44/21/40256eabdcbccdb6acf6b381b3016a154399a75fe39d406f790ae84d1f3c/coverage-7.13.5-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0cef0cdec915d11254a7f549c1170afecce708d30610c6abdded1f74e581666d", size = 247219, upload-time = "2026-03-17T10:30:01.199Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/e8/96e2a6c3f21a0ea77d7830b254a1542d0328acc8d7bdf6a284ba7e529f77/coverage-7.13.5-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:dc022073d063b25a402454e5712ef9e007113e3a676b96c5f29b2bda29352f40", size = 248248, upload-time = "2026-03-17T10:30:03.317Z" },
+    { url = "https://files.pythonhosted.org/packages/da/ba/8477f549e554827da390ec659f3c38e4b6d95470f4daafc2d8ff94eaa9c2/coverage-7.13.5-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:9b74db26dfea4f4e50d48a4602207cd1e78be33182bc9cbf22da94f332f99878", size = 246254, upload-time = "2026-03-17T10:30:04.832Z" },
+    { url = "https://files.pythonhosted.org/packages/55/59/bc22aef0e6aa179d5b1b001e8b3654785e9adf27ef24c93dc4228ebd5d68/coverage-7.13.5-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:ad146744ca4fd09b50c482650e3c1b1f4dfa1d4792e0a04a369c7f23336f0400", size = 250067, upload-time = "2026-03-17T10:30:06.535Z" },
+    { url = "https://files.pythonhosted.org/packages/de/1b/c6a023a160806a5137dca53468fd97530d6acad24a22003b1578a9c2e429/coverage-7.13.5-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:c555b48be1853fe3997c11c4bd521cdd9a9612352de01fa4508f16ec341e6fe0", size = 246521, upload-time = "2026-03-17T10:30:08.486Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/3f/3532c85a55aa2f899fa17c186f831cfa1aa434d88ff792a709636f64130e/coverage-7.13.5-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:7034b5c56a58ae5e85f23949d52c14aca2cfc6848a31764995b7de88f13a1ea0", size = 247126, upload-time = "2026-03-17T10:30:09.966Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/2e/b9d56af4a24ef45dfbcda88e06870cb7d57b2b0bfa3a888d79b4c8debd76/coverage-7.13.5-cp310-cp310-win32.whl", hash = "sha256:eb7fdf1ef130660e7415e0253a01a7d5a88c9c4d158bcf75cbbd922fd65a5b58", size = 221860, upload-time = "2026-03-17T10:30:11.393Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/cc/d938417e7a4d7f0433ad4edee8bb2acdc60dc7ac5af19e2a07a048ecbee3/coverage-7.13.5-cp310-cp310-win_amd64.whl", hash = "sha256:3e1bb5f6c78feeb1be3475789b14a0f0a5b47d505bfc7267126ccbd50289999e", size = 222788, upload-time = "2026-03-17T10:30:12.886Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/37/d24c8f8220ff07b839b2c043ea4903a33b0f455abe673ae3c03bbdb7f212/coverage-7.13.5-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:66a80c616f80181f4d643b0f9e709d97bcea413ecd9631e1dedc7401c8e6695d", size = 219381, upload-time = "2026-03-17T10:30:14.68Z" },
+    { url = "https://files.pythonhosted.org/packages/35/8b/cd129b0ca4afe886a6ce9d183c44d8301acbd4ef248622e7c49a23145605/coverage-7.13.5-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:145ede53ccbafb297c1c9287f788d1bc3efd6c900da23bf6931b09eafc931587", size = 219880, upload-time = "2026-03-17T10:30:16.231Z" },
+    { url = "https://files.pythonhosted.org/packages/55/2f/e0e5b237bffdb5d6c530ce87cc1d413a5b7d7dfd60fb067ad6d254c35c76/coverage-7.13.5-cp311-cp311-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:0672854dc733c342fa3e957e0605256d2bf5934feeac328da9e0b5449634a642", size = 250303, upload-time = "2026-03-17T10:30:17.748Z" },
+    { url = "https://files.pythonhosted.org/packages/92/be/b1afb692be85b947f3401375851484496134c5554e67e822c35f28bf2fbc/coverage-7.13.5-cp311-cp311-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:ec10e2a42b41c923c2209b846126c6582db5e43a33157e9870ba9fb70dc7854b", size = 252218, upload-time = "2026-03-17T10:30:19.804Z" },
+    { url = "https://files.pythonhosted.org/packages/da/69/2f47bb6fa1b8d1e3e5d0c4be8ccb4313c63d742476a619418f85740d597b/coverage-7.13.5-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:be3d4bbad9d4b037791794ddeedd7d64a56f5933a2c1373e18e9e568b9141686", size = 254326, upload-time = "2026-03-17T10:30:21.321Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/d0/79db81da58965bd29dabc8f4ad2a2af70611a57cba9d1ec006f072f30a54/coverage-7.13.5-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:4d2afbc5cc54d286bfb54541aa50b64cdb07a718227168c87b9e2fb8f25e1743", size = 256267, upload-time = "2026-03-17T10:30:23.094Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/32/d0d7cc8168f91ddab44c0ce4806b969df5f5fdfdbb568eaca2dbc2a04936/coverage-7.13.5-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:3ad050321264c49c2fa67bb599100456fc51d004b82534f379d16445da40fb75", size = 250430, upload-time = "2026-03-17T10:30:25.311Z" },
+    { url = "https://files.pythonhosted.org/packages/4d/06/a055311d891ddbe231cd69fdd20ea4be6e3603ffebddf8704b8ca8e10a3c/coverage-7.13.5-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:7300c8a6d13335b29bb76d7651c66af6bd8658517c43499f110ddc6717bfc209", size = 252017, upload-time = "2026-03-17T10:30:27.284Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/f6/d0fd2d21e29a657b5f77a2fe7082e1568158340dceb941954f776dce1b7b/coverage-7.13.5-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:eb07647a5738b89baab047f14edd18ded523de60f3b30e75c2acc826f79c839a", size = 250080, upload-time = "2026-03-17T10:30:29.481Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/ab/0d7fb2efc2e9a5eb7ddcc6e722f834a69b454b7e6e5888c3a8567ecffb31/coverage-7.13.5-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:9adb6688e3b53adffefd4a52d72cbd8b02602bfb8f74dcd862337182fd4d1a4e", size = 253843, upload-time = "2026-03-17T10:30:31.301Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/6f/7467b917bbf5408610178f62a49c0ed4377bb16c1657f689cc61470da8ce/coverage-7.13.5-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:7c8d4bc913dd70b93488d6c496c77f3aff5ea99a07e36a18f865bca55adef8bd", size = 249802, upload-time = "2026-03-17T10:30:33.358Z" },
+    { url = "https://files.pythonhosted.org/packages/75/2c/1172fb689df92135f5bfbbd69fc83017a76d24ea2e2f3a1154007e2fb9f8/coverage-7.13.5-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:0e3c426ffc4cd952f54ee9ffbdd10345709ecc78a3ecfd796a57236bfad0b9b8", size = 250707, upload-time = "2026-03-17T10:30:35.2Z" },
+    { url = "https://files.pythonhosted.org/packages/67/21/9ac389377380a07884e3b48ba7a620fcd9dbfaf1d40565facdc6b36ec9ef/coverage-7.13.5-cp311-cp311-win32.whl", hash = "sha256:259b69bb83ad9894c4b25be2528139eecba9a82646ebdda2d9db1ba28424a6bf", size = 221880, upload-time = "2026-03-17T10:30:36.775Z" },
+    { url = "https://files.pythonhosted.org/packages/af/7f/4cd8a92531253f9d7c1bbecd9fa1b472907fb54446ca768c59b531248dc5/coverage-7.13.5-cp311-cp311-win_amd64.whl", hash = "sha256:258354455f4e86e3e9d0d17571d522e13b4e1e19bf0f8596bcf9476d61e7d8a9", size = 222816, upload-time = "2026-03-17T10:30:38.891Z" },
+    { url = "https://files.pythonhosted.org/packages/12/a6/1d3f6155fb0010ca68eba7fe48ca6c9da7385058b77a95848710ecf189b1/coverage-7.13.5-cp311-cp311-win_arm64.whl", hash = "sha256:bff95879c33ec8da99fc9b6fe345ddb5be6414b41d6d1ad1c8f188d26f36e028", size = 221483, upload-time = "2026-03-17T10:30:40.463Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/c3/a396306ba7db865bf96fc1fb3b7fd29bcbf3d829df642e77b13555163cd6/coverage-7.13.5-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:460cf0114c5016fa841214ff5564aa4864f11948da9440bc97e21ad1f4ba1e01", size = 219554, upload-time = "2026-03-17T10:30:42.208Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/16/a68a19e5384e93f811dccc51034b1fd0b865841c390e3c931dcc4699e035/coverage-7.13.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:0e223ce4b4ed47f065bfb123687686512e37629be25cc63728557ae7db261422", size = 219908, upload-time = "2026-03-17T10:30:43.906Z" },
+    { url = "https://files.pythonhosted.org/packages/29/72/20b917c6793af3a5ceb7fb9c50033f3ec7865f2911a1416b34a7cfa0813b/coverage-7.13.5-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:6e3370441f4513c6252bf042b9c36d22491142385049243253c7e48398a15a9f", size = 251419, upload-time = "2026-03-17T10:30:45.545Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/49/cd14b789536ac6a4778c453c6a2338bc0a2fb60c5a5a41b4008328b9acc1/coverage-7.13.5-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:03ccc709a17a1de074fb1d11f217342fb0d2b1582ed544f554fc9fc3f07e95f5", size = 254159, upload-time = "2026-03-17T10:30:47.204Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/00/7b0edcfe64e2ed4c0340dac14a52ad0f4c9bd0b8b5e531af7d55b703db7c/coverage-7.13.5-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3f4818d065964db3c1c66dc0fbdac5ac692ecbc875555e13374fdbe7eedb4376", size = 255270, upload-time = "2026-03-17T10:30:48.812Z" },
+    { url = "https://files.pythonhosted.org/packages/93/89/7ffc4ba0f5d0a55c1e84ea7cee39c9fc06af7b170513d83fbf3bbefce280/coverage-7.13.5-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:012d5319e66e9d5a218834642d6c35d265515a62f01157a45bcc036ecf947256", size = 257538, upload-time = "2026-03-17T10:30:50.77Z" },
+    { url = "https://files.pythonhosted.org/packages/81/bd/73ddf85f93f7e6fa83e77ccecb6162d9415c79007b4bc124008a4995e4a7/coverage-7.13.5-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:8dd02af98971bdb956363e4827d34425cb3df19ee550ef92855b0acb9c7ce51c", size = 251821, upload-time = "2026-03-17T10:30:52.5Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/81/278aff4e8dec4926a0bcb9486320752811f543a3ce5b602cc7a29978d073/coverage-7.13.5-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:f08fd75c50a760c7eb068ae823777268daaf16a80b918fa58eea888f8e3919f5", size = 253191, upload-time = "2026-03-17T10:30:54.543Z" },
+    { url = "https://files.pythonhosted.org/packages/70/ee/fe1621488e2e0a58d7e94c4800f0d96f79671553488d401a612bebae324b/coverage-7.13.5-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:843ea8643cf967d1ac7e8ecd4bb00c99135adf4816c0c0593fdcc47b597fcf09", size = 251337, upload-time = "2026-03-17T10:30:56.663Z" },
+    { url = "https://files.pythonhosted.org/packages/37/a6/f79fb37aa104b562207cc23cb5711ab6793608e246cae1e93f26b2236ed9/coverage-7.13.5-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:9d44d7aa963820b1b971dbecd90bfe5fe8f81cff79787eb6cca15750bd2f79b9", size = 255404, upload-time = "2026-03-17T10:30:58.427Z" },
+    { url = "https://files.pythonhosted.org/packages/75/f0/ed15262a58ec81ce457ceb717b7f78752a1713556b19081b76e90896e8d4/coverage-7.13.5-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:7132bed4bd7b836200c591410ae7d97bf7ae8be6fc87d160b2bd881df929e7bf", size = 250903, upload-time = "2026-03-17T10:31:00.093Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/e9/9129958f20e7e9d4d56d51d42ccf708d15cac355ff4ac6e736e97a9393d2/coverage-7.13.5-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:a698e363641b98843c517817db75373c83254781426e94ada3197cabbc2c919c", size = 252780, upload-time = "2026-03-17T10:31:01.916Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/d7/0ad9b15812d81272db94379fe4c6df8fd17781cc7671fdfa30c76ba5ff7b/coverage-7.13.5-cp312-cp312-win32.whl", hash = "sha256:bdba0a6b8812e8c7df002d908a9a2ea3c36e92611b5708633c50869e6d922fdf", size = 222093, upload-time = "2026-03-17T10:31:03.642Z" },
+    { url = "https://files.pythonhosted.org/packages/29/3d/821a9a5799fac2556bcf0bd37a70d1d11fa9e49784b6d22e92e8b2f85f18/coverage-7.13.5-cp312-cp312-win_amd64.whl", hash = "sha256:d2c87e0c473a10bffe991502eac389220533024c8082ec1ce849f4218dded810", size = 222900, upload-time = "2026-03-17T10:31:05.651Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/fa/2238c2ad08e35cf4f020ea721f717e09ec3152aea75d191a7faf3ef009a8/coverage-7.13.5-cp312-cp312-win_arm64.whl", hash = "sha256:bf69236a9a81bdca3bff53796237aab096cdbf8d78a66ad61e992d9dac7eb2de", size = 221515, upload-time = "2026-03-17T10:31:07.293Z" },
+    { url = "https://files.pythonhosted.org/packages/74/8c/74fedc9663dcf168b0a059d4ea756ecae4da77a489048f94b5f512a8d0b3/coverage-7.13.5-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:5ec4af212df513e399cf11610cc27063f1586419e814755ab362e50a85ea69c1", size = 219576, upload-time = "2026-03-17T10:31:09.045Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/c9/44fb661c55062f0818a6ffd2685c67aa30816200d5f2817543717d4b92eb/coverage-7.13.5-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:941617e518602e2d64942c88ec8499f7fbd49d3f6c4327d3a71d43a1973032f3", size = 219942, upload-time = "2026-03-17T10:31:10.708Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/13/93419671cee82b780bab7ea96b67c8ef448f5f295f36bf5031154ec9a790/coverage-7.13.5-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:da305e9937617ee95c2e39d8ff9f040e0487cbf1ac174f777ed5eddd7a7c1f26", size = 250935, upload-time = "2026-03-17T10:31:12.392Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/68/1666e3a4462f8202d836920114fa7a5ee9275d1fa45366d336c551a162dd/coverage-7.13.5-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:78e696e1cc714e57e8b25760b33a8b1026b7048d270140d25dafe1b0a1ee05a3", size = 253541, upload-time = "2026-03-17T10:31:14.247Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/5e/3ee3b835647be646dcf3c65a7c6c18f87c27326a858f72ab22c12730773d/coverage-7.13.5-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:02ca0eed225b2ff301c474aeeeae27d26e2537942aa0f87491d3e147e784a82b", size = 254780, upload-time = "2026-03-17T10:31:16.193Z" },
+    { url = "https://files.pythonhosted.org/packages/44/b3/cb5bd1a04cfcc49ede6cd8409d80bee17661167686741e041abc7ee1b9a9/coverage-7.13.5-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:04690832cbea4e4663d9149e05dba142546ca05cb1848816760e7f58285c970a", size = 256912, upload-time = "2026-03-17T10:31:17.89Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/66/c1dceb7b9714473800b075f5c8a84f4588f887a90eb8645282031676e242/coverage-7.13.5-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0590e44dd2745c696a778f7bab6aa95256de2cbc8b8cff4f7db8ff09813d6969", size = 251165, upload-time = "2026-03-17T10:31:19.605Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/62/5502b73b97aa2e53ea22a39cf8649ff44827bef76d90bf638777daa27a9d/coverage-7.13.5-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:d7cfad2d6d81dd298ab6b89fe72c3b7b05ec7544bdda3b707ddaecff8d25c161", size = 252908, upload-time = "2026-03-17T10:31:21.312Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/37/7792c2d69854397ca77a55c4646e5897c467928b0e27f2d235d83b5d08c6/coverage-7.13.5-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:e092b9499de38ae0fbfbc603a74660eb6ff3e869e507b50d85a13b6db9863e15", size = 250873, upload-time = "2026-03-17T10:31:23.565Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/23/bc866fb6163be52a8a9e5d708ba0d3b1283c12158cefca0a8bbb6e247a43/coverage-7.13.5-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:48c39bc4a04d983a54a705a6389512883d4a3b9862991b3617d547940e9f52b1", size = 255030, upload-time = "2026-03-17T10:31:25.58Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/8b/ef67e1c222ef49860701d346b8bbb70881bef283bd5f6cbba68a39a086c7/coverage-7.13.5-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:2d3807015f138ffea1ed9afeeb8624fd781703f2858b62a8dd8da5a0994c57b6", size = 250694, upload-time = "2026-03-17T10:31:27.316Z" },
+    { url = "https://files.pythonhosted.org/packages/46/0d/866d1f74f0acddbb906db212e096dee77a8e2158ca5e6bb44729f9d93298/coverage-7.13.5-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:ee2aa19e03161671ec964004fb74b2257805d9710bf14a5c704558b9d8dbaf17", size = 252469, upload-time = "2026-03-17T10:31:29.472Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/f5/be742fec31118f02ce42b21c6af187ad6a344fed546b56ca60caacc6a9a0/coverage-7.13.5-cp313-cp313-win32.whl", hash = "sha256:ce1998c0483007608c8382f4ff50164bfc5bd07a2246dd272aa4043b75e61e85", size = 222112, upload-time = "2026-03-17T10:31:31.526Z" },
+    { url = "https://files.pythonhosted.org/packages/66/40/7732d648ab9d069a46e686043241f01206348e2bbf128daea85be4d6414b/coverage-7.13.5-cp313-cp313-win_amd64.whl", hash = "sha256:631efb83f01569670a5e866ceb80fe483e7c159fac6f167e6571522636104a0b", size = 222923, upload-time = "2026-03-17T10:31:33.633Z" },
+    { url = "https://files.pythonhosted.org/packages/48/af/fea819c12a095781f6ccd504890aaddaf88b8fab263c4940e82c7b770124/coverage-7.13.5-cp313-cp313-win_arm64.whl", hash = "sha256:f4cd16206ad171cbc2470dbea9103cf9a7607d5fe8c242fdf1edf36174020664", size = 221540, upload-time = "2026-03-17T10:31:35.445Z" },
+    { url = "https://files.pythonhosted.org/packages/23/d2/17879af479df7fbbd44bd528a31692a48f6b25055d16482fdf5cdb633805/coverage-7.13.5-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:0428cbef5783ad91fe240f673cc1f76b25e74bbfe1a13115e4aa30d3f538162d", size = 220262, upload-time = "2026-03-17T10:31:37.184Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/4c/d20e554f988c8f91d6a02c5118f9abbbf73a8768a3048cb4962230d5743f/coverage-7.13.5-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:e0b216a19534b2427cc201a26c25da4a48633f29a487c61258643e89d28200c0", size = 220617, upload-time = "2026-03-17T10:31:39.245Z" },
+    { url = "https://files.pythonhosted.org/packages/29/9c/f9f5277b95184f764b24e7231e166dfdb5780a46d408a2ac665969416d61/coverage-7.13.5-cp313-cp313t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:972a9cd27894afe4bc2b1480107054e062df08e671df7c2f18c205e805ccd806", size = 261912, upload-time = "2026-03-17T10:31:41.324Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/f6/7f1ab39393eeb50cfe4747ae8ef0e4fc564b989225aa1152e13a180d74f8/coverage-7.13.5-cp313-cp313t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:4b59148601efcd2bac8c4dbf1f0ad6391693ccf7a74b8205781751637076aee3", size = 263987, upload-time = "2026-03-17T10:31:43.724Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/d7/62c084fb489ed9c6fbdf57e006752e7c516ea46fd690e5ed8b8617c7d52e/coverage-7.13.5-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:505d7083c8b0c87a8fa8c07370c285847c1f77739b22e299ad75a6af6c32c5c9", size = 266416, upload-time = "2026-03-17T10:31:45.769Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/f6/df63d8660e1a0bff6125947afda112a0502736f470d62ca68b288ea762d8/coverage-7.13.5-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:60365289c3741e4db327e7baff2a4aaacf22f788e80fa4683393891b70a89fbd", size = 267558, upload-time = "2026-03-17T10:31:48.293Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/02/353ca81d36779bd108f6d384425f7139ac3c58c750dcfaafe5d0bee6436b/coverage-7.13.5-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:1b88c69c8ef5d4b6fe7dea66d6636056a0f6a7527c440e890cf9259011f5e606", size = 261163, upload-time = "2026-03-17T10:31:50.125Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/16/2e79106d5749bcaf3aee6d309123548e3276517cd7851faa8da213bc61bf/coverage-7.13.5-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:5b13955d31d1633cf9376908089b7cebe7d15ddad7aeaabcbe969a595a97e95e", size = 263981, upload-time = "2026-03-17T10:31:51.961Z" },
+    { url = "https://files.pythonhosted.org/packages/29/c7/c29e0c59ffa6942030ae6f50b88ae49988e7e8da06de7ecdbf49c6d4feae/coverage-7.13.5-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:f70c9ab2595c56f81a89620e22899eea8b212a4041bd728ac6f4a28bf5d3ddd0", size = 261604, upload-time = "2026-03-17T10:31:53.872Z" },
+    { url = "https://files.pythonhosted.org/packages/40/48/097cdc3db342f34006a308ab41c3a7c11c3f0d84750d340f45d88a782e00/coverage-7.13.5-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:084b84a8c63e8d6fc7e3931b316a9bcafca1458d753c539db82d31ed20091a87", size = 265321, upload-time = "2026-03-17T10:31:55.997Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/1f/4994af354689e14fd03a75f8ec85a9a68d94e0188bbdab3fc1516b55e512/coverage-7.13.5-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:ad14385487393e386e2ea988b09d62dd42c397662ac2dabc3832d71253eee479", size = 260502, upload-time = "2026-03-17T10:31:58.308Z" },
+    { url = "https://files.pythonhosted.org/packages/22/c6/9bb9ef55903e628033560885f5c31aa227e46878118b63ab15dc7ba87797/coverage-7.13.5-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:7f2c47b36fe7709a6e83bfadf4eefb90bd25fbe4014d715224c4316f808e59a2", size = 262688, upload-time = "2026-03-17T10:32:00.141Z" },
+    { url = "https://files.pythonhosted.org/packages/14/4f/f5df9007e50b15e53e01edea486814783a7f019893733d9e4d6caad75557/coverage-7.13.5-cp313-cp313t-win32.whl", hash = "sha256:67e9bc5449801fad0e5dff329499fb090ba4c5800b86805c80617b4e29809b2a", size = 222788, upload-time = "2026-03-17T10:32:02.246Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/98/aa7fccaa97d0f3192bec013c4e6fd6d294a6ed44b640e6bb61f479e00ed5/coverage-7.13.5-cp313-cp313t-win_amd64.whl", hash = "sha256:da86cdcf10d2519e10cabb8ac2de03da1bcb6e4853790b7fbd48523332e3a819", size = 223851, upload-time = "2026-03-17T10:32:04.416Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/8b/e5c469f7352651e5f013198e9e21f97510b23de957dd06a84071683b4b60/coverage-7.13.5-cp313-cp313t-win_arm64.whl", hash = "sha256:0ecf12ecb326fe2c339d93fc131816f3a7367d223db37817208905c89bded911", size = 222104, upload-time = "2026-03-17T10:32:06.65Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/77/39703f0d1d4b478bfd30191d3c14f53caf596fac00efb3f8f6ee23646439/coverage-7.13.5-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:fbabfaceaeb587e16f7008f7795cd80d20ec548dc7f94fbb0d4ec2e038ce563f", size = 219621, upload-time = "2026-03-17T10:32:08.589Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/3e/51dff36d99ae14639a133d9b164d63e628532e2974d8b1edb99dd1ebc733/coverage-7.13.5-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:9bb2a28101a443669a423b665939381084412b81c3f8c0fcfbac57f4e30b5b8e", size = 219953, upload-time = "2026-03-17T10:32:10.507Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/6c/1f1917b01eb647c2f2adc9962bd66c79eb978951cab61bdc1acab3290c07/coverage-7.13.5-cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:bd3a2fbc1c6cccb3c5106140d87cc6a8715110373ef42b63cf5aea29df8c217a", size = 250992, upload-time = "2026-03-17T10:32:12.41Z" },
+    { url = "https://files.pythonhosted.org/packages/22/e5/06b1f88f42a5a99df42ce61208bdec3bddb3d261412874280a19796fc09c/coverage-7.13.5-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:6c36ddb64ed9d7e496028d1d00dfec3e428e0aabf4006583bb1839958d280510", size = 253503, upload-time = "2026-03-17T10:32:14.449Z" },
+    { url = "https://files.pythonhosted.org/packages/80/28/2a148a51e5907e504fa7b85490277734e6771d8844ebcc48764a15e28155/coverage-7.13.5-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:380e8e9084d8eb38db3a9176a1a4f3c0082c3806fa0dc882d1d87abc3c789247", size = 254852, upload-time = "2026-03-17T10:32:16.56Z" },
+    { url = "https://files.pythonhosted.org/packages/61/77/50e8d3d85cc0b7ebe09f30f151d670e302c7ff4a1bf6243f71dd8b0981fa/coverage-7.13.5-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:e808af52a0513762df4d945ea164a24b37f2f518cbe97e03deaa0ee66139b4d6", size = 257161, upload-time = "2026-03-17T10:32:19.004Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/c4/b5fd1d4b7bf8d0e75d997afd3925c59ba629fc8616f1b3aae7605132e256/coverage-7.13.5-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:e301d30dd7e95ae068671d746ba8c34e945a82682e62918e41b2679acd2051a0", size = 251021, upload-time = "2026-03-17T10:32:21.344Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/66/6ea21f910e92d69ef0b1c3346ea5922a51bad4446c9126db2ae96ee24c4c/coverage-7.13.5-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:800bc829053c80d240a687ceeb927a94fd108bbdc68dfbe505d0d75ab578a882", size = 252858, upload-time = "2026-03-17T10:32:23.506Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/ea/879c83cb5d61aa2a35fb80e72715e92672daef8191b84911a643f533840c/coverage-7.13.5-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:0b67af5492adb31940ee418a5a655c28e48165da5afab8c7fa6fd72a142f8740", size = 250823, upload-time = "2026-03-17T10:32:25.516Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/fb/616d95d3adb88b9803b275580bdeee8bd1b69a886d057652521f83d7322f/coverage-7.13.5-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:c9136ff29c3a91e25b1d1552b5308e53a1e0653a23e53b6366d7c2dcbbaf8a16", size = 255099, upload-time = "2026-03-17T10:32:27.944Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/93/25e6917c90ec1c9a56b0b26f6cad6408e5f13bb6b35d484a0d75c9cf000d/coverage-7.13.5-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:cff784eef7f0b8f6cb28804fbddcfa99f89efe4cc35fb5627e3ac58f91ed3ac0", size = 250638, upload-time = "2026-03-17T10:32:29.914Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/7b/dc1776b0464145a929deed214aef9fb1493f159b59ff3c7eeeedf91eddd0/coverage-7.13.5-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:68a4953be99b17ac3c23b6efbc8a38330d99680c9458927491d18700ef23ded0", size = 252295, upload-time = "2026-03-17T10:32:31.981Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/fb/99cbbc56a26e07762a2740713f3c8f9f3f3106e3a3dd8cc4474954bccd34/coverage-7.13.5-cp314-cp314-win32.whl", hash = "sha256:35a31f2b1578185fbe6aa2e74cea1b1d0bbf4c552774247d9160d29b80ed56cc", size = 222360, upload-time = "2026-03-17T10:32:34.233Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/b7/4758d4f73fb536347cc5e4ad63662f9d60ba9118cb6785e9616b2ce5d7fa/coverage-7.13.5-cp314-cp314-win_amd64.whl", hash = "sha256:2aa055ae1857258f9e0045be26a6d62bdb47a72448b62d7b55f4820f361a2633", size = 223174, upload-time = "2026-03-17T10:32:36.369Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/f2/24d84e1dfe70f8ac9fdf30d338239860d0d1d5da0bda528959d0ebc9da28/coverage-7.13.5-cp314-cp314-win_arm64.whl", hash = "sha256:1b11eef33edeae9d142f9b4358edb76273b3bfd30bc3df9a4f95d0e49caf94e8", size = 221739, upload-time = "2026-03-17T10:32:38.736Z" },
+    { url = "https://files.pythonhosted.org/packages/60/5b/4a168591057b3668c2428bff25dd3ebc21b629d666d90bcdfa0217940e84/coverage-7.13.5-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:10a0c37f0b646eaff7cce1874c31d1f1ccb297688d4c747291f4f4c70741cc8b", size = 220351, upload-time = "2026-03-17T10:32:41.196Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/21/1fd5c4dbfe4a58b6b99649125635df46decdfd4a784c3cd6d410d303e370/coverage-7.13.5-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:b5db73ba3c41c7008037fa731ad5459fc3944cb7452fc0aa9f822ad3533c583c", size = 220612, upload-time = "2026-03-17T10:32:43.204Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/fe/2a924b3055a5e7e4512655a9d4609781b0d62334fa0140c3e742926834e2/coverage-7.13.5-cp314-cp314t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:750db93a81e3e5a9831b534be7b1229df848b2e125a604fe6651e48aa070e5f9", size = 261985, upload-time = "2026-03-17T10:32:45.514Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/0d/c8928f2bd518c45990fe1a2ab8db42e914ef9b726c975facc4282578c3eb/coverage-7.13.5-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:9ddb4f4a5479f2539644be484da179b653273bca1a323947d48ab107b3ed1f29", size = 264107, upload-time = "2026-03-17T10:32:47.971Z" },
+    { url = "https://files.pythonhosted.org/packages/ef/ae/4ae35bbd9a0af9d820362751f0766582833c211224b38665c0f8de3d487f/coverage-7.13.5-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d8a7a2049c14f413163e2bdabd37e41179b1d1ccb10ffc6ccc4b7a718429c607", size = 266513, upload-time = "2026-03-17T10:32:50.1Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/20/d326174c55af36f74eac6ae781612d9492f060ce8244b570bb9d50d9d609/coverage-7.13.5-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:e1c85e0b6c05c592ea6d8768a66a254bfb3874b53774b12d4c89c481eb78cb90", size = 267650, upload-time = "2026-03-17T10:32:52.391Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/5e/31484d62cbd0eabd3412e30d74386ece4a0837d4f6c3040a653878bfc019/coverage-7.13.5-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:777c4d1eff1b67876139d24288aaf1817f6c03d6bae9c5cc8d27b83bcfe38fe3", size = 261089, upload-time = "2026-03-17T10:32:54.544Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/d8/49a72d6de146eebb0b7e48cc0f4bc2c0dd858e3d4790ab2b39a2872b62bd/coverage-7.13.5-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:6697e29b93707167687543480a40f0db8f356e86d9f67ddf2e37e2dfd91a9dab", size = 263982, upload-time = "2026-03-17T10:32:56.803Z" },
+    { url = "https://files.pythonhosted.org/packages/06/3b/0351f1bd566e6e4dd39e978efe7958bde1d32f879e85589de147654f57bb/coverage-7.13.5-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:8fdf453a942c3e4d99bd80088141c4c6960bb232c409d9c3558e2dbaa3998562", size = 261579, upload-time = "2026-03-17T10:32:59.466Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/ce/796a2a2f4017f554d7810f5c573449b35b1e46788424a548d4d19201b222/coverage-7.13.5-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:32ca0c0114c9834a43f045a87dcebd69d108d8ffb666957ea65aa132f50332e2", size = 265316, upload-time = "2026-03-17T10:33:01.847Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/16/d5ae91455541d1a78bc90abf495be600588aff8f6db5c8b0dae739fa39c9/coverage-7.13.5-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:8769751c10f339021e2638cd354e13adeac54004d1941119b2c96fe5276d45ea", size = 260427, upload-time = "2026-03-17T10:33:03.945Z" },
+    { url = "https://files.pythonhosted.org/packages/48/11/07f413dba62db21fb3fad5d0de013a50e073cc4e2dc4306e770360f6dfc8/coverage-7.13.5-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:cec2d83125531bd153175354055cdb7a09987af08a9430bd173c937c6d0fba2a", size = 262745, upload-time = "2026-03-17T10:33:06.285Z" },
+    { url = "https://files.pythonhosted.org/packages/91/15/d792371332eb4663115becf4bad47e047d16234b1aff687b1b18c58d60ae/coverage-7.13.5-cp314-cp314t-win32.whl", hash = "sha256:0cd9ed7a8b181775459296e402ca4fb27db1279740a24e93b3b41942ebe4b215", size = 223146, upload-time = "2026-03-17T10:33:08.756Z" },
+    { url = "https://files.pythonhosted.org/packages/db/51/37221f59a111dca5e85be7dbf09696323b5b9f13ff65e0641d535ed06ea8/coverage-7.13.5-cp314-cp314t-win_amd64.whl", hash = "sha256:301e3b7dfefecaca37c9f1aa6f0049b7d4ab8dd933742b607765d757aca77d43", size = 224254, upload-time = "2026-03-17T10:33:11.174Z" },
+    { url = "https://files.pythonhosted.org/packages/54/83/6acacc889de8987441aa7d5adfbdbf33d288dad28704a67e574f1df9bcbb/coverage-7.13.5-cp314-cp314t-win_arm64.whl", hash = "sha256:9dacc2ad679b292709e0f5fc1ac74a6d4d5562e424058962c7bb0c658ad25e45", size = 222276, upload-time = "2026-03-17T10:33:13.466Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/ee/a4cf96b8ce1e566ed238f0659ac2d3f007ed1d14b181bcb684e19561a69a/coverage-7.13.5-py3-none-any.whl", hash = "sha256:34b02417cf070e173989b3db962f7ed56d2f644307b2cf9d5a0f258e13084a61", size = 211346, upload-time = "2026-03-17T10:33:15.691Z" },
+]
+
+[package.optional-dependencies]
+toml = [
+    { name = "tomli", marker = "python_full_version <= '3.11'" },
+]
+
 [[package]]
 name = "cryptography"
 version = "46.0.6"
@@ -1471,6 +1589,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/2f/22/38c339e370d198008f2c17ebdda1ae8f23bb4e1509dc7ae8eab6dc9b9cbe/openenv_core-0.2.3-py3-none-any.whl", hash = "sha256:f75a20c94452057a5f53a86e6d71a9f6a461524c3d6a865aa9344d257a92b795", size = 174557, upload-time = "2026-03-28T18:56:26.874Z" },
 ]
 
+[package.optional-dependencies]
+core = [
+    { name = "fastapi" },
+    { name = "pydantic" },
+    { name = "requests" },
+    { name = "uvicorn" },
+    { name = "websockets" },
+]
+
 [[package]]
 name = "opentelemetry-api"
 version = "1.40.0"
@@ -2082,6 +2209,20 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/3b/ab/b3226f0bd7cdcf710fbede2b3548584366da3b19b5021e74f5bde2a8fa3f/pytest-9.0.2-py3-none-any.whl", hash = "sha256:711ffd45bf766d5264d487b917733b453d917afd2b0ad65223959f59089f875b", size = 374801, upload-time = "2025-12-06T21:30:49.154Z" },
 ]
 
+[[package]]
+name = "pytest-cov"
+version = "7.1.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "coverage", extra = ["toml"] },
+    { name = "pluggy" },
+    { name = "pytest" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/b1/51/a849f96e117386044471c8ec2bd6cfebacda285da9525c9106aeb28da671/pytest_cov-7.1.0.tar.gz", hash = "sha256:30674f2b5f6351aa09702a9c8c364f6a01c27aae0c1366ae8016160d1efc56b2", size = 55592, upload-time = "2026-03-21T20:11:16.284Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/9d/7a/d968e294073affff457b041c2be9868a40c1c71f4a35fcc1e45e5493067b/pytest_cov-7.1.0-py3-none-any.whl", hash = "sha256:a0461110b7865f9a271aa1b51e516c9a95de9d696734a2f71e3e78f46e1d4678", size = 22876, upload-time = "2026-03-21T20:11:14.438Z" },
+]
+
 [[package]]
 name = "python-dateutil"
 version = "2.9.0.post0"
@@ -2487,7 +2628,7 @@ source = { editable = "." }
 dependencies = [
     { name = "fastapi" },
     { name = "openai" },
-    { name = "openenv-core" },
+    { name = "openenv-core", extra = ["core"] },
     { name = "pydantic" },
     { name = "requests" },
     { name = "uvicorn" },
@@ -2496,15 +2637,17 @@ dependencies = [
 [package.optional-dependencies]
 dev = [
     { name = "pytest" },
+    { name = "pytest-cov" },
 ]
 
 [package.metadata]
 requires-dist = [
     { name = "fastapi", specifier = ">=0.115.0" },
     { name = "openai", specifier = ">=1.54.0" },
-    { name = "openenv-core", specifier = ">=0.2.0" },
+    { name = "openenv-core", extras = ["core"], specifier = ">=0.2.2" },
     { name = "pydantic", specifier = ">=2.9.0" },
-    { name = "pytest", marker = "extra == 'dev'", specifier = ">=8.3.0" },
+    { name = "pytest", marker = "extra == 'dev'", specifier = ">=8.0.0" },
+    { name = "pytest-cov", marker = "extra == 'dev'", specifier = ">=4.0.0" },
     { name = "requests", specifier = ">=2.32.0" },
     { name = "uvicorn", specifier = ">=0.30.0" },
 ]