Upload OpenEnv model release environment

.dockerignore

@@ -0,0 +1,8 @@
+__pycache__
+.git
+.venv
+.pytest_cache
+dist
+build
+outputs
+tests

.gitignore

@@ -0,0 +1,11 @@
+.venv/
+__pycache__/
+.pytest_cache/
+*.pyc
+*.egg-info/
+dist/
+build/
+outputs/logs/*
+outputs/evals/*
+!outputs/logs/.gitkeep
+!outputs/evals/.gitkeep

README.md

@@ -1,11 +1,113 @@
 ---
-title: Openenv Model Release Env
-emoji: 🌖
-colorFrom: pink
-colorTo: blue
+title: Model Release Env
 sdk: docker
-pinned: false
-license: apache-2.0
+app_port: 8000
+base_path: /web
+tags:
+  - openenv
+  - llm
+  - evaluation
+  - release
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Model Release Env
+
+Model Release Env is an OpenEnv environment for release-readiness decisions around LLM launches. The agent acts like a release engineer reviewing structured evidence, updating a release package, and making the correct launch decision under tight operational constraints.
+
+The current offline heuristic smoke baseline scores `1.00` on all three tasks, for an average score of `1.00`.
+
+## Why this is a real environment
+
+This is modeled on a real workflow used before shipping model checkpoints: confirm what can be published, align the release card with approved evidence, and block unsafe launches when compliance or safety signals fail. The environment is deterministic, fast to evaluate, and shaped for RL because every intermediate edit changes a measurable checklist score.
+
+## Tasks
+
+Three tasks are included.
+
+1. `card_completion_easy`: finish a draft release card with the correct model identity, evaluation summary, limitations, and release channel.
+2. `policy_alignment_medium`: align the package with licensing and serving-policy constraints.
+3. `launch_gate_hard`: detect a regression plus a critical safety issue and hold the launch.
+
+Each task exposes three evidence documents, a structured release package, and a small action space.
+
+## Action Space
+
+`inspect`: reveal one hidden evidence document.
+
+`set_field`: update one structured package field.
+
+`set_decision`: set the release channel to `public`, `beta`, or `hold`.
+
+`submit`: finish the episode and receive the final score.
+
+## Reward Design
+
+The score is a weighted checklist in `[0, 1]`.
+
+- First-time document inspection gives a small positive reward.
+- Editing a field that satisfies a previously unsatisfied checklist item gives positive reward equal to the score gain.
+- Invalid or non-improving edits incur a small penalty.
+- `submit` returns the final normalized score.
+
+This gives dense partial credit while keeping grading fully programmatic.
+
+## Project Layout
+
+- `models.py`: typed action, observation, and state contracts.
+- `client.py`: typed OpenEnv client.
+- `server/model_release_env_environment.py`: deterministic task logic and grading.
+- `server/app.py`: FastAPI/OpenEnv server entry point.
+- `inference.py`: baseline runner with OpenAI-client support and an offline heuristic fallback.
+
+## Local Development
+
+```bash
+uv sync
+uv run server
+```
+
+Open the local server at `http://localhost:8000/web`.
+
+## Docker
+
+```bash
+docker build -t model-release-env:latest -f server/Dockerfile .
+```
+
+## Baseline Runner
+
+The hackathon runner expects a root-level `inference.py`.
+
+```bash
+HF_TOKEN=hf_xxx uv run python inference.py
+```
+
+Relevant variables:
+
+- `API_BASE_URL` defaults to `https://router.huggingface.co/v1`
+- `MODEL_NAME` defaults to `Qwen/Qwen2.5-72B-Instruct`
+- `HF_TOKEN` is required for LLM-backed runs
+- `LOCAL_IMAGE_NAME` defaults to `model-release-env:latest`
+- `ENV_BASE_URL` can be used instead of Docker for a running server
+
+If `HF_TOKEN` is missing, `inference.py` uses a deterministic heuristic fallback so the project can still be smoke-tested offline.
+
+On machines with a polluted user-site Python installation, prefix local runs with `env -u PYTHONPATH` to prevent incompatible global packages from overriding the repo environment.
+
+## Example Client Usage
+
+```python
+from model_release_env import ModelReleaseAction, ModelReleaseEnv
+
+with ModelReleaseEnv(base_url="http://localhost:8000").sync() as env:
+    result = env.reset(task_name="card_completion_easy")
+    result = env.step(ModelReleaseAction(action_type="inspect", target="release_brief"))
+    print(result.observation.visible_documents)
+```
+
+## Validation Notes
+
+- The environment implements typed `Action`, `Observation`, and `State` models.
+- `reset`, `step`, and `state` follow the OpenEnv contract.
+- The baseline logs use the required `[START]`, `[STEP]`, and `[END]` markers.
+- The server responds to `/reset`, which is required by the submission validator.

__init__.py

@@ -0,0 +1,18 @@
+"""Model Release Environment for OpenEnv."""
+
+from .models import ModelReleaseAction, ModelReleaseObservation, ModelReleaseState
+
+__all__ = [
+    "ModelReleaseAction",
+    "ModelReleaseObservation",
+    "ModelReleaseState",
+    "ModelReleaseEnv",
+]
+
+
+def __getattr__(name: str):
+    if name == "ModelReleaseEnv":
+        from .client import ModelReleaseEnv
+
+        return ModelReleaseEnv
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

client.py

@@ -0,0 +1,44 @@
+"""Client for the Model Release environment."""
+
+from __future__ import annotations
+
+from typing import Any, Dict
+
+try:
+    from openenv.core.client_types import StepResult
+    from openenv.core.env_client import EnvClient
+
+    from .models import ModelReleaseAction, ModelReleaseObservation, ModelReleaseState
+except ImportError:
+    from openenv.core.client_types import StepResult
+    from openenv.core.env_client import EnvClient
+
+    from models import ModelReleaseAction, ModelReleaseObservation, ModelReleaseState
+
+
+class ModelReleaseEnv(
+    EnvClient[ModelReleaseAction, ModelReleaseObservation, ModelReleaseState]
+):
+    """Typed WebSocket client for deterministic LLM release workflows."""
+
+    def _step_payload(self, action: ModelReleaseAction) -> Dict[str, Any]:
+        return action.model_dump()
+
+    def _parse_result(self, payload: Dict[str, Any]) -> StepResult[ModelReleaseObservation]:
+        observation = ModelReleaseObservation(**payload.get("observation", {}))
+        return StepResult(
+            observation=observation,
+            reward=payload.get("reward"),
+            done=payload.get("done", False),
+        )
+
+    def _parse_state(self, payload: Dict[str, Any]) -> ModelReleaseState:
+        return ModelReleaseState(**payload)
+
+    async def reset(
+        self, task_name: str | None = None, **kwargs: Any
+    ) -> StepResult[ModelReleaseObservation]:
+        reset_kwargs = dict(kwargs)
+        if task_name is not None:
+            reset_kwargs["task_name"] = task_name
+        return await super().reset(**reset_kwargs)

inference.py

@@ -0,0 +1,259 @@
+"""Hackathon baseline runner for Model Release Env."""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import os
+import re
+import sys
+from typing import Any, Dict, List, Optional
+
+
+def _sanitize_sys_path() -> None:
+    current_tag = f"python{sys.version_info.major}.{sys.version_info.minor}"
+    sys.path[:] = [
+        entry
+        for entry in sys.path
+        if entry == "" or "/site-packages" not in entry or current_tag in entry
+    ]
+
+
+_sanitize_sys_path()
+
+from openai import OpenAI
+
+try:
+    from model_release_env import ModelReleaseAction, ModelReleaseEnv
+except ImportError:
+    from client import ModelReleaseEnv
+    from models import ModelReleaseAction
+
+
+API_BASE_URL = os.getenv("API_BASE_URL", "https://router.huggingface.co/v1")
+MODEL_NAME = os.getenv("MODEL_NAME", "Qwen/Qwen2.5-72B-Instruct")
+HF_TOKEN = os.getenv("HF_TOKEN")
+LOCAL_IMAGE_NAME = os.getenv("LOCAL_IMAGE_NAME", "model-release-env:latest")
+ENV_BASE_URL = os.getenv("ENV_BASE_URL")
+BENCHMARK = os.getenv("BENCHMARK_NAME", "model_release_env")
+MAX_STEPS = int(os.getenv("MODEL_RELEASE_MAX_STEPS", "8"))
+SUCCESS_THRESHOLD = float(os.getenv("MODEL_RELEASE_SUCCESS_THRESHOLD", "0.75"))
+
+DEFAULT_TASKS = [
+    "card_completion_easy",
+    "policy_alignment_medium",
+    "launch_gate_hard",
+]
+
+HEURISTIC_PLANS: Dict[str, List[Dict[str, str]]] = {
+    "card_completion_easy": [
+        {"action_type": "inspect", "target": "release_brief"},
+        {"action_type": "inspect", "target": "eval_sheet"},
+        {"action_type": "inspect", "target": "risk_note"},
+        {
+            "action_type": "set_field",
+            "target": "base_model",
+            "value": "Qwen2.5-7B-Instruct",
+        },
+        {
+            "action_type": "set_field",
+            "target": "eval_summary",
+            "value": "gsm8k=0.78; math500=0.61; aime24=0.18",
+        },
+        {
+            "action_type": "set_field",
+            "target": "limitations",
+            "value": "Fails on long derivations and is not approved for medical advice.",
+        },
+        {"action_type": "set_decision", "value": "beta"},
+        {"action_type": "submit"},
+    ],
+    "policy_alignment_medium": [
+        {"action_type": "inspect", "target": "license_audit"},
+        {"action_type": "inspect", "target": "safety_report"},
+        {"action_type": "inspect", "target": "policy_note"},
+        {
+            "action_type": "set_field",
+            "target": "license",
+            "value": "apache-2.0",
+        },
+        {
+            "action_type": "set_field",
+            "target": "safety_guardrails",
+            "value": "prompt_injection_filter; pii_redaction",
+        },
+        {
+            "action_type": "set_field",
+            "target": "blocked_use_cases",
+            "value": "legal advice; medical advice",
+        },
+        {"action_type": "set_decision", "value": "beta"},
+        {"action_type": "submit"},
+    ],
+    "launch_gate_hard": [
+        {"action_type": "inspect", "target": "regression_report"},
+        {"action_type": "inspect", "target": "red_team_note"},
+        {"action_type": "inspect", "target": "launch_policy"},
+        {
+            "action_type": "set_field",
+            "target": "known_regressions",
+            "value": "latency; throughput",
+        },
+        {
+            "action_type": "set_field",
+            "target": "launch_blockers",
+            "value": "chain-of-thought extraction bypass",
+        },
+        {
+            "action_type": "set_field",
+            "target": "public_summary",
+            "value": "release on hold pending latency and safety fixes.",
+        },
+        {"action_type": "set_decision", "value": "hold"},
+        {"action_type": "submit"},
+    ],
+}
+
+
+def _task_names() -> List[str]:
+    raw = os.getenv("MODEL_RELEASE_TASKS")
+    if not raw:
+        return list(DEFAULT_TASKS)
+    return [item.strip() for item in raw.split(",") if item.strip()]
+
+
+def _compact_action(action: ModelReleaseAction) -> str:
+    value = action.value.replace(" ", "_") if action.value else ""
+    if action.action_type == "inspect":
+        return f"inspect({action.target})"
+    if action.action_type == "set_field":
+        return f"set_field({action.target}={value})"
+    if action.action_type == "set_decision":
+        return f"set_decision({value})"
+    return "submit()"
+
+
+def _stderr(message: str) -> None:
+    print(message, file=sys.stderr)
+
+
+def _llm_client() -> Optional[OpenAI]:
+    if not HF_TOKEN:
+        return None
+    return OpenAI(base_url=API_BASE_URL, api_key=HF_TOKEN)
+
+
+def _extract_json_block(content: str) -> Dict[str, Any]:
+    match = re.search(r"\{.*\}", content, re.DOTALL)
+    if not match:
+        raise ValueError("No JSON object found in model response")
+    return json.loads(match.group(0))
+
+
+def _observation_prompt(observation: Any) -> str:
+    payload = {
+        "task_name": observation.task_name,
+        "goal": observation.goal,
+        "document_index": observation.document_index,
+        "visible_documents": observation.visible_documents,
+        "package_snapshot": observation.package_snapshot,
+        "checklist_status": observation.checklist_status,
+        "available_fields": observation.available_fields,
+        "available_decisions": observation.available_decisions,
+        "inspected_documents": observation.inspected_documents,
+        "remaining_steps": observation.remaining_steps,
+        "score": observation.score,
+        "last_action_error": observation.last_action_error,
+    }
+    return json.dumps(payload, indent=2, sort_keys=True)
+
+
+def _heuristic_action(task_name: str, step_index: int) -> ModelReleaseAction:
+    plan = HEURISTIC_PLANS[task_name]
+    if step_index >= len(plan):
+        return ModelReleaseAction(action_type="submit")
+    return ModelReleaseAction(**plan[step_index])
+
+
+def _model_action(
+    client: OpenAI,
+    task_name: str,
+    observation: Any,
+) -> ModelReleaseAction:
+    system_prompt = (
+        "You are operating an OpenEnv release-readiness environment. "
+        "Return exactly one JSON object with keys action_type, target, and value. "
+        "Allowed action_type values: inspect, set_field, set_decision, submit. "
+        "Use inspect before editing. Keep values compact and deterministic."
+    )
+    user_prompt = (
+        f"Task: {task_name}\n"
+        "Choose the single best next action given the observation below.\n"
+        "Observation JSON:\n"
+        f"{_observation_prompt(observation)}"
+    )
+    response = client.chat.completions.create(
+        model=MODEL_NAME,
+        temperature=0.0,
+        max_tokens=220,
+        messages=[
+            {"role": "system", "content": system_prompt},
+            {"role": "user", "content": user_prompt},
+        ],
+    )
+    content = response.choices[0].message.content or ""
+    return ModelReleaseAction(**_extract_json_block(content))
+
+
+async def _create_env() -> ModelReleaseEnv:
+    if ENV_BASE_URL:
+        return ModelReleaseEnv(base_url=ENV_BASE_URL)
+    return await ModelReleaseEnv.from_docker_image(LOCAL_IMAGE_NAME)
+
+
+async def _run_task(env: ModelReleaseEnv, task_name: str, llm: Optional[OpenAI]) -> float:
+    print(f"[START] benchmark={BENCHMARK} task={task_name}")
+    result = await env.reset(task_name=task_name)
+    step_index = 0
+
+    while not result.done and step_index < MAX_STEPS:
+        try:
+            if llm is None:
+                action = _heuristic_action(task_name, step_index)
+            else:
+                action = _model_action(llm, task_name, result.observation)
+        except Exception as exc:
+            _stderr(f"planner fallback for {task_name}: {exc}")
+            action = _heuristic_action(task_name, step_index)
+
+        result = await env.step(action)
+        error = result.observation.last_action_error or "null"
+        reward = 0.0 if result.reward is None else float(result.reward)
+        print(
+            f"[STEP] action={_compact_action(action)} reward={reward:.2f} "
+            f"done={str(result.done)} error={error}"
+        )
+        step_index += 1
+
+    score = float(result.observation.score)
+    success = score >= SUCCESS_THRESHOLD
+    print(f"[END] success={str(success)} score={score:.2f}")
+    return score
+
+
+async def main() -> int:
+    llm = _llm_client()
+    env = await _create_env()
+    scores: List[float] = []
+
+    async with env:
+        for task_name in _task_names():
+            scores.append(await _run_task(env, task_name, llm))
+
+    average_score = sum(scores) / len(scores) if scores else 0.0
+    _stderr(f"average_score={average_score:.2f}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(asyncio.run(main()))

models.py

@@ -0,0 +1,95 @@
+"""Typed models for the Model Release environment."""
+
+from __future__ import annotations
+
+from typing import Any, Dict, List, Literal, Optional
+
+from pydantic import Field
+
+try:
+    from openenv.core.env_server.types import Action, Observation, State
+except ImportError:
+    from openenv_core.env_server.types import Action, Observation, State
+
+ActionType = Literal["inspect", "set_field", "set_decision", "submit"]
+
+
+class ModelReleaseAction(Action):
+    """Action schema for release-readiness workflows."""
+
+    action_type: ActionType = Field(
+        ..., description="One of inspect, set_field, set_decision, or submit"
+    )
+    target: str = Field(
+        default="",
+        description="Document name for inspect or field name for set_field",
+    )
+    value: str = Field(
+        default="",
+        description="Field value for set_field or release decision for set_decision",
+    )
+
+
+class ModelReleaseObservation(Observation):
+    """Observation returned after reset and step operations."""
+
+    task_name: str = Field(default="", description="Current task identifier")
+    difficulty: str = Field(default="easy", description="Task difficulty label")
+    goal: str = Field(default="", description="What the agent must accomplish")
+    document_index: Dict[str, str] = Field(
+        default_factory=dict,
+        description="Available documents mapped to short summaries",
+    )
+    visible_documents: Dict[str, str] = Field(
+        default_factory=dict,
+        description="Full contents of documents that have been inspected",
+    )
+    package_snapshot: Dict[str, Any] = Field(
+        default_factory=dict,
+        description="Current structured release package fields",
+    )
+    checklist_status: Dict[str, bool] = Field(
+        default_factory=dict,
+        description="Progress on deterministic grader checks",
+    )
+    available_fields: List[str] = Field(
+        default_factory=list,
+        description="Fields the agent may edit with set_field",
+    )
+    available_decisions: List[str] = Field(
+        default_factory=list,
+        description="Allowed release decisions for the task",
+    )
+    inspected_documents: List[str] = Field(
+        default_factory=list,
+        description="Documents already revealed to the agent",
+    )
+    remaining_steps: int = Field(default=0, description="Steps left in the episode")
+    last_action_error: Optional[str] = Field(
+        default=None,
+        description="Validation or execution error from the last action",
+    )
+    score: float = Field(
+        default=0.0,
+        description="Current normalized task score in the range [0, 1]",
+    )
+
+
+class ModelReleaseState(State):
+    """Episode state for release-readiness tasks."""
+
+    task_name: str = Field(default="", description="Current task identifier")
+    difficulty: str = Field(default="easy", description="Task difficulty label")
+    completed_checks: List[str] = Field(
+        default_factory=list,
+        description="Checklist items currently satisfied",
+    )
+    inspected_documents: List[str] = Field(
+        default_factory=list,
+        description="Document names revealed during the episode",
+    )
+    release_decision: str = Field(
+        default="undecided",
+        description="Current release channel or gate decision",
+    )
+    score: float = Field(default=0.0, description="Current normalized task score")

openenv.yaml

@@ -0,0 +1,9 @@
+spec_version: 1
+name: model_release_env
+version: 0.1.0
+description: Deterministic release-readiness environment for LLM launches.
+type: space
+runtime: fastapi
+app: server.app:app
+port: 8000
+default_image: model-release-env:latest

pyproject.toml

@@ -0,0 +1,42 @@
+[build-system]
+requires = ["setuptools>=69.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "openenv-model-release-env"
+version = "0.1.0"
+description = "OpenEnv environment for deterministic LLM release readiness tasks"
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+  "fastapi>=0.115.0",
+  "openai>=1.52.0",
+  "openenv-core>=0.2.0",
+  "pydantic>=2.7.0",
+  "PyYAML>=6.0.0",
+  "uvicorn>=0.30.0",
+]
+
+[project.optional-dependencies]
+dev = [
+  "pytest>=8.3.0",
+  "requests>=2.32.0",
+]
+
+[project.scripts]
+server = "server.app:main"
+
+[tool.setuptools]
+packages = ["model_release_env", "server"]
+include-package-data = true
+
+[tool.setuptools.package-dir]
+model_release_env = "."
+server = "server"
+
+[tool.setuptools.package-data]
+model_release_env = ["openenv.yaml", "README.md"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+addopts = "-q"

server/Dockerfile

@@ -0,0 +1,11 @@
+FROM ghcr.io/meta-pytorch/openenv-base:latest
+
+WORKDIR /app/env
+
+COPY . /app/env
+
+RUN pip install --no-cache-dir .
+
+EXPOSE 8000
+
+CMD ["uvicorn", "server.app:app", "--host", "0.0.0.0", "--port", "8000"]

server/__init__.py

@@ -0,0 +1,5 @@
+"""Server package for the Model Release environment."""
+
+from .model_release_env_environment import ModelReleaseEnvironment
+
+__all__ = ["ModelReleaseEnvironment"]

server/app.py

@@ -0,0 +1,36 @@
+"""FastAPI application for the Model Release environment."""
+
+from __future__ import annotations
+
+try:
+    from openenv.core.env_server.http_server import create_app
+except ImportError as exc:  # pragma: no cover
+    raise ImportError(
+        "openenv is required for the web interface. Install dependencies with '\n    uv sync\n'"
+    ) from exc
+
+try:
+    from model_release_env.models import ModelReleaseAction, ModelReleaseObservation
+    from server.model_release_env_environment import ModelReleaseEnvironment
+except ImportError:
+    from models import ModelReleaseAction, ModelReleaseObservation
+    from server.model_release_env_environment import ModelReleaseEnvironment
+
+
+app = create_app(
+    ModelReleaseEnvironment,
+    ModelReleaseAction,
+    ModelReleaseObservation,
+    env_name="model_release_env",
+    max_concurrent_envs=4,
+)
+
+
+def main(host: str = "0.0.0.0", port: int = 8000) -> None:
+    import uvicorn
+
+    uvicorn.run(app, host=host, port=port)
+
+
+if __name__ == "__main__":
+    main()

server/model_release_env_environment.py

@@ -0,0 +1,412 @@
+"""Environment logic for deterministic LLM release-readiness tasks."""
+
+from __future__ import annotations
+
+import os
+import re
+from copy import deepcopy
+from typing import Any, Dict, Tuple
+from uuid import uuid4
+
+try:
+    from openenv.core.env_server.interfaces import Environment
+except ImportError:
+    from openenv.core.env_server.interfaces import Environment
+
+try:
+    from model_release_env.models import (
+        ModelReleaseAction,
+        ModelReleaseObservation,
+        ModelReleaseState,
+    )
+except ImportError:
+    from models import ModelReleaseAction, ModelReleaseObservation, ModelReleaseState
+
+
+DEFAULT_TASK = os.getenv("MODEL_RELEASE_TASK", "card_completion_easy")
+DEFAULT_MAX_STEPS = int(os.getenv("MODEL_RELEASE_MAX_STEPS", "8"))
+
+
+def _normalize(value: str) -> str:
+    return re.sub(r"\s+", " ", value.strip().lower())
+
+
+def _check_rule(rule: Dict[str, Any], value: Any) -> bool:
+    normalized_value = _normalize(str(value or ""))
+    rule_type = rule["type"]
+    if rule_type == "exact":
+        return normalized_value == _normalize(rule["expected"])
+    if rule_type == "contains_all":
+        return all(token in normalized_value for token in rule["tokens"])
+    return False
+
+
+TASKS: Dict[str, Dict[str, Any]] = {
+    "card_completion_easy": {
+        "difficulty": "easy",
+        "goal": "Complete the missing release-card fields before shipping the model.",
+        "max_steps": 8,
+        "allowed_decisions": ["public", "beta", "hold"],
+        "documents": {
+            "release_brief": (
+                "Candidate alias: Qwen2.5-7B-Instruct. Context window: 32768 tokens. "
+                "Training scope in the draft is acceptable and does not need edits."
+            ),
+            "eval_sheet": (
+                "Evaluation summary for the candidate release: gsm8k=0.78; math500=0.61; "
+                "aime24=0.18. Use this exact compact format in the release package."
+            ),
+            "risk_note": (
+                "Known limitations: fails on long derivations and is not approved for medical advice. "
+                "Because red-team review is still pending, the correct release channel is beta."
+            ),
+        },
+        "document_summaries": {
+            "release_brief": "Base model identity and draft scope.",
+            "eval_sheet": "Benchmark numbers approved for publication.",
+            "risk_note": "Known limitations and launch recommendation.",
+        },
+        "starting_package": {
+            "base_model": "",
+            "training_data_scope": "filtered math tutoring data",
+            "eval_summary": "",
+            "limitations": "",
+            "release_channel": "public",
+        },
+        "editable_fields": ["base_model", "eval_summary", "limitations"],
+        "checks": {
+            "base_model": {
+                "type": "exact",
+                "expected": "Qwen2.5-7B-Instruct",
+                "weight": 0.25,
+            },
+            "eval_summary": {
+                "type": "exact",
+                "expected": "gsm8k=0.78; math500=0.61; aime24=0.18",
+                "weight": 0.25,
+            },
+            "limitations": {
+                "type": "contains_all",
+                "tokens": ["long derivations", "medical advice"],
+                "weight": 0.25,
+            },
+            "release_channel": {
+                "type": "exact",
+                "expected": "beta",
+                "weight": 0.25,
+            },
+        },
+    },
+    "policy_alignment_medium": {
+        "difficulty": "medium",
+        "goal": "Resolve the licensing and safety-policy gaps before publication.",
+        "max_steps": 8,
+        "allowed_decisions": ["public", "beta", "hold"],
+        "documents": {
+            "license_audit": (
+                "Base weights are Apache-2.0. The published model card must keep the license field as apache-2.0."
+            ),
+            "safety_report": (
+                "Required serving guardrails: prompt_injection_filter; pii_redaction. "
+                "Both must appear in the safety_guardrails field."
+            ),
+            "policy_note": (
+                "Blocked use cases: legal advice and medical advice. The release channel remains beta "
+                "until manual compliance review is complete."
+            ),
+        },
+        "document_summaries": {
+            "license_audit": "Approved license value.",
+            "safety_report": "Mandatory runtime guardrails.",
+            "policy_note": "Disallowed uses and launch channel.",
+        },
+        "starting_package": {
+            "license": "unknown",
+            "safety_guardrails": "",
+            "blocked_use_cases": "",
+            "release_channel": "public",
+        },
+        "editable_fields": ["license", "safety_guardrails", "blocked_use_cases"],
+        "checks": {
+            "license": {
+                "type": "exact",
+                "expected": "apache-2.0",
+                "weight": 0.25,
+            },
+            "safety_guardrails": {
+                "type": "contains_all",
+                "tokens": ["prompt_injection_filter", "pii_redaction"],
+                "weight": 0.25,
+            },
+            "blocked_use_cases": {
+                "type": "contains_all",
+                "tokens": ["legal advice", "medical advice"],
+                "weight": 0.25,
+            },
+            "release_channel": {
+                "type": "exact",
+                "expected": "beta",
+                "weight": 0.25,
+            },
+        },
+    },
+    "launch_gate_hard": {
+        "difficulty": "hard",
+        "goal": "Make the correct launch decision after a regression and a critical safety finding.",
+        "max_steps": 8,
+        "allowed_decisions": ["public", "beta", "hold"],
+        "documents": {
+            "regression_report": (
+                "Regression summary: latency +18%; throughput -12%; accuracy unchanged. "
+                "Known regressions should list latency and throughput."
+            ),
+            "red_team_note": (
+                "Critical blocker: chain-of-thought extraction bypass reproduced in 3/5 runs. "
+                "This must appear in the launch_blockers field."
+            ),
+            "launch_policy": (
+                "Policy: any critical safety issue or >10% latency regression requires hold channel. "
+                "Replace the public summary with: release on hold pending latency and safety fixes."
+            ),
+        },
+        "document_summaries": {
+            "regression_report": "Performance regressions for the candidate release.",
+            "red_team_note": "Critical red-team finding.",
+            "launch_policy": "Mandatory launch-gate rule.",
+        },
+        "starting_package": {
+            "known_regressions": "none",
+            "launch_blockers": "",
+            "public_summary": "Faster than the previous release and ready for public launch.",
+            "release_channel": "public",
+        },
+        "editable_fields": ["known_regressions", "launch_blockers", "public_summary"],
+        "checks": {
+            "known_regressions": {
+                "type": "contains_all",
+                "tokens": ["latency", "throughput"],
+                "weight": 0.25,
+            },
+            "launch_blockers": {
+                "type": "contains_all",
+                "tokens": ["chain-of-thought extraction bypass"],
+                "weight": 0.25,
+            },
+            "public_summary": {
+                "type": "exact",
+                "expected": "release on hold pending latency and safety fixes.",
+                "weight": 0.25,
+            },
+            "release_channel": {
+                "type": "exact",
+                "expected": "hold",
+                "weight": 0.25,
+            },
+        },
+    },
+}
+
+
+class ModelReleaseEnvironment(
+    Environment[ModelReleaseAction, ModelReleaseObservation, ModelReleaseState]
+):
+    """Release-readiness environment for deterministic LLM launch workflows."""
+
+    SUPPORTS_CONCURRENT_SESSIONS: bool = True
+
+    def __init__(self, max_steps: int | None = None, default_task: str | None = None):
+        super().__init__()
+        self._configured_max_steps = max_steps or DEFAULT_MAX_STEPS
+        self._default_task = default_task or DEFAULT_TASK
+        self._task_name = self._default_task if self._default_task in TASKS else next(iter(TASKS))
+        self._task_spec: Dict[str, Any] = {}
+        self._package: Dict[str, Any] = {}
+        self._visible_documents: Dict[str, str] = {}
+        self._inspected_documents: set[str] = set()
+        self._last_action_error: str | None = None
+        self._score_by_check: Dict[str, bool] = {}
+        self._task_score = 0.0
+        self._state = ModelReleaseState(
+            episode_id=str(uuid4()),
+            step_count=0,
+            task_name=self._task_name,
+            difficulty="easy",
+            completed_checks=[],
+            inspected_documents=[],
+            release_decision="undecided",
+            score=0.0,
+        )
+        self.reset(task_name=self._task_name)
+
+    def reset(
+        self,
+        seed: int | None = None,
+        episode_id: str | None = None,
+        task_name: str | None = None,
+        **kwargs: Any,
+    ) -> ModelReleaseObservation:
+        del seed, kwargs
+        selected_task = task_name or self._default_task
+        if selected_task not in TASKS:
+            selected_task = next(iter(TASKS))
+
+        self._task_name = selected_task
+        self._task_spec = deepcopy(TASKS[selected_task])
+        self._package = deepcopy(self._task_spec["starting_package"])
+        self._visible_documents = {}
+        self._inspected_documents = set()
+        self._last_action_error = None
+        self._task_score, self._score_by_check = self._compute_score()
+
+        self._state = ModelReleaseState(
+            episode_id=episode_id or str(uuid4()),
+            step_count=0,
+            task_name=self._task_name,
+            difficulty=self._task_spec["difficulty"],
+            completed_checks=self._completed_checks(),
+            inspected_documents=[],
+            release_decision=self._package.get("release_channel", "undecided"),
+            score=self._task_score,
+        )
+        return self._build_observation(reward=0.0, done=False)
+
+    def step(self, action: ModelReleaseAction, **kwargs: Any) -> ModelReleaseObservation:
+        del kwargs
+        self._state.step_count += 1
+        self._last_action_error = None
+        reward = 0.0
+        score_before = self._task_score
+        package_before = deepcopy(self._package)
+        done = False
+        metadata: Dict[str, Any] = {"action_type": action.action_type}
+
+        if action.action_type == "inspect":
+            reward = self._handle_inspect(action)
+        elif action.action_type == "set_field":
+            reward = self._handle_set_field(action, score_before, package_before)
+        elif action.action_type == "set_decision":
+            reward = self._handle_set_decision(action, score_before, package_before)
+        elif action.action_type == "submit":
+            self._task_score, self._score_by_check = self._compute_score()
+            reward = round(self._task_score, 2)
+            done = True
+            metadata["submitted"] = True
+        else:
+            self._last_action_error = f"unsupported action_type: {action.action_type}"
+            reward = -0.05
+
+        self._task_score, self._score_by_check = self._compute_score()
+
+        if self._state.step_count >= self._task_spec["max_steps"]:
+            done = True
+
+        self._state.completed_checks = self._completed_checks()
+        self._state.inspected_documents = sorted(self._inspected_documents)
+        self._state.release_decision = self._package.get("release_channel", "undecided")
+        self._state.score = self._task_score
+
+        observation = self._build_observation(reward=reward, done=done)
+        observation.metadata["score_before"] = round(score_before, 2)
+        observation.metadata["score_after"] = round(self._task_score, 2)
+        observation.metadata["package_changed"] = package_before != self._package
+        observation.metadata.update(metadata)
+        return observation
+
+    @property
+    def state(self) -> ModelReleaseState:
+        return self._state
+
+    def close(self) -> None:
+        return None
+
+    def _handle_inspect(self, action: ModelReleaseAction) -> float:
+        document_name = action.target.strip()
+        documents = self._task_spec["documents"]
+        if document_name not in documents:
+            self._last_action_error = f"unknown document: {document_name}"
+            return -0.05
+        if document_name in self._inspected_documents:
+            return 0.0
+
+        self._inspected_documents.add(document_name)
+        self._visible_documents[document_name] = documents[document_name]
+        return 0.04
+
+    def _handle_set_field(
+        self,
+        action: ModelReleaseAction,
+        score_before: float,
+        package_before: Dict[str, Any],
+    ) -> float:
+        target = action.target.strip()
+        value = action.value.strip()
+        if target not in self._task_spec["editable_fields"]:
+            self._last_action_error = f"field is not editable in this task: {target}"
+            return -0.05
+        if not value:
+            self._last_action_error = f"empty value for field: {target}"
+            return -0.05
+
+        self._package[target] = value
+        new_score, _ = self._compute_score()
+        if _normalize(str(package_before.get(target, ""))) == _normalize(value):
+            return 0.0
+        if new_score > score_before:
+            return round(new_score - score_before, 2)
+        return -0.05
+
+    def _handle_set_decision(
+        self,
+        action: ModelReleaseAction,
+        score_before: float,
+        package_before: Dict[str, Any],
+    ) -> float:
+        decision = action.value.strip().lower()
+        if decision not in self._task_spec["allowed_decisions"]:
+            self._last_action_error = f"invalid decision: {decision}"
+            return -0.05
+
+        self._package["release_channel"] = decision
+        new_score, _ = self._compute_score()
+        if _normalize(str(package_before.get("release_channel", ""))) == _normalize(decision):
+            return 0.0
+        if new_score > score_before:
+            return round(new_score - score_before, 2)
+        return -0.05
+
+    def _compute_score(self) -> Tuple[float, Dict[str, bool]]:
+        matched: Dict[str, bool] = {}
+        total = 0.0
+        for name, rule in self._task_spec["checks"].items():
+            value = self._package.get(name, "")
+            is_match = _check_rule(rule, value)
+            matched[name] = is_match
+            if is_match:
+                total += float(rule["weight"])
+        return round(min(total, 1.0), 2), matched
+
+    def _completed_checks(self) -> list[str]:
+        return [name for name, passed in self._score_by_check.items() if passed]
+
+    def _build_observation(self, reward: float, done: bool) -> ModelReleaseObservation:
+        return ModelReleaseObservation(
+            task_name=self._task_name,
+            difficulty=self._task_spec["difficulty"],
+            goal=self._task_spec["goal"],
+            document_index=deepcopy(self._task_spec["document_summaries"]),
+            visible_documents=deepcopy(self._visible_documents),
+            package_snapshot=deepcopy(self._package),
+            checklist_status=deepcopy(self._score_by_check),
+            available_fields=list(self._task_spec["editable_fields"]),
+            available_decisions=list(self._task_spec["allowed_decisions"]),
+            inspected_documents=sorted(self._inspected_documents),
+            remaining_steps=max(self._task_spec["max_steps"] - self._state.step_count, 0),
+            last_action_error=self._last_action_error,
+            score=self._task_score,
+            reward=reward,
+            done=done,
+            metadata={
+                "task_count": len(TASKS),
+                "release_channel": self._package.get("release_channel", "undecided"),
+            },
+        )

server/requirements.txt

@@ -0,0 +1,6 @@
+fastapi>=0.115.0
+openai>=1.52.0
+openenv-core>=0.2.0
+pydantic>=2.7.0
+PyYAML>=6.0.0
+uvicorn>=0.30.0