inference update v4

inference.py

@@ -8,6 +8,7 @@ from models import DocAction
 IMAGE_NAME = os.getenv("IMAGE_NAME") 
 API_KEY = os.getenv("HF_TOKEN") or os.getenv("API_KEY")
 
+# Swapped back to OpenAI defaults
 API_BASE_URL = os.getenv("API_BASE_URL") or "https://api.openai.com/v1"
 MODEL_NAME = os.getenv("MODEL_NAME") or "gpt-4o-mini"
 BENCHMARK_NAME = "doc_sweeper"
@@ -24,9 +25,12 @@ def run_inference(task_name: str):
     if not hf_token:
         raise ValueError("Missing hf_token")
 
+    # Replaced Groq with OpenAI, keeping the timeout fixes!
     client = OpenAI(
         api_key=hf_token,
-        base_url=api_base_url
+        base_url=api_base_url,
+        timeout=15.0,     # Max 15 seconds per request
+        max_retries=1     # Do not get stuck in infinite backoff loops
     )
     
     env = DocSweeperEnvironment(task=task_name)
@@ -36,6 +40,7 @@ def run_inference(task_name: str):
     total_reward = 0.0
     step_count = 0
     rewards_history = []
+    MAX_STEPS = 20 # Hard step limit failsafe
 
     print(f"[START] task={task_name} env={BENCHMARK_NAME} model={model_name}", flush=True)
 
@@ -44,11 +49,11 @@ def run_inference(task_name: str):
     
     YOUR CURRENT TASK: '{task_name}'
     - If 'version_bump': Systematically OPEN EVERY SINGLE FILE in the directory tree. Check for 'v1.0.0' or 'v1.00'. If found, use 'edit' to update to 'v2.0.0'.
-    - If 'config_migration': Open docker-compose files. Update version to 3.8 and migrate 'links' to 'networks'.
-    - If 'broken_links': Find broken relative links and edit them to point to correct paths.
+    - If 'config_migration': Open docker-compose files. Update version to '3.8' and migrate 'links:' to 'networks:'.
+    - If 'broken_links': Find broken relative links containing '../old-docs/' and edit them to point strictly to './new-docs/'.
     
     WORKFLOW RULES:
-    1. PLAN FIRST: Use the 'thought' field to track which files you have checked and which remain.
+    1. PLAN IN THOUGHT: Use the 'thought' field to reason. NEVER use a tool called "plan". Valid tools are strictly: 'open', 'edit', 'grep', 'done'.
     2. OPEN THEN EDIT: You MUST 'open' a file before you can 'edit' it.
     3. EDIT SAFELY: When editing, use 'old_str' (exact text to replace) and 'new_str'. Do NOT use 'path'.
     4. FINISH: Call 'done' ONLY when you have opened and verified EVERY file in the directory tree.
@@ -66,10 +71,9 @@ def run_inference(task_name: str):
     """
     
     messages = [{"role": "system", "content": system_prompt}]
-    
     start_time = time.time()
 
-    while not done:
+    while not done and step_count < MAX_STEPS:
         step_count += 1
         current_state_prompt = f"""
         [ENVIRONMENT OBSERVATION]
@@ -116,11 +120,14 @@ def run_inference(task_name: str):
             obs.terminal_feedback = f"SYSTEM ERROR: {error_msg}. Review the schema rules."
             rewards_history.append(0.0) 
             
+            if "timeout" in error_msg.lower() or "connection" in error_msg.lower():
+                 done = True 
+                 
             done_str = str(done).lower()
             print(f"[STEP] step={step_count} action=error reward=0.00 done={done_str} error=\"{error_msg}\"", flush=True)
 
     final_score = max(0.0, min(1.0, total_reward))
-    success = final_score > 0.0 # Define what success means for your environment
+    success = final_score > 0.0 
     success_str = str(success).lower()
     rewards_str = ",".join(f"{r:.2f}" for r in rewards_history)
 

server/cust_env_environment.py

@@ -8,55 +8,52 @@ import uuid
 from typing import Dict, List
 
 from openenv.core.env_server import Environment
-
 from models import DocAction, DocObservation, DocState
 
-
 class DocSweeperEnvironment(Environment):
 
     def __init__(
         self,
         task: str = "version_bump",
-        max_steps: int = 30,
+        max_steps: int = 20,
     ):
-        """
-        Args:
-            task: Task to run - "version_bump", "config_migration", or "broken_links".
-            max_steps: Maximum allowed actions before forced termination.
-        """
         super().__init__(rubric=None)
         self._task = task
         self._max_steps = max_steps
         self._state: DocState | None = None
         self._terminal_feedback = ""
+        
+        self._baseline_denominators = {}
         self.reset()
 
     def reset(self, **kwargs):
-        """
-        Returns:
-            Initial observation of the virtual file system.
-        """
         episode_id = str(uuid.uuid4())
         self._terminal_feedback = "Environment reset."
         
-        initial_vfs = {}
         if self._task == "version_bump":
             initial_vfs = {
                 "/docs/setup.md": "Welcome to our tool v1.0.0. To install v1.0.0, run the script.",
                 "/docs/api.md": "API Reference for v1.0.0.",
                 "/docs/troubleshoot.md": "If v1.00 fails, check logs."
             }
+            self._baseline_denominators["total_files"] = 3
+            
         elif self._task == "config_migration":
             initial_vfs = {
                 "/docs/docker-compose.yml": "version: '2'\nservices:\n  web:\n    links:\n      - db",
                 "/docs/readme.md": "Use the docker-compose to start."
             }
-        else: 
+            self._baseline_denominators["total_files"] = 1 # Only one compose file matters
+            
+        elif self._task == "broken_links": 
             initial_vfs = {
-                "/docs/index.md": "Please read [Setup](setup.md) before continuing.",
-                "/docs/installation.md": "# Installation\nSteps go here.",
-                "/docs/advanced.md": "Advanced config in [Setup](setup.md)."
+                "/docs/index.md": "Please read [Setup](../old-docs/setup.md) before continuing.",
+                "/docs/installation.md": "# Installation\nSee [API](../old-docs/api.md) for details.",
+                "/docs/advanced.md": "Advanced config in [Setup](../old-docs/setup.md)."
             }
+            self._baseline_denominators["total_links"] = 3
+        else:
+            initial_vfs = {"/docs/empty.md": "Unknown task."}
 
         self._state = DocState(
             episode_id=episode_id,
@@ -68,96 +65,140 @@ class DocSweeperEnvironment(Environment):
         return self._make_observation(reward=0.0, done=False)
 
     def step(self, action: DocAction):
-        """
-        Args:
-            action: The tool action to execute (open, edit, grep, done).
-        """
         if self._state is None:
             raise RuntimeError("Environment not initialized. Call reset() first.")
 
         self._state.step_count += 1
-        reward = 0.0
         done = False
         self._terminal_feedback = ""
         
-        # Action Routing
+        # 1. Calculate the score BEFORE the action
+        old_score = self._calculate_state_score()
+        
+        # 2. Execute the action and track any direct penalties (syntax errors, bad paths)
+        step_penalty = 0.0
+
         if action.tool_name == "done":
             done = True
-            reward += self._evaluate_final_grade()
-            self._terminal_feedback = "Task submitted for final grading."
+            self._terminal_feedback = "Task submitted. Evaluating final state."
+            # No direct penalty or bonus here, the final delta will handle it
             
         elif action.tool_name == "open":
             if action.path in self._state.vfs:
                 self._state.active_file = action.path
                 self._terminal_feedback = f"Opened {action.path}"
             else:
-                self._terminal_feedback = f"Error: File {action.path} not found."
-                reward -= 0.1
+                self._terminal_feedback = f"Error: File '{action.path}' not found."
+                step_penalty -= 0.05 # Small penalty for hallucinating files
                 
         elif action.tool_name == "grep":
             if action.search_query:
                 results = [p for p, c in self._state.vfs.items() if action.search_query in c]
                 self._terminal_feedback = f"Found '{action.search_query}' in: {', '.join(results) or 'No files'}"
-                if self._task == "broken_links":
-                    reward += 0.1
             else:
                 self._terminal_feedback = "Error: search_query required for grep."
+                step_penalty -= 0.05
                 
         elif action.tool_name == "edit":
-            reward += self._handle_edit(action)
+            step_penalty += self._handle_edit(action)
             
         else:
             self._terminal_feedback = f"Error: Unknown tool {action.tool_name}."
-            reward -= 0.1
+            step_penalty -= 0.05
 
-        # Check timeout
-        if self._state.step_count >= self._max_steps:
+        if self._state.step_count >= self._max_steps and not done:
             done = True
-            self._terminal_feedback = "Max steps reached."
+            self._terminal_feedback = "Max steps reached. Forced termination."
+
+        new_score = self._calculate_state_score()
+        
+        delta_reward = (new_score - old_score)
+        total_step_reward = delta_reward + step_penalty
             
-        return self._make_observation(reward=reward, done=done)
+        return self._make_observation(reward=total_step_reward, done=done)
 
     def _handle_edit(self, action: DocAction) -> float:
+        """Executes the edit and returns a penalty if it fails."""
         if not self._state.active_file:
             self._terminal_feedback = "Error: No file is currently open."
-            return -0.1
+            return -0.05
             
+        if not action.old_str:
+            self._terminal_feedback = "Error: 'old_str' is missing or empty."
+            return -0.05
+
         content = self._state.vfs[self._state.active_file]
         
         if action.old_str in ["```yaml", "# Title"] and not action.new_str:
             self._terminal_feedback = "Error: Destructive action prevented."
-            return -1.0
+            return -0.05
             
-        if action.old_str and action.old_str in content:
-            self._state.vfs[self._state.active_file] = content.replace(action.old_str, action.new_str or "")
+        if action.old_str in content:
+            safe_new_str = action.new_str if action.new_str is not None else ""
+            self._state.vfs[self._state.active_file] = content.replace(action.old_str, safe_new_str)
             self._terminal_feedback = "Edit successful."
-            return 0.1
+            return 0.0 
         else:
             self._terminal_feedback = f"Error: old_str '{action.old_str}' not found in file."
-            return -0.1
+            return -0.05
 
-    def _evaluate_final_grade(self) -> float:
-        text = "".join(self._state.vfs.values())
+    def _calculate_state_score(self) -> float:
+        """
+        Calculates the absolute progress of the environment [0.0 to 1.0].
+        This is called every step to calculate the delta reward.
+        """
+        vfs_items = self._state.vfs.items()
+        
         if self._task == "version_bump":
-            target_count = text.count("v2.0.0")
-            penalty = text.count("v1.0.0") + text.count("v1.00")
-            return max(0.0, (target_count / 4.0) - (penalty * 0.5))
-        return 0.5
+            correct_files = 0
+            for path, content in vfs_items:
+                if "v2.0.0" in content and not ("v1.0.0" in content or "v1.00" in content):
+                    correct_files += 1
+            
+            return min(1.0, correct_files / self._baseline_denominators["total_files"])
+
+        elif self._task == "config_migration":
+            compose_files = [content for path, content in vfs_items if "docker-compose" in path]
+            total_score = 0.0
+            
+            for content in compose_files:
+                if "version: '3.8'" in content or 'version: "3.8"' in content:
+                    total_score += 0.5
+                if "networks:" in content and "links:" not in content:
+                    total_score += 0.5
+                    
+            return min(1.0, total_score / self._baseline_denominators["total_files"])
+
+        elif self._task == "broken_links":
+            good_link_count = 0
+            for path, content in vfs_items:
+                good_link_count += content.count("./new-docs/")
+                
+            return min(1.0, good_link_count / self._baseline_denominators["total_links"])
+
+        return 0.0
 
     def _get_linter_issues(self) -> List[str]:
         if not self._state.active_file:
             return []
         issues = []
         content = self._state.vfs.get(self._state.active_file, "")
-        if self._task == "version_bump" and "v1.0.0" in content:
-            issues.append("Deprecated version 'v1.0.0' found.")
+        
+        if self._task == "version_bump" and ("v1.0.0" in content or "v1.00" in content):
+            issues.append("LINTER WARNING: Deprecated version string found.")
+        elif self._task == "broken_links" and "../old-docs/" in content:
+            issues.append("LINTER WARNING: Broken relative link detected.")
+        elif self._task == "config_migration" and "links:" in content:
+            issues.append("LINTER WARNING: Docker 'links' is deprecated. Use 'networks'.")
+            
         return issues
 
     def _make_observation(self, reward: float = 0.0, done: bool = False):
+        files_list = list(self._state.vfs.keys())
         return DocObservation(
             active_file=self._state.active_file,
             file_content=self._state.vfs.get(self._state.active_file, ""),
-            directory_tree={"/docs": list(self._state.vfs.keys())},
+            directory_tree={"/docs": files_list},
             issues_detected=self._get_linter_issues(),
             terminal_feedback=self._terminal_feedback,
             reward=reward,