Delete reference-material directory

reference-material/add_water_variable.py

@@ -1,59 +0,0 @@
-"""
-add_water_variable.py
-
-Adds a Water_mm column to the farm dataset.
-Water is drawn uniformly from [WATER_MIN, Rainfall_mm].
-Rainfall_mm is reduced by the water drawn to prevent bias.
-"""
-
-import pandas as pd
-import numpy as np
-import sys
-
-WATER_MIN = 20   # minimum meaningful irrigation (mm)
-WATER_MAX = 200  # hard ceiling - avoids flooding; also capped at rainfall
-
-def add_water(df: pd.DataFrame, seed: int = 42) -> pd.DataFrame:
-    rng = np.random.default_rng(seed)
-    df = df.copy()
-
-    # Upper bound: rainfall itself, capped at WATER_MAX
-    upper = df["Rainfall_mm"].clip(upper=WATER_MAX)
-
-    # Where rainfall < WATER_MIN we can't irrigate meaningfully — set 0
-    can_irrigate = upper >= WATER_MIN
-    water = np.where(
-        can_irrigate,
-        rng.uniform(WATER_MIN, upper.where(can_irrigate, WATER_MIN)),
-        0.0
-    )
-
-    df["Water_mm"] = np.round(water, 2)
-    df["Rainfall_mm"] = np.round(df["Rainfall_mm"] - df["Water_mm"], 2)
-    return df
-
-
-def main():
-    path = sys.argv[1] if len(sys.argv) > 1 else "farm_data.csv"
-    out  = sys.argv[2] if len(sys.argv) > 2 else path.replace(".csv", "_watered.csv")
-
-    df = pd.read_csv(path)
-    required = {"Rainfall_mm"}
-    missing = required - set(df.columns)
-    if missing:
-        raise ValueError(f"Missing columns: {missing}")
-
-    df_out = add_water(df)
-
-    print(f"Water_mm  — min: {df_out['Water_mm'].min():.1f}  "
-          f"max: {df_out['Water_mm'].max():.1f}  "
-          f"mean: {df_out['Water_mm'].mean():.1f}")
-    print(f"Rainfall_mm after subtraction — min: {df_out['Rainfall_mm'].min():.1f}  "
-          f"mean: {df_out['Rainfall_mm'].mean():.1f}")
-
-    df_out.to_csv(out, index=False)
-    print(f"Saved → {out}")
-
-
-if __name__ == "__main__":
-    main()

reference-material/prevalidation-script.sh

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

reference-material/roadmap.md

@@ -1,577 +0,0 @@
-# FarmRL Round-1 Fast Development Roadmap
-
-## Reference Materials
-
-### Introduction
-
-FarmRL is a reinforcement learning project that trains an agent to manage crop farming decisions. Given observable farm conditions such as soil properties, weather, and crop type, the agent learns to control irrigation, fertilizer application, and pesticide use in order to maximise crop yield while maintaining a healthy sustainability score.
-
-The project is grounded in a tabular agricultural dataset and draws conceptual inspiration from the FarmGym simulation framework. Two training paradigms are supported: a classic RL agent via a custom OpenEnv environment, and an optional text-framing path using TRL for language-model-based decision making.
-
-The raw CSV dataset is preprocessed once. The preprocessing adds the Water\_mm column (drawn uniformly from [20, min(Rainfall\_mm, 200)]) and subtracts that value from Rainfall\_mm to preserve water-balance invariance. A lightweight regression model (XGBoost) is then trained on the processed data to serve as the environment's transition model.
-
----
-
-## Dataset preprocessing requirement
-
-Add a preprocessing script that creates a new variable Water\_mm such that:
-
-Rainfall\_original = Rainfall\_new + Water\_mm
-
-This prevents bias by conserving total water availability.
-
-Script file:
-
-scripts/add\_water\_variable.py
-
-```
-"""
-add_water_variable.py
-
-Adds a Water_mm column to the farm dataset.
-Water is drawn uniformly from [WATER_MIN, Rainfall_mm].
-Rainfall_mm is reduced by the water drawn to prevent bias.
-"""
-
-import pandas as pd
-import numpy as np
-import sys
-
-WATER_MIN = 20   # minimum meaningful irrigation (mm)
-WATER_MAX = 200  # hard ceiling - avoids flooding; also capped at rainfall
-
-def add_water(df: pd.DataFrame, seed: int = 42) -> pd.DataFrame:
-    rng = np.random.default_rng(seed)
-    df = df.copy()
-
-    # Upper bound: rainfall itself, capped at WATER_MAX
-    upper = df["Rainfall_mm"].clip(upper=WATER_MAX)
-
-    # Where rainfall < WATER_MIN we can't irrigate meaningfully — set 0
-    can_irrigate = upper >= WATER_MIN
-    water = np.where(
-        can_irrigate,
-        rng.uniform(WATER_MIN, upper.where(can_irrigate, WATER_MIN)),
-        0.0
-    )
-
-    df["Water_mm"] = np.round(water, 2)
-    df["Rainfall_mm"] = np.round(df["Rainfall_mm"] - df["Water_mm"], 2)
-    return df
-
-
-def main():
-    path = sys.argv[1] if len(sys.argv) > 1 else "farm_data.csv"
-    out  = sys.argv[2] if len(sys.argv) > 2 else path.replace(".csv", "_watered.csv")
-
-    df = pd.read_csv(path)
-    required = {"Rainfall_mm"}
-    missing = required - set(df.columns)
-    if missing:
-        raise ValueError(f"Missing columns: {missing}")
-
-    df_out = add_water(df)
-
-    print(f"Water_mm  — min: {df_out['Water_mm'].min():.1f}  "
-          f"max: {df_out['Water_mm'].max():.1f}  "
-          f"mean: {df_out['Water_mm'].mean():.1f}")
-    print(f"Rainfall_mm after subtraction — min: {df_out['Rainfall_mm'].min():.1f}  "
-          f"mean: {df_out['Rainfall_mm'].mean():.1f}")
-
-    df_out.to_csv(out, index=False)
-    print(f"Saved → {out}")
-
-
-if __name__ == "__main__":
-    main()
-
-```
-
-Purpose:
-
-• introduces irrigation variable • prevents data leakage • preserves statistical consistency • improves realism of agent decisions
-
----
-
-# 3-Phase Fast Development Plan (3–4 hours)
-
-Goal: produce validator-compliant submission with improved reward design.
-
-Scope limitations:
-
-• simple environment dynamics • minimal dataset preprocessing • basic transition model • improved reward shaping only
-
----
-
-# Phase 1 — OpenEnv Environment (Core functionality)
-
-**Goal:** produce a valid OpenEnv-compliant environment that passes schema and endpoint checks.
-
-Estimated time: **1.5 hours**
-
----
-
-## Tasks
-
-### 1. Define typed state model (Pydantic)
-
-Keep small but realistic.
-
-Example variables:
-
-```
-soil_moisture : float
-soil_ph       : float
-temperature   : float
-rainfall      : float
-crop_stage    : int
-day           : int
-
-```
-
-Requirements satisfied:
-
-- typed models required by OpenEnv spec
-- deterministic state structure
-
----
-
-### 2. Define typed action model
-
-Discrete actions simplify LLM reliability:
-
-```
-water       : float   (0–50)
-fertilizer  : float   (0–20)
-pesticide   : float   (0–10)
-
-```
-
-Keep ranges bounded to stabilize scoring.
-
----
-
-### 3. Implement environment class
-
-File:
-
-```
-env/farm_env.py
-
-```
-
-Must implement:
-
-```
-reset()
-step(action)
-state()
-
-```
-
----
-
-### 4. Implement improved reward design (only sophistication added)
-
-Reward must reflect:
-
-- yield improvement
-- sustainability balance
-- penalty for overuse of chemicals
-
-Example reward:
-
-```
-yield_score =
-    0.4 * soil_moisture
-  + 0.3 * temperature_factor
-  + 0.3 * rainfall_factor
-
-resource_penalty =
-    0.03 * fertilizer^1.2
-  + 0.04 * pesticide^1.3
-
-sustainability_bonus =
-    0.2 * exp(-fertilizer/20)
-  + 0.2 * exp(-pesticide/10)
-
-reward =
-    yield_score
-  + sustainability_bonus
-  - resource_penalty
-
-```
-
-Characteristics:
-
-- diminishing returns on fertilizer
-- discourages excessive pesticide
-- stable numeric range
-- smooth gradients
-
----
-
-### 5. Episode termination rule
-
-```
-max_days = 30
-
-```
-
-Short episodes ensure runtime < 20 min.
-
----
-
-### 6. Create openenv.yaml
-
-Define:
-
-```
-environment metadata
-observation schema
-action schema
-reward schema
-task definitions
-
-```
-
-Ensure field names exactly match Pydantic models.
-
----
-
-### 7. Implement API wrapper (if required by spec)
-
-Expose:
-
-```
-POST /reset
-POST /step
-GET /state
-
-```
-
-Ensure reset returns valid initial state.
-
-Requirement satisfied:
-
-HF Space ping must return 200.
-
----
-
-# Phase 2 — inference pipeline + tasks + graders
-
-**Goal:** produce valid evaluation run with structured logs and normalized scores.
-
-Estimated time: **1.5 hours**
-
----
-
-## Tasks
-
-### 1. Create inference.py in root directory
-
-File location:
-
-```
-/inference.py
-
-```
-
-Must:
-
-- load environment
-- call LLM via OpenAI client
-- run episodes
-- log structured output
-- compute task scores
-
----
-
-### 2. Implement OpenAI client usage
-
-Must use env variables:
-
-```
-API_BASE_URL
-MODEL_NAME
-HF_TOKEN
-
-```
-
-LLM prompt format:
-
-```
-Farm state:
-soil moisture: 34
-temperature: 26
-rainfall: 3
-crop stage: 2
-
-Choose action values:
-water
-fertilizer
-pesticide
-
-```
-
-LLM output expected as JSON:
-
-```
-{
- "water": 20,
- "fertilizer": 5,
- "pesticide": 1
-}
-
-```
-
-Add fallback defaults if parsing fails.
-
----
-
-### 3. Define 3 tasks
-
-Tasks must produce score ∈ [0,1].
-
----
-
-#### Task 1 — yield performance
-
-Measures productivity.
-
-```
-score =
-normalized(total_reward)
-
-```
-
----
-
-#### Task 2 — chemical efficiency
-
-Penalizes excessive fertilizer/pesticide.
-
-```
-score =
-1 - normalized(total_chemical_use)
-
-```
-
----
-
-#### Task 3 — sustainability balance
-
-Encourages moderate actions.
-
-```
-score =
-yield / (fertilizer + pesticide + 1)
-normalized to 0–1
-
-```
-
----
-
-### 4. Implement graders
-
-Each grader returns:
-
-```
-{
- "task_id": "...",
- "score": float
-}
-
-```
-
-Ensure:
-
-```
-0 ≤ score ≤ 1
-
-```
-
-Validator requirement.
-
----
-
-### 5. Implement structured logs
-
-Strict format:
-
-```
-[START]
-model: MODEL_NAME
-
-[STEP]
-step: 1
-action: {...}
-reward: ...
-
-[STEP]
-step: 2
-...
-
-[END]
-task_scores:
-task1: 0.63
-task2: 0.71
-task3: 0.59
-
-```
-
-Formatting must match specification exactly.
-
----
-
-### 6. Runtime optimization
-
-Keep small:
-
-```
-episodes = 3
-steps per episode = 20–30
-
-```
-
-Ensures runtime well below 20 minutes.
-
----
-
-# Phase 3 — packaging, docker, validation
-
-**Goal:** ensure infrastructure compatibility and reproducibility.
-
-Estimated time: **1 hour**
-
----
-
-## Tasks
-
-### 1. requirements.txt
-
-Minimal dependencies:
-
-```
-pydantic
-numpy
-pyyaml
-openai
-fastapi (optional)
-uvicorn (optional)
-
-```
-
-Avoid heavy ML libraries.
-
----
-
-### 2. Dockerfile
-
-Must build automatically.
-
-Example flow:
-
-```
-FROM python:3.11-slim
-
-WORKDIR /app
-
-COPY . .
-
-RUN pip install -r requirements.txt
-
-CMD ["python", "inference.py"]
-
-```
-
-Validator requirement satisfied.
-
----
-
-### 3. environment variables support
-
-Ensure inference.py reads:
-
-```
-API_BASE_URL
-MODEL_NAME
-HF_TOKEN
-
-```
-
-No hardcoding.
-
----
-
-### 4. basic local tests
-
-Run:
-
-```
-python inference.py
-
-```
-
-Verify:
-
-- no crashes
-- scores generated
-- logs formatted correctly
-
----
-
-### 5. validation checklist
-
-Confirm:
-
-HF Space can call:
-
-```
-reset()
-step()
-state()
-
-```
-
-Ensure:
-
-- numeric reward returned
-- valid JSON outputs
-- docker build successful
-
----
-
-# Final deliverable structure
-
-```
-project/
-│
-├── openenv.yaml
-├── inference.py
-├── Dockerfile
-├── requirements.txt
-│
-├── env/
-│   └── farm_env.py
-│
-└── tasks/
-    └── graders.py
-
-```
-
----
-
-# Expected outcome
-
-Submission will pass:
-
-- OpenEnv compliance
-- structured logging requirement
-- 3 task requirement
-- reproducibility requirement
-- runtime constraint
-- docker build requirement
-- HF space endpoint validation
-
----

reference-material/sample-inference-script.py

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