feat: Update class names and enhance documentation for CoEnv integration

COEnv_Project_Documentation.md

@@ -387,7 +387,7 @@ coenv/
 ├── openenv.yaml                   # OpenEnv manifest
 ├── pyproject.toml                 # Project metadata and dependencies
 ├── uv.lock                        # Locked dependencies
-├── client.py                      # CoenvEnv client / inference-side runner
+├── client.py                      # CoEnv client / inference-side runner
 ├── models.py                      # Shared action and observation models
 ├── config.json                    # Cluster defaults and simulation params
 ├── mkdocs.yml                     # Docs site configuration

README.md

@@ -19,14 +19,14 @@ The environment exposes realistic cluster state (nodes, pods, deployments, servi
 
 ## Quick Start
 
-The simplest way to use the Coenv environment is through the `CoenvEnv` class:
+The simplest way to use the Coenv environment is through the `CoEnv` class:
 
 ```python
-from coenv import CoenvAction, CoenvEnv
+from coenv import CoenvAction, CoEnv
 
 try:
     # Create environment from Docker image
-    coenvenv = CoenvEnv.from_docker_image("coenv-env:latest")
+    coenvenv = CoEnv.from_docker_image("coenv-env:latest")
 
     # Reset with a task
     result = coenvenv.reset(task="pod_recovery")
@@ -50,7 +50,7 @@ finally:
     coenvenv.close()
 ```
 
-That's it! The `CoenvEnv.from_docker_image()` method handles:
+That's it! The `CoEnv.from_docker_image()` method handles:
 - Starting the Docker container
 - Waiting for the server to be ready
 - Connecting to the environment
@@ -157,10 +157,10 @@ Reward is task-dependent and based on service health progression:
 If you already have a Coenv environment server running, you can connect directly:
 
 ```python
-from coenv import CoenvAction, CoenvEnv
+from coenv import CoenvAction, CoEnv
 
 # Connect to existing server
-coenvenv = CoenvEnv(base_url="<ENV_HTTP_URL_HERE>")
+coenvenv = CoEnv(base_url="<ENV_HTTP_URL_HERE>")
 
 # Use as normal
 result = coenvenv.reset(task="incident")
@@ -176,10 +176,10 @@ Note: When connecting to an existing server, `coenvenv.close()` will NOT stop th
 The client supports context manager usage for automatic connection management:
 
 ```python
-from coenv import CoenvAction, CoenvEnv
+from coenv import CoenvAction, CoEnv
 
 # Connect with context manager (auto-connects and closes)
-with CoenvEnv(base_url="http://localhost:8000") as env:
+with CoEnv(base_url="http://localhost:8000") as env:
     result = env.reset(task="autoscaling")
     print(f"Reset objective: {result.observation.objective}")
     # Multiple steps with low latency
@@ -213,11 +213,11 @@ app = create_app(
 Then multiple clients can connect simultaneously:
 
 ```python
-from coenv import CoenvAction, CoenvEnv
+from coenv import CoenvAction, CoEnv
 from concurrent.futures import ThreadPoolExecutor
 
 def run_episode(client_id: int):
-    with CoenvEnv(base_url="http://localhost:8000") as env:
+    with CoEnv(base_url="http://localhost:8000") as env:
         result = env.reset(task="pod_recovery")
         for i in range(10):
             result = env.step(
@@ -265,7 +265,7 @@ coenv/
 ├── openenv.yaml           # OpenEnv manifest
 ├── pyproject.toml         # Project metadata and dependencies
 ├── uv.lock                # Locked dependencies (generated)
-├── client.py              # CoenvEnv client
+├── client.py              # CoEnv client
 ├── models.py              # Action and Observation models
 └── server/
     ├── __init__.py        # Server module exports

__init__.py

@@ -6,11 +6,11 @@
 
 """Coenv Environment."""
 
-from .client import CoenvEnv
+from .client import CoEnv
 from .models import CoenvAction, CoenvObservation
 
 __all__ = [
     "CoenvAction",
     "CoenvObservation",
-    "CoenvEnv",
+    "CoEnv",
 ]

client.py

@@ -12,10 +12,10 @@ from openenv.core import EnvClient
 from openenv.core.client_types import StepResult
 from openenv.core.env_server.types import State
 
-from .models import CoenvAction, CoenvObservation
+from models import CoenvAction, CoenvObservation
 
 
-class CoenvEnv(
+class CoEnv(
     EnvClient[CoenvAction, CoenvObservation, State]
 ):
     """
@@ -27,7 +27,7 @@ class CoenvEnv(
 
     Example:
         >>> # Connect to a running server
-        >>> with CoenvEnv(base_url="http://localhost:8000") as client:
+        >>> with CoEnv(base_url="http://localhost:8000") as client:
         ...     result = client.reset()
         ...     print(result.observation.echoed_message)
         ...
@@ -36,7 +36,7 @@ class CoenvEnv(
 
     Example with Docker:
         >>> # Automatically start container and connect
-        >>> client = CoenvEnv.from_docker_image("coenv-env:latest")
+        >>> client = CoEnv.from_docker_image("coenv-env:latest")
         >>> try:
         ...     result = client.reset()
         ...     result = client.step(CoenvAction(message="Test"))

inference.py

@@ -1,86 +1,188 @@
 """
-coenv Inference Script
-Used by validators to run episodes with LLMs
+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 sys
-import json
-import argparse
-import requests
-from typing import Dict, Any, Optional
-
-API_BASE_URL = os.getenv("API_BASE_URL", "http://localhost:8000")
-MODEL_NAME = os.getenv("MODEL_NAME", "Qwen3-30B")
-HF_TOKEN = os.getenv("HF_TOKEN")
-
-
-def main():
-    parser = argparse.ArgumentParser(description='Run coenv inference')
-    parser.add_argument('--api-base-url', type=str, default=API_BASE_URL, help='Base URL for the coenv API')
-    parser.add_argument('--model-name', type=str, default=MODEL_NAME, help='Name of the model to use')
-    parser.add_argument('--hf-token', type=str, default=HF_TOKEN, help='Hugging Face token (if needed)')
-    parser.add_argument('--task-id', type=str, default='pod_recovery', help='Task ID to run')
-    parser.add_argument('--max-steps', type=int, default=15, help='Maximum steps per episode')
-    
-    args = parser.parse_args()
-    
-    api_base_url = args.api_base_url.rstrip('/')
-    model_name = args.model_name
-    hf_token = args.hf_token or HF_TOKEN
-    task_id = args.task_id
-    max_steps = args.max_steps
-    
-    print(f"[START] task={task_id} env=coenv model={model_name}")
-    
-    reset_url = f"{api_base_url}/reset"
+import textwrap
+from typing import List, Optional
+
+from openai import OpenAI
+from models import CoenvAction
+from client import CoEnv
+IMAGE_NAME = os.getenv("IMAGE_NAME")
+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:
-        response = requests.post(reset_url, json={"task": task_id})
-        response.raise_for_status()
-        observation = response.json()
-    except Exception as e:
-        print(f"[ERROR] Failed to reset environment: {e}")
-        return 1
-    
-    total_reward = []
-    
-    for step in range(1, max_steps + 1):
-        action = {
-            "action_type": "describe",
-            "resource_type": "deployment",
-            "name": "frontend"
-        }
-        action_str = f"describe('deployment','frontend')"
-        
-        step_url = f"{api_base_url}/step"
-        try:
-            response = requests.post(step_url, json={"action": action})
-            response.raise_for_status()
-            result = response.json()
-            
-            reward = result.get('reward', 0.0)
-            done = result.get('done', False)
-            info = result.get('info', {})
-            error_str = "null"
-            
-            if 'error' in info and info['error']:
-                error_str = f"\"{info['error']}\""
-            
-            total_reward.append(reward)
-            
-            print(f"[STEP] step={step} action={action_str} reward={reward:.2f} done={done} error={error_str}")
-            
+        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 CoEnv.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(CoenvAction(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:
-                print(f"[END] success={str(done).lower()} steps={step} rewards={total_reward}")
-                return 0
-                
+                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"[ERROR] Failed to step environment: {e}")
-            print(f"[STEP] step={step} action={action_str} reward=0.00 done=false error=\"{str(e)}\"")
-    
-    print(f"[END] success=false steps={max_steps} rewards={total_reward}")
-    return 0
+            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__":
-    sys.exit(main())
+    asyncio.run(main())

models.py

@@ -11,7 +11,7 @@ These models define the public OpenEnv action/observation schema for the
 Kubernetes simulation.
 """
 
-from openenv.core.env_server.types import Action, Observation
+from openenv.core.env_server.types import Action, Observation, State
 from pydantic import Field
 from typing import Dict, Any, Optional, Literal, List
 
@@ -74,3 +74,9 @@ class CoenvObservation(Observation):
     events: List[ClusterEvent] = Field(default_factory=list)
     step: int = Field(default=0)
     objective: str = Field(default="")
+
+class CoenvState(State):
+    """State model for the Kubernetes simulator."""
+
+    episode_id: str = Field(default="")
+    step_count: int = Field(default=0)

pre-submission.sh

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

server/Dockerfile

@@ -17,19 +17,33 @@ COPY . /app/env
 
 WORKDIR /app/env
 
-# Install dependencies with uv (locked when uv.lock is available).
+# Install dependencies with uv.
+# Use pyproject/uv.lock when present, otherwise fall back to requirements.txt
+# because submission validators often build from server/ as context.
 RUN --mount=type=cache,target=/root/.cache/uv \
-	if [ -f uv.lock ]; then \
-		uv sync --frozen --no-install-project --no-editable; \
+	if [ -f pyproject.toml ]; then \
+		if [ -f uv.lock ]; then \
+			uv sync --frozen --no-install-project --no-editable; \
+		else \
+			uv sync --no-install-project --no-editable; \
+		fi; \
+	elif [ -f requirements.txt ]; then \
+		uv venv .venv; \
+		uv pip install --python .venv/bin/python -r requirements.txt; \
 	else \
-		uv sync --no-install-project --no-editable; \
+		echo "No pyproject.toml or requirements.txt found in build context" >&2; \
+		exit 2; \
 	fi
 
 RUN --mount=type=cache,target=/root/.cache/uv \
-	if [ -f uv.lock ]; then \
-		uv sync --frozen --no-editable; \
+	if [ -f pyproject.toml ]; then \
+		if [ -f uv.lock ]; then \
+			uv sync --frozen --no-editable; \
+		else \
+			uv sync --no-editable; \
+		fi; \
 	else \
-		uv sync --no-editable; \
+		true; \
 	fi
 
 FROM ${BASE_IMAGE}

server/simulation_service.py

@@ -16,9 +16,9 @@ except ImportError:
     from coenv_environment import World
 
 try:
-    from ..models import CoenvAction, CoenvObservation
+    from ..models import CoenvAction, CoenvObservation, CoenvState
 except ImportError:
-    from models import CoenvAction, CoenvObservation
+    from models import CoenvAction, CoenvObservation, CoenvState
 
 
 def load_config() -> Dict[str, Any]:
@@ -147,6 +147,7 @@ class CoenvEnvironment(Environment):
 
     def __init__(self):
         self.config: Dict[str, Any] = load_config()
+        self.episode_id = f"episode-{os.getpid()}-{int(os.times()[4] * 1000)}"
         self.world = World(self.config, seed=self.config.get("seed"))
         self.current_task = "pod_recovery"
         self.current_objective = get_objective_for_task(self.current_task)
@@ -225,14 +226,16 @@ class CoenvEnvironment(Environment):
             done = True
 
         return self._observation(done=done, reward=reward, info=info)
-
-    def state(self, **_: Any) -> Dict[str, Any]:
-        """Return lightweight environment state metadata."""
-        return {
-            "step": self.world.step_count,
-            "task": self.current_task,
-            "objective": self.current_objective,
-        }
+    
+    @property
+    def state(self) -> CoenvState:
+        """Return current observation without applying an action."""
+        reward = calculate_reward(self.world, self.current_task)
+        done = check_task_complete(self.world, self.current_task)
+        return CoenvState(
+            episode_id=self.episode_id,
+            step_count=self.world.step_count
+        )
 
     def _observation(self, done: bool, reward: float, info: Dict[str, Any]) -> CoenvObservation:
         obs = self.world.get_observation(self.current_objective)

tests/test_server.py

@@ -0,0 +1,31 @@
+from ..client import CoEnv
+from ..models import CoenvAction
+import pytest
+
+@pytest.mark.asyncio
+async def test_client_step_and_state():
+    async with CoEnv(base_url="http://localhost:8000") as client:
+        # Test reset and initial state
+        reset_result = await client.reset()
+        assert hasattr(reset_result.observation, "step")
+        assert hasattr(reset_result.observation, "done")
+        assert reset_result.observation.step == 0
+        assert reset_result.done is False
+
+        # Test step with a sample action
+        action = CoenvAction(action_type="describe", resource_type="pod", name="test-pod")
+        step_result = await client.step(action)
+        assert hasattr(step_result.observation, "step")
+        assert step_result.observation.step == 1
+
+        # Test state retrieval
+        
+        step_result = await client.step(action)
+
+        state_attr = getattr(client, "state")
+        state = await state_attr() if callable(state_attr) else state_attr
+        if isinstance(state, dict):
+            step_count = state.get("step_count", state.get("step", -1))
+        else:
+            step_count = getattr(state, "step_count", getattr(state, "step", -1))
+        assert step_count == 2