DocSweeper v1

.dockerignore

@@ -0,0 +1,15 @@
+.venv
+.git
+.gitignore
+.env
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+*.pyw
+*.pyz
+*.pywz
+*.pyzw
+*.pyzwz
+
+

.gitignore

@@ -0,0 +1,10 @@
+# Python-generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+
+# Virtual environments
+.venv

.python-version

@@ -0,0 +1 @@
+3.10

Dockerfile

@@ -0,0 +1,19 @@
+FROM python:3.11-slim
+
+WORKDIR /app/env
+
+RUN apt-get update && apt-get install -y \
+    git \
+    && rm -rf /var/lib/apt/lists/*
+
+COPY . .
+
+RUN pip install --no-cache-dir -r requirements.txt
+
+EXPOSE 8000
+
+ENV PYTHONUNBUFFERED=1
+ENV ENABLE_WEB_INTERFACE=true
+ENV PYTHONPATH="/app/env:$PYTHONPATH"
+
+CMD ["python", "-m", "uvicorn", "server.app:app", "--host", "0.0.0.0", "--port", "8000"]

README.md

@@ -0,0 +1,129 @@
+# Doc Sweeper Environment
+
+A virtual file system and text-editing environment for OpenEnv. This environment tasks autonomous LLM agents with acting as automated documentation engineers, requiring them to navigate a directory tree, read files, and apply precise string manipulations to complete complex refactoring tasks.
+
+## Overview
+
+The Doc Sweeper environment provides a sandboxed, in-memory file system where agents can interact with dummy codebases and documentation. It evaluates an agent's ability to retain context, plan multi-step operations, and use tools correctly.
+
+### Features
+
+* **Virtual File System**: In-memory directory tree with nested files.
+* **Strict Tooling**: Requires agents to explicitly `open` files before applying `edit` commands.
+* **Granular Feedback**: Provides immediate terminal feedback and linter issues upon illegal actions or formatting errors.
+* **Three Distinct Scenarios**: Evaluates different logic flows (global search/replace, YAML refactoring, path resolution).
+
+### Task Rules
+
+The environment supports three primary tasks:
+
+* `version_bump`: The agent must find all outdated version numbers (e.g., `v1.0.0` or `v1.00`) across all files and update them to `v2.0.0`.
+* `config_migration`: The agent must open docker-compose files, update the version to `3.8`, and migrate `links` keys to `networks`.
+* `broken_links`: The agent must find broken relative markdown links and edit them to point to correct file paths.
+
+---
+
+## Quick Start
+
+### Running the Baseline Inference (Recommended)
+
+The easiest way to test the environment is using the provided Chain-of-Thought agent script.
+
+```bash
+# Export your required credentials
+export HF_TOKEN="your_api_key_here"
+export API_BASE_URL="[https://api.openai.com/v1](https://api.openai.com/v1)"
+export MODEL_NAME="gpt-4o-mini"
+```
+
+# Run the inference script across all tasks
+python inference.py
+
+## Using Local Server
+You can host the environment locally to manually test the API endpoints.
+
+```bash
+# Install dependencies
+pip install -r requirements.txt
+```
+
+
+# Run server
+```bash
+python -m uvicorn server.app:app --host 0.0.0.0 --port 8000
+```
+## Actions
+
+The action space is defined by the `DocAction` schema. The agent must provide a single JSON object with a `tool_name` and the corresponding required fields:
+
+* **`open`**: Opens a file. Requires the `path` parameter.
+* **`edit`**: Replaces text in the currently active file. Requires exact string matching via `old_str` and `new_str`.
+* **`grep`**: Searches the active file (or directory). Requires `search_query`.
+* **`done`**: Signals that the task is complete.
+
+## Observations
+
+Each observation (`DocObservation`) returned by the environment includes:
+
+* **`active_file`**: The file currently opened by the agent.
+* **`terminal_feedback`**: Error messages, success logs, or system alerts resulting from the last action.
+* **`directory_tree`**: A JSON representation of the current file system hierarchy.
+* **`file_content`**: The textual content of the currently active file.
+* **`issues_detected`**: A list of simulated linter errors (if the agent breaks a file's formatting).
+
+## Configuration
+
+### Reward Structure
+
+The environment issues rewards based on the agent's efficiency and accuracy:
+
+* **Valid Tool Usage**: `0.0` (Neutral, but advances the state).
+* **Tool Misuse Penalty**: `-0.1` (e.g., trying to edit without opening a file, or providing a bad file path).
+* **Task Completion**: `1.0` (Awarded only when `done` is called and all objective checks pass).
+* **Early/Failed Completion**: `-1.0` (Calling `done` before fixing all required strings).
+
+## Building and Deployment
+
+### Build Docker Image
+
+From the repository root:
+
+# Build the environment image
+
+```bash
+docker build -t doc-sweeper-env:latest .
+```
+
+The Dockerfile uses pip install with requirements.txt for maximum compatibility with Hugging Face Spaces.
+
+# Run the container locally
+
+```bash
+docker run -p 8000:8000 doc-sweeper-env:latest
+```
+The FastAPI OpenEnv endpoints will be available at `http://localhost:8000/reset` and `http://localhost:8000/step`.
+
+---
+
+## Dependencies
+
+The Doc Sweeper environment requires:
+
+* **`fastapi` & `uvicorn`**: For serving the OpenEnv endpoints.
+* **`pydantic`**: For strict action and observation schema validation.
+* **`openai` / `groq`**: For the baseline LLM inference script.
+
+These are automatically installed when using Docker or installing via `pip install -r requirements.txt`.
+
+---
+
+## Example Evaluation Log Output
+
+When running `inference.py`, the agent emits strictly formatted logs for the automated graders:
+
+```text
+[START] task=version_bump model=gpt-4o-mini
+[STEP] step=1 action=open reward=0.00 done=False thought="Opening setup.md to check for versions."
+[STEP] step=2 action=edit reward=0.00 done=False thought="Replacing v1.0.0 with v2.0.0."
+[STEP] step=3 action=done reward=1.00 done=True thought="All files have been checked."
+[END] task=version_bump score=1.00 total_steps=3 runtime_seconds=4.2

__init__.py

@@ -0,0 +1,17 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+"""Cust Env Environment."""
+
+from client import DocSweeperEnv
+from models import DocAction, DocObservation, DocState
+
+__all__ = [
+    "DocSweeperEnv",
+    "DocObservation",
+    "DocAction",
+    "DocState"
+]

client.py

@@ -0,0 +1,101 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+"""
+Doc Sweeper Environment Client.
+
+This module provides the client for connecting to a Doc Sweeper Environment server
+via WebSocket for persistent sessions.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Dict
+
+from openenv.core.client_types import StepResult
+from openenv.core.env_client import EnvClient
+
+from models import DocAction, DocObservation, DocState
+
+
+class DocSweeperEnv(EnvClient[DocAction, DocObservation, DocState]):
+    """
+    Client for Doc Sweeper Environment.
+
+    This client maintains a persistent WebSocket connection to the environment
+    server, enabling efficient multi-step interactions with lower latency.
+
+    Example:
+        >>> with DocSweeperEnv(base_url="http://localhost:8000") as client:
+        ...     result = client.reset()
+        ...     print(result.observation.terminal_feedback)
+        ...
+        ...     result = client.step(DocAction(tool_name="open", path="/docs/setup.md"))
+        ...     print(result.observation.file_content)
+    """
+
+    def _step_payload(self, action: DocAction) -> Dict[str, Any]:
+        """
+        Convert DocAction to JSON payload for step request.
+
+        Args:
+            action: DocAction instance with tool parameters.
+
+        Returns:
+            Dictionary representation suitable for JSON encoding.
+        """
+        return {
+            "tool_name": action.tool_name,
+            "path": action.path,
+            "old_str": action.old_str,
+            "new_str": action.new_str,
+            "search_query": action.search_query,
+        }
+
+    def _parse_result(self, payload: Dict[str, Any]) -> StepResult[DocObservation]:
+        """
+        Parse server response into StepResult[DocObservation].
+
+        Args:
+            payload: JSON response from server.
+
+        Returns:
+            StepResult with DocObservation.
+        """
+        obs_data = payload.get("observation", {})
+
+        observation = DocObservation(
+            active_file=obs_data.get("active_file", ""),
+            file_content=obs_data.get("file_content", ""),
+            directory_tree=obs_data.get("directory_tree", {}),
+            issues_detected=obs_data.get("issues_detected", []),
+            terminal_feedback=obs_data.get("terminal_feedback", ""),
+            done=obs_data.get("done", False),
+            reward=obs_data.get("reward", 0.0),
+        )
+
+        return StepResult(
+            observation=observation,
+            reward=observation.reward,
+            done=observation.done,
+        )
+
+    def _parse_state(self, payload: Dict[str, Any]) -> DocState:
+        """
+        Parse server response into DocState object.
+
+        Args:
+            payload: JSON response from /state endpoint.
+
+        Returns:
+            DocState object with environment state information.
+        """
+        return DocState(
+            episode_id=payload.get("episode_id", ""),
+            step_count=payload.get("step_count", 0),
+            vfs=payload.get("vfs", {}),
+            active_file=payload.get("active_file", ""),
+        )

inference.py

@@ -0,0 +1,118 @@
+"""Inference script for the Doc Sweeper Environment."""
+
+import os
+import json
+import time
+from openai import OpenAI
+from server.cust_env_environment import DocSweeperEnvironment
+from models import DocAction
+
+def run_inference(task_name: str):
+
+    api_base_url = os.environ.get("API_BASE_URL")
+    model_name = os.environ.get("MODEL_NAME")
+    hf_token = os.environ.get("HF_TOKEN")
+
+    if not all([api_base_url, model_name, hf_token]):
+        raise ValueError("Missing required environment variables: API_BASE_URL, MODEL_NAME, or HF_TOKEN")
+
+
+    client = OpenAI(
+        api_key=hf_token,
+        base_url=api_base_url
+    )
+    
+    env = DocSweeperEnvironment(task=task_name)
+    obs = env.reset()
+    done = False
+    total_reward = 0.0
+    step_count = 0
+    
+
+    print(f"[START] task={task_name} model={model_name}")
+
+    system_prompt = f"""
+    You are an elite, systematic documentation engineer. You interact with a virtual file system via JSON tool calls.
+    
+    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.
+    
+    WORKFLOW RULES:
+    1. PLAN FIRST: Use the 'thought' field to track which files you have checked and which remain.
+    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.
+    
+    OUTPUT SCHEMA:
+    You MUST output ONLY a single raw JSON object EXACTLY matching this structure:
+    {{
+        "thought": "<Mandatory step-by-step reasoning>",
+        "tool_name": "<MUST be one of: 'open', 'edit', 'grep', 'done'>",
+        "path": "<Optional. File path for 'open'>",
+        "old_str": "<Optional. Exact match string for 'edit'>",
+        "new_str": "<Optional. Replacement string for 'edit'>",
+        "search_query": "<Optional. Text to search for 'grep'>"
+    }}
+    """
+    
+    messages = [{"role": "system", "content": system_prompt}]
+    
+    start_time = time.time()
+
+    while not done:
+        step_count += 1
+        current_state_prompt = f"""
+        [ENVIRONMENT OBSERVATION]
+        Active File: {obs.active_file or 'None'}
+        Terminal Feedback: {obs.terminal_feedback}
+        Directory Tree: {json.dumps(obs.directory_tree)}
+        File Content: {obs.file_content}
+        Linter Issues: {obs.issues_detected}
+        """
+        messages.append({"role": "user", "content": current_state_prompt})
+        
+        try:
+            response = client.chat.completions.create(
+                model=model_name,
+                messages=messages,
+                response_format={"type": "json_object"}
+            )
+            
+            raw_reply = response.choices[0].message.content
+            messages.append({"role": "assistant", "content": raw_reply})
+            
+            action_json = json.loads(raw_reply)
+            if isinstance(action_json, list):
+                action_json = action_json[0] if len(action_json) > 0 else {"tool_name": "done"}
+                
+            thought = action_json.pop("thought", "None")
+            
+            valid_fields = DocAction.model_fields.keys() 
+            safe_kwargs = {k: v for k, v in action_json.items() if k in valid_fields}
+            
+            action = DocAction(**safe_kwargs)
+            obs = env.step(action)
+            total_reward += obs.reward
+            done = obs.done
+
+
+            print(f"[STEP] step={step_count} action={action.tool_name} reward={obs.reward:.2f} done={done} thought=\"{thought[:100]}...\"")
+            
+        except Exception as e:
+            obs.terminal_feedback = f"SYSTEM ERROR: {str(e)}. Review the schema rules."
+            print(f"[STEP] step={step_count} action=error reward=0.0 done={done} error=\"{str(e)}\"")
+
+    runtime = time.time() - start_time
+
+
+    final_score = max(0.0, min(1.0, total_reward))
+    
+    print(f"[END] task={task_name} score={final_score:.2f} total_steps={step_count} runtime_seconds={runtime:.1f}")
+
+
+if __name__ == "__main__":
+    tasks = ["version_bump", "config_migration", "broken_links"]
+    for task in tasks:
+        run_inference(task)

main.py

@@ -0,0 +1,6 @@
+def main():
+    print("Hello from cust-env!")
+
+
+if __name__ == "__main__":
+    main()

models.py

@@ -0,0 +1,77 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+"""
+Data models for Doc Sweeper Environment.
+
+This module defines the Action, Observation, and State types for the documentation
+maintenance tasks via the OpenEnv interface.
+"""
+
+from __future__ import annotations
+
+from typing import Dict, List, Optional
+
+from openenv.core.env_server import Action, Observation, State
+from pydantic import Field
+
+
+class DocAction(Action):
+    """
+    Action for Doc Sweeper environment.
+
+    Attributes:
+        tool_name: The command to run ('open', 'edit', 'grep', 'done').
+        path: File path for opening or editing.
+        old_str: Exact match string for safe replacement.
+        new_str: Replacement string.
+        search_query: String to search via grep.
+    """
+
+    tool_name: str = Field(..., description="'open', 'edit', 'grep', or 'done'")
+    path: Optional[str] = Field(None, description="File path for open/edit/grep")
+    old_str: Optional[str] = Field(None, description="Exact match string for safe replacement")
+    new_str: Optional[str] = Field(None, description="Replacement string")
+    search_query: Optional[str] = Field(None, description="String to search via grep")
+
+
+class DocObservation(Observation):
+    """
+    Observation for Doc Sweeper environment.
+
+    Attributes:
+        active_file: Currently opened file path.
+        file_content: Full text of the opened file.
+        directory_tree: Virtual File System tree representation.
+        issues_detected: Linter output for current file.
+        terminal_feedback: Result of last action.
+        done: Whether the task is complete.
+        reward: Reward for the last action.
+    """
+
+    active_file: str = ""
+    file_content: str = ""
+    directory_tree: Dict[str, List[str]] = Field(default_factory=dict)
+    issues_detected: List[str] = Field(default_factory=list)
+    terminal_feedback: str = "Environment initialized."
+    done: bool = False
+
+
+class DocState(State):
+    """
+    State for Doc Sweeper environment.
+
+    Attributes:
+        episode_id: Unique ID for the current task session.
+        step_count: Number of actions taken.
+        vfs: The current state of the virtual file system (hidden from direct observation).
+        active_file: The file currently open in the editor.
+    """
+
+    episode_id: str = ""
+    step_count: int = 0
+    vfs: Dict[str, str] = Field(default_factory=dict)
+    active_file: str = ""

openenv.yaml

@@ -0,0 +1,7 @@
+spec_version: 1
+name: cust_env
+type: space
+runtime: fastapi
+app: server.app:app
+port: 8000
+

pyproject.toml

@@ -0,0 +1,15 @@
+[project]
+name = "cust-env"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+    "fastapi>=0.135.2",
+    "groq>=1.1.2",
+    "openai>=2.29.0",
+    "openenv-core>=0.2.3",
+    "openenv[core]>=0.1.13",
+    "pydantic>=2.12.5",
+    "uvicorn>=0.42.0",
+]

requirements.txt

@@ -0,0 +1,5 @@
+openenv-core
+fastapi 
+uvicorn 
+pydantic 
+openai

server/__init__.py

@@ -0,0 +1,11 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+"""Cust Env environment server components."""
+
+from .cust_env_environment import DocSweeperEnvironment
+
+__all__ = ["DocSweeperEnvironment"]

server/app.py

@@ -0,0 +1,21 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+"""FastAPI application for the Doc Sweeper Environment."""
+
+from openenv.core.env_server import create_app
+
+from models import DocAction, DocObservation
+from .cust_env_environment import DocSweeperEnvironment
+
+# Create the FastAPI app
+# Pass the class (factory) instead of an instance for WebSocket session support
+app = create_app(DocSweeperEnvironment, DocAction, DocObservation, env_name="doc_sweeper")
+
+if __name__ == "__main__":
+    import uvicorn
+
+    uvicorn.run(app, host="0.0.0.0", port=8000)

server/cust_env_environment.py

@@ -0,0 +1,193 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+"""
+Doc Sweeper Environment for OpenEnv.
+
+This module provides an environment where an agent navigates a virtual file system
+to fix outdated documentation, broken links, and deprecated configurations.
+"""
+
+import uuid
+from typing import Dict, List
+
+from openenv.core.env_server import Environment
+
+from models import DocAction, DocObservation, DocState
+
+
+class DocSweeperEnvironment(Environment):
+    """
+    Doc Sweeper environment implementing the OpenEnv interface.
+
+    Simulates a Virtual File System (VFS) of markdown and config files. The agent
+    must find and replace deprecated patterns without destructive behavior.
+    """
+
+    def __init__(
+        self,
+        task: str = "version_bump",
+        max_steps: int = 30,
+    ):
+        """
+        Initialize the Doc Sweeper environment.
+
+        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.reset()
+
+    def reset(self, **kwargs):
+        """
+        Initialize a new task episode.
+
+        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."
+            }
+        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: 
+            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)."
+            }
+
+        self._state = DocState(
+            episode_id=episode_id,
+            step_count=0,
+            vfs=initial_vfs,
+            active_file=""
+        )
+
+        return self._make_observation(reward=0.0, done=False)
+
+    def step(self, action: DocAction):
+        """
+        Execute an action and return the resulting state.
+
+        Args:
+            action: The tool action to execute (open, edit, grep, done).
+
+        Returns:
+            Observation with reward and done flag.
+        """
+        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
+        if action.tool_name == "done":
+            done = True
+            reward += self._evaluate_final_grade()
+            self._terminal_feedback = "Task submitted for final grading."
+            
+        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
+                
+        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."
+                
+        elif action.tool_name == "edit":
+            reward += self._handle_edit(action)
+            
+        else:
+            self._terminal_feedback = f"Error: Unknown tool {action.tool_name}."
+            reward -= 0.1
+
+        # Check timeout
+        if self._state.step_count >= self._max_steps:
+            done = True
+            self._terminal_feedback = "Max steps reached."
+            
+        return self._make_observation(reward=reward, done=done)
+
+    def _handle_edit(self, action: DocAction) -> float:
+        if not self._state.active_file:
+            self._terminal_feedback = "Error: No file is currently open."
+            return -0.1
+            
+        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
+            
+        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 "")
+            self._terminal_feedback = "Edit successful."
+            return 0.1
+        else:
+            self._terminal_feedback = f"Error: old_str '{action.old_str}' not found in file."
+            return -0.1
+
+    def _evaluate_final_grade(self) -> float:
+        # Simplified deterministic grader for example purposes
+        text = "".join(self._state.vfs.values())
+        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
+
+    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.")
+        return issues
+
+    def _make_observation(self, reward: float = 0.0, done: bool = False):
+        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())},
+            issues_detected=self._get_linter_issues(),
+            terminal_feedback=self._terminal_feedback,
+            reward=reward,
+            done=done,
+        )
+
+    @property
+    def state(self):
+        """Return the current episode state."""
+        return self._state