Upload folder using huggingface_hub

server/app.py

@@ -11,6 +11,8 @@ Endpoints:
 
 import os
 import logging
+import json
+import time
 import gradio as gr
 from openai import OpenAI
 from dotenv import load_dotenv
@@ -29,6 +31,27 @@ logging.basicConfig(
 )
 logger = logging.getLogger("rust_coder.server")
 
+# #region agent log
+_DEBUG_LOG_PATH = os.getenv("DEBUG_LOG_PATH") or "debug-55b5ef.log"
+_DEBUG_SESSION_ID = "55b5ef"
+def _dbg(hypothesis_id: str, location: str, message: str, data: dict, run_id: str = "pre-fix") -> None:
+    try:
+        payload = {
+            "sessionId": _DEBUG_SESSION_ID,
+            "runId": run_id,
+            "hypothesisId": hypothesis_id,
+            "location": location,
+            "message": message,
+            "data": data,
+            "timestamp": int(time.time() * 1000),
+        }
+        with open(_DEBUG_LOG_PATH, "a", encoding="utf-8") as f:
+            f.write(json.dumps(payload, ensure_ascii=False) + "\n")
+    except Exception:
+        # Never break app for debug logging
+        pass
+# #endregion
+
 # --- Core OpenEnv Server Setup ---
 # Use a distinct name for the OpenEnv FastAPI instance
 openenv_app = create_app(
@@ -52,6 +75,12 @@ HF_TOKEN = os.getenv("HF_TOKEN") or os.getenv("API_KEY")
 def get_llm_solution(problem_desc: str):
     """Call LLM to get a Rust solution"""
     try:
+        _dbg(
+            "H2",
+            "server/app.py:get_llm_solution:entry",
+            "LLM call starting",
+            {"model": MODEL_NAME, "base_url": API_BASE_URL, "prompt_chars": len(problem_desc or ""), "token_present": bool(HF_TOKEN)},
+        )
         logger.info(
             "LLM call start model=%s base_url=%s prompt_chars=%d token_present=%s",
             MODEL_NAME,
@@ -77,11 +106,14 @@ def get_llm_solution(problem_desc: str):
             text = text.split("```")[1].split("```")[0]
         text = text.strip()
         if not text:
+            _dbg("H2", "server/app.py:get_llm_solution:empty", "LLM returned empty after cleanup", {"raw_chars": len((completion.choices[0].message.content or ""))})
             logger.warning("LLM returned empty code after cleanup.")
             return "// LLM Error: empty response (no code returned)."
+        _dbg("H2", "server/app.py:get_llm_solution:exit", "LLM call finished", {"returned_code_chars": len(text)})
         logger.info("LLM call end: returned_code_chars=%d", len(text))
         return text
     except Exception as e:
+        _dbg("H2", "server/app.py:get_llm_solution:error", "LLM call exception", {"error": str(e)})
         logger.exception("LLM call failed.")
         return f"// LLM Error: {e}"
 
@@ -90,6 +122,12 @@ def evaluate_single(problem_id, code=None):
     try:
         idx = int(problem_id.split(":")[0]) - 1
         problem = RustCoderEnvironment().problems[idx]
+        _dbg(
+            "H2",
+            "server/app.py:evaluate_single:entry",
+            "evaluate_single called",
+            {"problem_id": str(problem_id), "idx": idx, "code_is_none": code is None, "code_chars": len(code or "")},
+        )
         logger.info(
             "evaluate_single start problem_id=%s idx=%d code_provided=%s",
             problem_id,
@@ -102,6 +140,12 @@ def evaluate_single(problem_id, code=None):
 
         # 2. Guard: If LLM failed, do not evaluate
         if not solution_code.strip() or solution_code.startswith("// LLM Error"):
+            _dbg(
+                "H2",
+                "server/app.py:evaluate_single:abort",
+                "evaluate_single abort due to empty/error code",
+                {"starts_with_llm_error": solution_code.startswith("// LLM Error"), "solution_code_chars": len(solution_code or "")},
+            )
             logger.warning(
                 "evaluate_single abort: empty_or_error_code=%s chars=%d",
                 solution_code.startswith("// LLM Error"),

server/rust_coder_environment.py

@@ -13,11 +13,13 @@ import subprocess
 import tempfile
 import time
 import logging
+import json
 from typing import Dict, List, Optional, Tuple
 
 from openenv.core.env_server.interfaces import Environment
 
 from models import RustCoderAction, RustCoderObservation
+from openai import OpenAI
 
 
 # Resolve problems.json: look in same dir as this file, then parent
@@ -69,6 +71,29 @@ class RustCoderEnvironment(Environment):
         self.current_problem_idx: int = 0
         self.step_count: int = 0
 
+        # #region agent log
+        self._debug_log_path = os.getenv("DEBUG_LOG_PATH") or "debug-55b5ef.log"
+        self._debug_session_id = "55b5ef"
+        # #endregion
+
+    # #region agent log
+    def _dbg(self, hypothesis_id: str, location: str, message: str, data: dict, run_id: str = "pre-fix") -> None:
+        try:
+            payload = {
+                "sessionId": self._debug_session_id,
+                "runId": run_id,
+                "hypothesisId": hypothesis_id,
+                "location": location,
+                "message": message,
+                "data": data,
+                "timestamp": int(time.time() * 1000),
+            }
+            with open(self._debug_log_path, "a", encoding="utf-8") as f:
+                f.write(json.dumps(payload, ensure_ascii=False) + "\n")
+        except Exception:
+            pass
+    # #endregion
+
     # ------------------------------------------------------------------
     # Internal helpers
     # ------------------------------------------------------------------
@@ -119,7 +144,97 @@ class RustCoderEnvironment(Environment):
         problem = self.problems[self.current_problem_idx]
         code = action.code
 
+        self._dbg(
+            "H1",
+            "server/rust_coder_environment.py:step:entry",
+            "env.step called",
+            {
+                "step_count": self.step_count,
+                "problem_id": problem.get("id"),
+                "title": problem.get("title"),
+                "code_chars": len(code or ""),
+                "code_is_empty": not bool((code or "").strip()),
+            },
+        )
+
         if not code.strip():
+            # Some UIs may "step" without providing an action payload.
+            # Optionally auto-generate code via LLM so the UI can still progress.
+            auto_llm = (os.getenv("AUTO_LLM_ON_EMPTY_STEP") or "0").strip().lower() in {"1", "true", "yes", "y"}
+            if auto_llm:
+                model = os.getenv("MODEL_NAME") or "Qwen/Qwen2.5-72B-Instruct"
+                base_url = os.getenv("API_BASE_URL") or "https://router.huggingface.co/v1"
+                token = os.getenv("HF_TOKEN") or os.getenv("API_KEY")
+                prompt = problem.get("description", "")
+                starter = problem.get("starter_code", "")
+                if starter:
+                    prompt += f"\n\nStarter Code:\n```rust\n{starter}\n```"
+
+                self._dbg(
+                    "H5",
+                    "server/rust_coder_environment.py:step:auto_llm",
+                    "AUTO_LLM_ON_EMPTY_STEP enabled; attempting LLM generation",
+                    {"model": model, "base_url": base_url, "prompt_chars": len(prompt), "token_present": bool(token)},
+                )
+
+                if not token:
+                    self._logger.error("AUTO_LLM_ON_EMPTY_STEP enabled but HF_TOKEN/API_KEY missing.")
+                    return RustCoderObservation(
+                        problem_description=problem.get("description", ""),
+                        starter_code=problem.get("starter_code", ""),
+                        compilation_success=False,
+                        compilation_output="Error: AUTO_LLM_ON_EMPTY_STEP enabled but HF_TOKEN/API_KEY is missing.",
+                        test_results=[],
+                        reward_breakdown={
+                            "compilation": 0.0,
+                            "correctness": 0.0,
+                            "coverage": 0.0,
+                            "elegance": 0.0,
+                            "efficiency": 0.0,
+                        },
+                        done=False,
+                        reward=0.0,
+                    )
+                try:
+                    client_llm = OpenAI(base_url=base_url, api_key=token)
+                    completion = client_llm.chat.completions.create(
+                        model=model,
+                        messages=[
+                            {"role": "system", "content": "You are a senior Rust engineer. Return ONLY the complete fixed Rust code. No explanation."},
+                            {"role": "user", "content": prompt},
+                        ],
+                        temperature=0.1,
+                    )
+                    text = (completion.choices[0].message.content or "").strip()
+                    if "```rust" in text:
+                        text = text.split("```rust")[1].split("```")[0]
+                    elif "```" in text:
+                        text = text.split("```")[1].split("```")[0]
+                    text = text.strip()
+                    if text:
+                        code = text
+                        self._dbg(
+                            "H5",
+                            "server/rust_coder_environment.py:step:auto_llm_ok",
+                            "LLM produced non-empty code; continuing evaluation",
+                            {"code_chars": len(code)},
+                        )
+                    else:
+                        self._dbg(
+                            "H5",
+                            "server/rust_coder_environment.py:step:auto_llm_empty",
+                            "LLM returned empty after cleanup; falling back to empty submission behavior",
+                            {"raw_chars": len((completion.choices[0].message.content or ""))},
+                        )
+                except Exception as e:
+                    self._dbg(
+                        "H5",
+                        "server/rust_coder_environment.py:step:auto_llm_error",
+                        "LLM call failed; falling back to empty submission behavior",
+                        {"error": str(e)},
+                    )
+
+            if not code.strip():
             # Invalid/empty submission: do not advance the problem index.
             self._logger.warning(
                 "Empty code submitted step_count=%d problem_id=%s title=%s",
@@ -127,6 +242,12 @@ class RustCoderEnvironment(Environment):
                 problem.get("id"),
                 problem.get("title"),
             )
+            self._dbg(
+                "H1",
+                "server/rust_coder_environment.py:step:empty",
+                "empty code branch taken",
+                {"step_count": self.step_count, "problem_id": problem.get("id")},
+            )
             done = False
             return RustCoderObservation(
                 problem_description=problem["description"],