fix: add pyrightconfig, update pyproject packages, polish inference & models

Dockerfile

@@ -3,14 +3,17 @@ FROM python:3.11-slim
 # HuggingFace Spaces expects port 7860
 WORKDIR /app
 
-# Install dependencies (openenv-core brings FastAPI, uvicorn, pydantic)
+# Upgrade pip first for better retry/timeout handling
+RUN pip install --upgrade pip
+
+# Install dependencies with retries and longer timeout for slow networks
 COPY requirements.txt .
-RUN pip install --no-cache-dir -r requirements.txt
+RUN pip install --no-cache-dir --timeout=300 --retries=5 -r requirements.txt
 
 # Copy environment code
 COPY . .
 
 EXPOSE 7860
 
-# Use uvicorn to serve the OpenEnv app on HF Spaces port
-CMD ["uvicorn", "server.app:app", "--host", "0.0.0.0", "--port", "7860"]
+# Use python -m uvicorn to ensure it's found regardless of PATH
+CMD ["python", "-m", "uvicorn", "server.app:app", "--host", "0.0.0.0", "--port", "7860"]

TROUBLESHOOTING.md

@@ -0,0 +1,124 @@
+# Inference.py Troubleshooting Guide
+
+## What Was Fixed
+
+The original `inference.py` had an unhandled exception because it lacked proper error handling around:
+
+1. **Environment connection failures** - Docker image or server URL not reachable
+2. **Missing API credentials** - No validation of required environment variables
+3. **Network/parsing errors** - LLM calls and JSON parsing could fail silently
+4. **Environment step failures** - No recovery when env.step() fails
+
+## Changes Made
+
+### 1. Main Function Error Handling
+- Added validation for required `API_KEY`/`HF_TOKEN`
+- Wrapped environment connection in try-except with debug logging
+- Added per-task error handling to continue even if one task fails
+- Added traceback printing for debugging
+- Ensured proper cleanup in finally block
+
+### 2. Run Task Error Handling
+- Wrapped LLM calls in try-except
+- Added error handling for env.step() failures
+- Added traceback printing for task-level errors
+- Ensured log_end() is always called (required by validator)
+
+## How to Test Locally
+
+### Prerequisites
+```bash
+# Install dependencies
+pip install -r requirements.txt
+
+# Set required environment variables
+export HF_TOKEN="your_token_here"
+export MODEL_NAME="openai/gpt-4o-mini"
+export API_BASE_URL="https://router.huggingface.co/v1"
+```
+
+### Option 1: Test with Docker Image
+```bash
+export IMAGE_NAME="your-docker-image-name"
+python inference.py
+```
+
+### Option 2: Test with Running Server
+```bash
+# Start the server in one terminal
+python -m server.app
+
+# In another terminal, run inference
+export SPACE_URL="http://localhost:8000"
+python inference.py
+```
+
+### Option 3: Use Test Script
+```bash
+./test_inference.sh
+```
+
+## Common Issues & Solutions
+
+### Issue 1: "Failed to connect to environment"
+**Cause:** Docker image not available or server not running
+
+**Solutions:**
+- If using Docker: Ensure image exists with `docker images`
+- If using server: Start server first with `python -m server.app`
+- Check network connectivity to SPACE_URL
+
+### Issue 2: "API_KEY or HF_TOKEN environment variable is required"
+**Cause:** Missing authentication credentials
+
+**Solution:**
+```bash
+export HF_TOKEN="your_huggingface_token"
+# or
+export API_KEY="your_api_key"
+```
+
+### Issue 3: LLM calls timing out
+**Cause:** Network issues or API rate limits
+
+**Solution:**
+- The script now retries up to 3 times with exponential backoff
+- Check your API quota and rate limits
+- Verify API_BASE_URL is correct
+
+### Issue 4: JSON parsing errors
+**Cause:** LLM returns malformed JSON
+
+**Solution:**
+- The script now has robust JSON parsing with fallbacks
+- If parsing fails, it uses default actions
+- Check stderr for [DEBUG] messages showing what the LLM returned
+
+## Validation Checklist
+
+Before submitting, verify:
+
+- [ ] All required environment variables are set
+- [ ] Dependencies are installed (`pip install -r requirements.txt`)
+- [ ] Script runs without exceptions locally
+- [ ] Output contains [START], [STEP], and [END] lines
+- [ ] Environment container is reachable (Docker or server)
+- [ ] No unhandled exceptions in stderr
+
+## Expected Output Format
+
+```
+[START] task=severity-labeling env=code-review-env model=openai/gpt-4o-mini
+[STEP] step=1 action=label_severity:medium reward=0.50 done=false error=null
+[STEP] step=2 action=label_severity:high reward=1.00 done=true error=null
+[END] success=true steps=2 score=0.750 rewards=0.50,1.00
+```
+
+## Debug Mode
+
+To see detailed debug output:
+```bash
+python inference.py 2>&1 | tee inference.log
+```
+
+This captures both stdout (required format) and stderr (debug messages) to a file.

client.py

@@ -39,10 +39,13 @@ class CodeReviewEnv(EnvClient[CodeReviewAction, CodeReviewObservation, CodeRevie
         """Parse the server's JSON response into a typed StepResult."""
         obs_data = payload.get("observation", payload.get("data", payload))
         observation = CodeReviewObservation(**obs_data)
+        # reward and done live at the top level of the payload, not inside observation
+        reward = payload.get("reward", getattr(observation, "reward", 0.0))
+        done = payload.get("done", getattr(observation, "done", False))
         return StepResult(
             observation=observation,
-            reward=observation.reward,
-            done=observation.done,
+            reward=reward,
+            done=done,
         )
 
     def _parse_state(self, payload: Dict[str, Any]) -> CodeReviewState:

inference.py

@@ -41,6 +41,7 @@ import json
 import os
 import re
 import textwrap
+import inspect
 from typing import Any, Dict, List, Optional
 
 from openai import OpenAI
@@ -48,10 +49,33 @@ from openai import OpenAI
 from models import CodeReviewAction, CodeReviewObservation, CodeReviewState
 from client import CodeReviewEnv
 
+# ─── .env loading (no extra dependency) ───────────────────────────────────────
+
+def _load_dotenv(dotenv_path: str) -> None:
+    """Load KEY=VALUE pairs from a .env file into os.environ (without overriding)."""
+    try:
+        with open(dotenv_path, "r", encoding="utf-8") as f:
+            for raw_line in f:
+                line = raw_line.strip()
+                if not line or line.startswith("#"):
+                    continue
+                if "=" not in line:
+                    continue
+                key, value = line.split("=", 1)
+                key = key.strip()
+                value = value.strip().strip("\"'")  # tolerate simple quoting
+                if key:
+                    os.environ.setdefault(key, value)
+    except FileNotFoundError:
+        return
+
+
+_load_dotenv(os.path.join(os.path.dirname(__file__), ".env"))
+
 # ─── Configuration ────────────────────────────────────────────────────────────
 
 IMAGE_NAME = os.getenv("LOCAL_IMAGE_NAME") or os.getenv("IMAGE_NAME")  # If using from_docker_image()
-API_KEY = os.getenv("HF_TOKEN") or os.getenv("API_KEY")
+API_KEY = os.getenv("HF_TOKEN") or os.getenv("OPENAI_API_KEY") or os.getenv("API_KEY")
 
 API_BASE_URL = os.getenv("API_BASE_URL") or "https://router.huggingface.co/v1"
 MODEL_NAME = os.getenv("MODEL_NAME", "openai/gpt-4o-mini")
@@ -60,6 +84,48 @@ TEMPERATURE = 0.0
 MAX_TOKENS = 300
 SUCCESS_SCORE_THRESHOLD = 0.3
 
+def _maybe_disable_proxies() -> None:
+    """
+    OpenEnv's websocket client will honor HTTP(S)/SOCKS proxy env vars.
+    For local runs, misconfigured proxies are a common source of connection failure.
+    Set USE_PROXY=1 to keep proxy env vars enabled.
+    """
+    if os.getenv("USE_PROXY", "").strip().lower() in {"1", "true", "yes", "on"}:
+        return
+    for k in (
+        "ALL_PROXY",
+        "HTTPS_PROXY",
+        "HTTP_PROXY",
+        "SOCKS_PROXY",
+        "SOCKS5_PROXY",
+        "all_proxy",
+        "https_proxy",
+        "http_proxy",
+        "socks_proxy",
+        "socks5_proxy",
+    ):
+        os.environ.pop(k, None)
+
+    # Ensure local proxy bypass includes the default HF Space host.
+    host = os.getenv("SPACE_URL", "https://ragavrida-code-review-env.hf.space")
+    try:
+        host = host.split("://", 1)[1].split("/", 1)[0]
+    except Exception:
+        host = "ragavrida-code-review-env.hf.space"
+    for k in ("NO_PROXY", "no_proxy"):
+        cur = os.getenv(k, "")
+        parts = [p.strip() for p in cur.split(",") if p.strip()]
+        if host not in parts:
+            parts.append(host)
+            os.environ[k] = ",".join(parts)
+
+
+async def _maybe_await(value: Any) -> Any:
+    """Await value if it's awaitable, else return it."""
+    if inspect.isawaitable(value):
+        return await value
+    return value
+
 
 # ─── Structured Logging (exact spec format) ──────────────────────────────────
 
@@ -88,24 +154,35 @@ def log_end(success: bool, steps: int, score: float, rewards: List[float]) -> No
 
 def call_llm(client: OpenAI, system_prompt: str, user_prompt: str, max_retries: int = 3) -> str:
     """Call the LLM using OpenAI Client with retry. Returns response text."""
+    model_candidates = [MODEL_NAME]
+    if "/" in MODEL_NAME:
+        model_candidates.append(MODEL_NAME.split("/", 1)[1])
+
     for attempt in range(max_retries):
-        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,
-            )
-            return (completion.choices[0].message.content or "").strip()
-        except Exception as exc:
-            print(f"[DEBUG] Attempt {attempt+1}/{max_retries} failed: {exc}", file=sys.stderr, flush=True)
-            if attempt < max_retries - 1:
-                import time
-                time.sleep(2 ** attempt)
+        for model in model_candidates:
+            try:
+                completion = client.chat.completions.create(
+                    model=model,
+                    messages=[
+                        {"role": "system", "content": system_prompt},
+                        {"role": "user", "content": user_prompt},
+                    ],
+                    temperature=TEMPERATURE,
+                    max_tokens=MAX_TOKENS,
+                    stream=False,
+                )
+                return (completion.choices[0].message.content or "").strip()
+            except Exception as exc:
+                print(
+                    f"[DEBUG] Attempt {attempt+1}/{max_retries} failed (model={model}): {exc}",
+                    file=sys.stderr,
+                    flush=True,
+                )
+                # Try next candidate model (if any) before sleeping/retrying.
+                continue
+        if attempt < max_retries - 1:
+            import time
+            time.sleep(2 ** attempt)
     return ""
 
 
@@ -263,7 +340,7 @@ async def run_task(env: CodeReviewEnv, llm_client: OpenAI, task: str) -> float:
     log_start(task=config["task_name"], env=BENCHMARK, model=MODEL_NAME)
 
     try:
-        result = await env.reset(seed=42)
+        result = await _maybe_await(env.reset(seed=42))
         obs = result.observation
 
         for step in range(1, config["max_steps"] + 1):
@@ -271,9 +348,13 @@ async def run_task(env: CodeReviewEnv, llm_client: OpenAI, task: str) -> float:
                 break
 
             # Get LLM response
-            user_prompt = config["format_obs"](obs)
-            response = call_llm(llm_client, config["system_prompt"], user_prompt)
-            parsed = parse_json_response(response)
+            try:
+                user_prompt = config["format_obs"](obs)
+                response = call_llm(llm_client, config["system_prompt"], user_prompt)
+                parsed = parse_json_response(response)
+            except Exception as e:
+                print(f"[DEBUG] LLM call failed at step {step}: {e}", file=sys.stderr, flush=True)
+                parsed = None
 
             # Build action
             if parsed and parsed.get("action_type"):
@@ -284,16 +365,23 @@ async def run_task(env: CodeReviewEnv, llm_client: OpenAI, task: str) -> float:
             # Ensure valid action fields
             try:
                 action = CodeReviewAction(**action_dict)
-            except Exception:
+            except Exception as e:
+                print(f"[DEBUG] Action validation failed: {e}", file=sys.stderr, flush=True)
                 action_dict = config["default_action"](obs)
                 action = CodeReviewAction(**action_dict)
 
             # Step
-            result = await env.step(action)
-            obs = result.observation
-            reward = result.reward or 0.0
-            done = result.done
-            error = None
+            try:
+                result = await _maybe_await(env.step(action))
+                obs = result.observation
+                reward = result.reward or 0.0
+                done = result.done
+                error = None
+            except Exception as e:
+                print(f"[DEBUG] env.step() failed: {e}", file=sys.stderr, flush=True)
+                reward = 0.0
+                done = True
+                error = str(e)
 
             rewards.append(reward)
             steps_taken = step
@@ -317,6 +405,8 @@ async def run_task(env: CodeReviewEnv, llm_client: OpenAI, task: str) -> float:
 
     except Exception as exc:
         print(f"[DEBUG] Task {task} error: {exc}", file=sys.stderr, flush=True)
+        import traceback
+        traceback.print_exc(file=sys.stderr)
 
     finally:
         log_end(success=success, steps=steps_taken, score=score, rewards=rewards)
@@ -326,32 +416,52 @@ async def run_task(env: CodeReviewEnv, llm_client: OpenAI, task: str) -> float:
 
 # ─── Main ────────────────────────────────────────────────────────────────────
 
-async def main() -> None:
-    llm_client = OpenAI(base_url=API_BASE_URL, api_key=API_KEY)
-
-    # Connect to environment via Docker image or HF Space
-    if IMAGE_NAME:
-        env = await CodeReviewEnv.from_docker_image(IMAGE_NAME)
-    else:
-        # Fallback: connect to running server
-        space_url = os.getenv("SPACE_URL", "https://ragavrida-code-review-env.hf.space")
-        env = CodeReviewEnv(base_url=space_url)
-
+async def main() -> int:
     try:
+        # Initialize LLM client
+        if not API_KEY:
+            raise ValueError("HF_TOKEN or OPENAI_API_KEY (or API_KEY) environment variable is required")
+        
+        llm_client = OpenAI(base_url=API_BASE_URL, api_key=API_KEY)
+
         scores = {}
+        _maybe_disable_proxies()
+        space_url = os.getenv("SPACE_URL", "https://ragavrida-code-review-env.hf.space")
         for task in ["easy", "medium", "hard"]:
-            score = await run_task(env, llm_client, task)
-            scores[task] = score
+            env = None
+            try:
+                # Fresh env per task to avoid reusing a closed ws connection.
+                if IMAGE_NAME:
+                    print(f"[DEBUG] Connecting to Docker image: {IMAGE_NAME}", file=sys.stderr, flush=True)
+                    env = await CodeReviewEnv.from_docker_image(IMAGE_NAME)
+                else:
+                    print(f"[DEBUG] Connecting to server: {space_url}", file=sys.stderr, flush=True)
+                    env = CodeReviewEnv(base_url=space_url)
+
+                score = await run_task(env, llm_client, task)
+                scores[task] = score
+            except Exception as e:
+                print(f"[ERROR] Task {task} failed: {e}", file=sys.stderr, flush=True)
+                scores[task] = 0.0
+            finally:
+                if env is not None:
+                    try:
+                        close_result = env.close()
+                        if inspect.isawaitable(close_result):
+                            await close_result
+                    except Exception as e:
+                        print(f"[DEBUG] env.close() error: {e}", file=sys.stderr, flush=True)
 
         composite = sum(scores.values()) / len(scores)
         print(f"\n[SUMMARY] composite={composite:.3f} easy={scores['easy']:.3f} medium={scores['medium']:.3f} hard={scores['hard']:.3f}", file=sys.stderr, flush=True)
 
-    finally:
-        try:
-            await env.close()
-        except Exception as e:
-            print(f"[DEBUG] env.close() error: {e}", file=sys.stderr, flush=True)
+    except Exception as e:
+        print(f"[ERROR] Main execution failed: {e}", file=sys.stderr, flush=True)
+        import traceback
+        traceback.print_exc(file=sys.stderr)
+        return 1
+    return 0
 
 
 if __name__ == "__main__":
-    asyncio.run(main())
+    raise SystemExit(asyncio.run(main()))

models.py

@@ -58,7 +58,7 @@ class CodeReviewObservation(Observation):
     Adds code-review-specific fields.
     """
 
-    model_config = ConfigDict(extra="forbid")
+    model_config = ConfigDict(extra="allow")
 
     pr_id: str = Field(default="", description="Pull request identifier")
     title: str = Field(default="", description="PR title")

pyproject.toml

@@ -7,11 +7,11 @@ name = "code-review-env"
 version = "1.0.0"
 description = "OpenEnv-compliant RL environment for software code review"
 readme = "README.md"
-requires-python = ">=3.10"
+requires-python = ">=3.10,<3.14"
 license = {text = "BSD-3-Clause"}
 
 dependencies = [
-    "openenv-core>=0.2.0",
+    "openenv>=0.1.13",
     "pydantic>=2.0",
     "pyyaml>=6.0",
     "python-ulid>=2.0",
@@ -43,6 +43,9 @@ include = [
     "analysis*",
     "world_model*",
     "server*",
+    "models*",
+    "client*",
+    "baseline*",
 ]
 
 [tool.pytest.ini_options]

pyrightconfig.json

@@ -0,0 +1,10 @@
+{
+  "executionEnvironments": [
+    {
+      "root": ".",
+      "extraPaths": ["."]
+    }
+  ],
+  "venvPath": ".",
+  "venv": ".venv"
+}

requirements.txt

@@ -6,3 +6,6 @@ scipy>=1.10
 numpy>=1.24
 openai>=1.0
 websockets>=12.0
+python-socks>=2.0
+uvicorn>=0.27.0
+fastapi>=0.109.0

scripts/validate-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

test_inference.sh

@@ -0,0 +1,39 @@
+#!/bin/bash
+# Test script for inference.py
+# Run this locally before submitting to catch errors early
+
+set -e
+
+echo "=== Testing inference.py locally ==="
+
+# Check required environment variables
+if [ -z "$HF_TOKEN" ] && [ -z "$API_KEY" ]; then
+    echo "ERROR: HF_TOKEN or API_KEY environment variable is required"
+    exit 1
+fi
+
+# Set defaults for testing
+export API_BASE_URL="${API_BASE_URL:-https://router.huggingface.co/v1}"
+export MODEL_NAME="${MODEL_NAME:-openai/gpt-4o-mini}"
+
+# Option 1: Test with Docker image (if available)
+if [ -n "$IMAGE_NAME" ]; then
+    echo "Testing with Docker image: $IMAGE_NAME"
+    python inference.py
+    exit $?
+fi
+
+# Option 2: Test with running server
+if [ -n "$SPACE_URL" ]; then
+    echo "Testing with server: $SPACE_URL"
+    python inference.py
+    exit $?
+fi
+
+# Option 3: Start local server first
+echo "No IMAGE_NAME or SPACE_URL set."
+echo "Please either:"
+echo "  1. Set IMAGE_NAME to your Docker image name"
+echo "  2. Set SPACE_URL to your running server URL"
+echo "  3. Start the server locally first with: python -m server.app"
+exit 1