🤖 Deploy chat_env environment - 2025-10-20 12:09:32

src/core/env_server/http_server.py

@@ -163,20 +163,22 @@ def create_app(
     env: Environment,
     action_cls: Type[Action],
     observation_cls: Type[Observation],
+    env_name: Optional[str] = None,
 ) -> Any:
     """
-    Create a FastAPI application with web interface enabled for Hugging Face deployments.
+    Create a FastAPI application with or without web interface.
     
-    This function checks for the ENABLE_WEB_INTERFACE environment variable to determine
-    whether to enable the web interface. 
+    This function creates a FastAPI app with the web interface enabled by default,
+    including README integration for better user experience.
     
     Args:
         env: The Environment instance to serve
         action_cls: The Action subclass this environment expects
         observation_cls: The Observation subclass this environment returns
+        env_name: Optional environment name for README loading
         
     Returns:
-        FastAPI application instance with or without web interface based on environment
+        FastAPI application instance with or without web interface and README integration
     """
     # Check if web interface should be enabled
     # This can be controlled via environment variable or build argument
@@ -187,7 +189,7 @@ def create_app(
     if enable_web:
         # Import web interface only when needed
         from .web_interface import create_web_interface_app
-        return create_web_interface_app(env, action_cls, observation_cls)
+        return create_web_interface_app(env, action_cls, observation_cls, env_name)
     else:
         # Use standard FastAPI app without web interface
         return create_fastapi_app(env, action_cls, observation_cls)

src/core/env_server/types.py

@@ -43,3 +43,15 @@ class CodeExecResult:
     stdout: str
     stderr: str
     exit_code: int
+
+
+@dataclass
+class EnvironmentMetadata:
+    """Metadata about an environment for documentation and UI purposes."""
+    
+    name: str
+    description: str
+    readme_content: Optional[str] = None
+    version: Optional[str] = None
+    author: Optional[str] = None
+    documentation_url: Optional[str] = None

src/core/env_server/web_interface.py

@@ -25,7 +25,77 @@ from fastapi.staticfiles import StaticFiles
 from pydantic import BaseModel
 
 from .interfaces import Environment
-from .types import Action, Observation, State
+from .types import Action, Observation, State, EnvironmentMetadata
+
+
+def load_environment_metadata(env: Environment, env_name: Optional[str] = None) -> EnvironmentMetadata:
+    """
+    Load environment metadata including README content.
+    
+    Args:
+        env: The environment instance
+        env_name: Optional environment name for README file lookup
+        
+    Returns:
+        EnvironmentMetadata with loaded information
+    """
+    # Try to get metadata from environment if it has a method for it
+    if hasattr(env, 'get_metadata'):
+        return env.get_metadata()
+    
+    # Default metadata
+    metadata = EnvironmentMetadata(
+        name=env_name or env.__class__.__name__,
+        description=f"{env.__class__.__name__} environment",
+        version="1.0.0"
+    )
+    
+    # Try to load README from file system
+    readme_content = _load_readme_from_filesystem(env_name)
+    if readme_content:
+        metadata.readme_content = readme_content
+    
+    return metadata
+
+
+def _load_readme_from_filesystem(env_name: Optional[str]) -> Optional[str]:
+    """
+    Load README content from the filesystem.
+    
+    Tries multiple locations:
+    1. Container filesystem: /app/README.md
+    2. Local development: src/envs/{env_name}/README.md
+    3. Environment variable: ENV_README_PATH
+    """
+    import os
+    from pathlib import Path
+    
+    # Try container filesystem first
+    container_readme = Path("/app/README.md")
+    if container_readme.exists():
+        try:
+            return container_readme.read_text(encoding='utf-8')
+        except Exception:
+            pass
+    
+    # Try environment variable path
+    custom_path = os.environ.get("ENV_README_PATH")
+    if custom_path and Path(custom_path).exists():
+        try:
+            return Path(custom_path).read_text(encoding='utf-8')
+        except Exception:
+            pass
+    
+    # Try local development path
+    if env_name:
+        local_readme = Path(f"src/envs/{env_name}/README.md")
+        if local_readme.exists():
+            try:
+                return local_readme.read_text(encoding='utf-8')
+            except Exception:
+                pass
+    
+    return None
 
 
 @dataclass
@@ -57,10 +127,15 @@ class WebInterfaceManager:
         env: Environment,
         action_cls: Type[Action],
         observation_cls: Type[Observation],
+        metadata: Optional[EnvironmentMetadata] = None,
     ):
         self.env = env
         self.action_cls = action_cls
         self.observation_cls = observation_cls
+        self.metadata = metadata or EnvironmentMetadata(
+            name=env.__class__.__name__,
+            description=f"{env.__class__.__name__} environment"
+        )
         self.episode_state = EpisodeState(
             episode_id=None,
             step_count=0,
@@ -199,6 +274,7 @@ def create_web_interface_app(
     env: Environment,
     action_cls: Type[Action],
     observation_cls: Type[Observation],
+    env_name: Optional[str] = None,
 ) -> FastAPI:
     """
     Create a FastAPI application with web interface for the given environment.
@@ -207,6 +283,7 @@ def create_web_interface_app(
         env: The Environment instance to serve
         action_cls: The Action subclass this environment expects
         observation_cls: The Observation subclass this environment returns
+        env_name: Optional environment name for README loading
         
     Returns:
         FastAPI application instance with web interface
@@ -216,14 +293,22 @@ def create_web_interface_app(
     # Create the base environment app
     app = create_fastapi_app(env, action_cls, observation_cls)
     
+    # Load environment metadata
+    metadata = load_environment_metadata(env, env_name)
+    
     # Create web interface manager
-    web_manager = WebInterfaceManager(env, action_cls, observation_cls)
+    web_manager = WebInterfaceManager(env, action_cls, observation_cls, metadata)
     
     # Add web interface routes
     @app.get("/web", response_class=HTMLResponse)
     async def web_interface():
         """Serve the web interface."""
-        return get_web_interface_html(action_cls)
+        return get_web_interface_html(action_cls, web_manager.metadata)
+    
+    @app.get("/web/metadata")
+    async def web_metadata():
+        """Get environment metadata."""
+        return asdict(web_manager.metadata)
     
     @app.websocket("/ws")
     async def websocket_endpoint(websocket: WebSocket):
@@ -263,7 +348,7 @@ def create_web_interface_app(
     return app
 
 
-def get_web_interface_html(action_cls: Type[Action]) -> str:
+def get_web_interface_html(action_cls: Type[Action], metadata: Optional[EnvironmentMetadata] = None) -> str:
     """Generate the HTML for the web interface."""
     
     # Check if this is a chat environment by looking for tokens field
@@ -274,30 +359,8 @@ def get_web_interface_html(action_cls: Type[Action]) -> str:
                 is_chat_env = True
                 break
     
-    # Get action fields for dynamic form generation
-    action_fields = []
-    if hasattr(action_cls, '__dataclass_fields__'):
-        for field_name, field_info in action_cls.__dataclass_fields__.items():
-            if field_name != 'metadata':
-                field_type = field_info.type
-                if field_type == str:
-                    input_type = "text"
-                elif field_type == int:
-                    input_type = "number"
-                elif field_type == float:
-                    input_type = "number"
-                elif field_type == bool:
-                    input_type = "checkbox"
-                elif hasattr(field_type, '__name__') and 'Tensor' in field_type.__name__:
-                    input_type = "tensor"
-                else:
-                    input_type = "text"
-                
-                action_fields.append({
-                    'name': field_name,
-                    'type': input_type,
-                    'required': field_info.default is field_info.default_factory
-                })
+    # Get action fields for dynamic form generation with enhanced metadata
+    action_fields = _extract_action_fields(action_cls)
     
     return f"""
 <!DOCTYPE html>
@@ -613,6 +676,210 @@ def get_web_interface_html(action_cls: Type[Action]) -> str:
             border-color: #007bff;
             box-shadow: 0 0 0 2px rgba(0, 123, 255, 0.25);
         }}
+        
+        /* Instructions Section Styles */
+        .instructions-section {{
+            background: white;
+            border: 1px solid #e0e0e0;
+            border-radius: 8px;
+            padding: 20px;
+            margin-bottom: 20px;
+        }}
+        
+        .instructions-header {{
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            margin-bottom: 15px;
+        }}
+        
+        .instructions-title {{
+            font-size: 18px;
+            font-weight: 600;
+            color: #333;
+            margin: 0;
+        }}
+        
+        .instructions-toggle {{
+            background: #f8f9fa;
+            border: 1px solid #dee2e6;
+            border-radius: 4px;
+            padding: 5px 10px;
+            cursor: pointer;
+            font-size: 12px;
+            color: #6c757d;
+        }}
+        
+        .instructions-toggle:hover {{
+            background: #e9ecef;
+        }}
+        
+        .instructions-content {{
+            display: none;
+            max-height: 400px;
+            overflow-y: auto;
+            border-top: 1px solid #e0e0e0;
+            padding-top: 15px;
+        }}
+        
+        .instructions-content.expanded {{
+            display: block;
+        }}
+        
+        .instructions-content h1,
+        .instructions-content h2,
+        .instructions-content h3 {{
+            color: #333;
+            margin-top: 20px;
+            margin-bottom: 10px;
+        }}
+        
+        .instructions-content h1 {{
+            font-size: 24px;
+            border-bottom: 2px solid #007bff;
+            padding-bottom: 10px;
+        }}
+        
+        .instructions-content h2 {{
+            font-size: 20px;
+        }}
+        
+        .instructions-content h3 {{
+            font-size: 16px;
+        }}
+        
+        .instructions-content p {{
+            margin-bottom: 10px;
+            line-height: 1.6;
+        }}
+        
+        .instructions-content code {{
+            background: #f8f9fa;
+            padding: 2px 4px;
+            border-radius: 3px;
+            font-family: monospace;
+            font-size: 14px;
+        }}
+        
+        .instructions-content pre {{
+            background: #f8f9fa;
+            border: 1px solid #e9ecef;
+            border-radius: 4px;
+            padding: 15px;
+            overflow-x: auto;
+            margin: 10px 0;
+        }}
+        
+        .instructions-content pre code {{
+            background: none;
+            padding: 0;
+        }}
+        
+        .instructions-content ul,
+        .instructions-content ol {{
+            margin: 10px 0;
+            padding-left: 20px;
+        }}
+        
+        .instructions-content li {{
+            margin-bottom: 5px;
+        }}
+        
+        .instructions-content table {{
+            border-collapse: collapse;
+            width: 100%;
+            margin: 15px 0;
+        }}
+        
+        .instructions-content th,
+        .instructions-content td {{
+            border: 1px solid #dee2e6;
+            padding: 8px 12px;
+            text-align: left;
+        }}
+        
+        .instructions-content th {{
+            background: #f8f9fa;
+            font-weight: 600;
+        }}
+        
+        /* Enhanced Form Styles */
+        .help-text {{
+            display: block;
+            margin-top: 5px;
+            font-size: 12px;
+            color: #6c757d;
+            font-style: italic;
+        }}
+        
+        .form-group label {{
+            font-weight: 500;
+            color: #333;
+            margin-bottom: 5px;
+        }}
+        
+        .form-group select {{
+            width: 100%;
+            padding: 8px 12px;
+            border: 1px solid #ddd;
+            border-radius: 4px;
+            font-size: 14px;
+            background-color: white;
+        }}
+        
+        .form-group select:focus {{
+            outline: none;
+            border-color: #007bff;
+            box-shadow: 0 0 0 2px rgba(0, 123, 255, 0.25);
+        }}
+        
+        .form-group textarea {{
+            width: 100%;
+            padding: 8px 12px;
+            border: 1px solid #ddd;
+            border-radius: 4px;
+            font-size: 14px;
+            font-family: inherit;
+            resize: vertical;
+        }}
+        
+        .form-group textarea:focus {{
+            outline: none;
+            border-color: #007bff;
+            box-shadow: 0 0 0 2px rgba(0, 123, 255, 0.25);
+        }}
+        
+        .form-group input[type="number"] {{
+            width: 100%;
+            padding: 8px 12px;
+            border: 1px solid #ddd;
+            border-radius: 4px;
+            font-size: 14px;
+        }}
+        
+        .form-group input[type="number"]:focus {{
+            outline: none;
+            border-color: #007bff;
+            box-shadow: 0 0 0 2px rgba(0, 123, 255, 0.25);
+        }}
+        
+        .form-group input[type="text"]:focus {{
+            outline: none;
+            border-color: #007bff;
+            box-shadow: 0 0 0 2px rgba(0, 123, 255, 0.25);
+        }}
+        
+        .required-indicator {{
+            color: #dc3545;
+            font-weight: bold;
+        }}
+        
+        .form-group .field-description {{
+            font-size: 11px;
+            color: #666;
+            margin-top: 2px;
+            font-style: italic;
+        }}
     </style>
 </head>
 <body>
@@ -624,6 +891,9 @@ def get_web_interface_html(action_cls: Type[Action]) -> str:
                 HumanAgent Interface
             </div>
             <div class="pane-content">
+                <!-- Instructions Section -->
+                {_generate_instructions_section(metadata)}
+                
                 <!-- Action Form or Chat Interface -->
                 {_generate_action_interface(action_fields, is_chat_env)}
                 
@@ -725,6 +995,17 @@ def get_web_interface_html(action_cls: Type[Action]) -> str:
             }}
             
             setupEventListeners() {{
+                // Instructions toggle
+                const instructionsToggle = document.getElementById('instructions-toggle');
+                const instructionsContent = document.getElementById('instructions-content');
+                if (instructionsToggle && instructionsContent) {{
+                    instructionsToggle.addEventListener('click', () => {{
+                        instructionsContent.classList.toggle('expanded');
+                        instructionsToggle.textContent = instructionsContent.classList.contains('expanded') 
+                            ? 'Hide Instructions' : 'Show Instructions';
+                    }});
+                }}
+                
                 // Check if this is a chat environment
                 const isChatEnv = document.getElementById('chat-messages') !== null;
                 
@@ -974,6 +1255,206 @@ def get_web_interface_html(action_cls: Type[Action]) -> str:
     """.replace('{_generate_action_form_fields(action_fields)}', _generate_action_form_fields(action_fields))
 
 
+def _generate_instructions_section(metadata: Optional[EnvironmentMetadata]) -> str:
+    """Generate the instructions section with environment documentation."""
+    if not metadata or not metadata.readme_content:
+        return ''
+    
+    # Convert markdown to HTML (basic conversion)
+    import re
+    html_content = _markdown_to_html(metadata.readme_content)
+    
+    return f'''
+                <!-- Instructions Section -->
+                <div class="instructions-section">
+                    <div class="instructions-header">
+                        <h3 class="instructions-title">{metadata.name}</h3>
+                        <button class="instructions-toggle" id="instructions-toggle">Show Instructions</button>
+                    </div>
+                    <div class="instructions-content" id="instructions-content">
+                        <div class="instructions-readme">
+                            {html_content}
+                        </div>
+                    </div>
+                </div>
+    '''
+
+
+def _extract_action_fields(action_cls: Type[Action]) -> List[Dict[str, Any]]:
+    """Extract enhanced field metadata from Action class for form generation."""
+    import typing
+    from typing import get_origin, get_args
+    
+    action_fields = []
+    if not hasattr(action_cls, '__dataclass_fields__'):
+        return action_fields
+    
+    for field_name, field_info in action_cls.__dataclass_fields__.items():
+        if field_name == 'metadata':
+            continue
+            
+        field_type = field_info.type
+        field_metadata = _extract_field_metadata(field_name, field_info)
+        
+        # Determine input type based on field type
+        input_type = _determine_input_type(field_type)
+        
+        # Check if field is required
+        is_required = field_info.default is field_info.default_factory
+        
+        action_fields.append({
+            'name': field_name,
+            'type': input_type,
+            'required': is_required,
+            'description': field_metadata.get('description', ''),
+            'default_value': field_metadata.get('default_value'),
+            'choices': field_metadata.get('choices', []),
+            'min_value': field_metadata.get('min_value'),
+            'max_value': field_metadata.get('max_value'),
+            'placeholder': field_metadata.get('placeholder', ''),
+            'help_text': field_metadata.get('help_text', ''),
+        })
+    
+    return action_fields
+
+
+def _extract_field_metadata(field_name: str, field_info) -> Dict[str, Any]:
+    """Extract metadata from dataclass field including docstring and type hints."""
+    import typing
+    from typing import get_origin, get_args, Literal, Union, Optional
+    
+    metadata = {}
+    
+    # Extract description from field docstring or annotation
+    if hasattr(field_info, 'metadata') and field_info.metadata:
+        # Check for custom metadata
+        for meta in field_info.metadata:
+            if isinstance(meta, dict):
+                metadata.update(meta)
+    
+    # Extract type information
+    field_type = field_info.type
+    origin = get_origin(field_type)
+    
+    # Handle Literal types for dropdown choices
+    if origin is Literal:
+        args = get_args(field_type)
+        metadata['choices'] = list(args)
+    
+    # Handle Optional types
+    if origin is Union:
+        args = get_args(field_type)
+        if len(args) == 2 and type(None) in args:
+            # This is Optional[SomeType]
+            non_none_type = args[0] if args[1] is type(None) else args[1]
+            metadata['optional'] = True
+            # Recursively check the non-None type for choices
+            if get_origin(non_none_type) is Literal:
+                metadata['choices'] = list(get_args(non_none_type))
+        else:
+            # Regular Union type
+            metadata['choices'] = [str(arg) for arg in args if arg is not type(None)]
+    
+    # Handle numeric constraints
+    if field_type in (int, float):
+        # Check for common constraint patterns in field name
+        if 'count' in field_name.lower() or 'num' in field_name.lower():
+            metadata['min_value'] = 0
+        if 'id' in field_name.lower():
+            metadata['min_value'] = 0
+    
+    # Generate placeholder text
+    if 'message' in field_name.lower():
+        metadata['placeholder'] = f'Enter {field_name.replace("_", " ")}...'
+    elif 'code' in field_name.lower():
+        metadata['placeholder'] = 'Enter Python code here...'
+    elif 'tokens' in field_name.lower():
+        metadata['placeholder'] = 'Enter comma-separated token IDs (e.g., 1,2,3,4,5)'
+    else:
+        metadata['placeholder'] = f'Enter {field_name.replace("_", " ")}...'
+    
+    # Generate help text based on field name and type
+    if 'action_id' in field_name.lower():
+        metadata['help_text'] = 'The action ID to execute in the environment'
+    elif 'game_name' in field_name.lower():
+        metadata['help_text'] = 'Name of the game or environment'
+    elif 'tokens' in field_name.lower():
+        metadata['help_text'] = 'Token IDs as a comma-separated list of integers'
+    elif 'code' in field_name.lower():
+        metadata['help_text'] = 'Python code to execute in the environment'
+    elif 'message' in field_name.lower():
+        metadata['help_text'] = 'Text message to send'
+    
+    return metadata
+
+
+def _determine_input_type(field_type) -> str:
+    """Determine the appropriate HTML input type for a field type."""
+    import typing
+    from typing import get_origin, get_args, Literal, Union
+    
+    # Handle direct types
+    if field_type == str:
+        return "text"
+    elif field_type == int:
+        return "number"
+    elif field_type == float:
+        return "number"
+    elif field_type == bool:
+        return "checkbox"
+    
+    # Handle complex types
+    origin = get_origin(field_type)
+    
+    if origin is Literal:
+        return "select"
+    elif origin is Union:
+        args = get_args(field_type)
+        if len(args) == 2 and type(None) in args:
+            # Optional type - use the non-None type
+            non_none_type = args[0] if args[1] is type(None) else args[1]
+            return _determine_input_type(non_none_type)
+        elif all(isinstance(arg, str) for arg in args if arg is not type(None)):
+            return "select"
+        else:
+            return "text"
+    elif hasattr(field_type, '__name__') and 'Tensor' in field_type.__name__:
+        return "tensor"
+    else:
+        return "text"
+
+
+def _markdown_to_html(markdown: str) -> str:
+    """Convert basic markdown to HTML for README display."""
+    import html
+    import re
+    
+    # Escape HTML first
+    html_content = html.escape(markdown)
+    
+    # Convert headers
+    html_content = re.sub(r'^# (.*?)$', r'<h1>\1</h1>', html_content, flags=re.MULTILINE)
+    html_content = re.sub(r'^## (.*?)$', r'<h2>\1</h2>', html_content, flags=re.MULTILINE)
+    html_content = re.sub(r'^### (.*?)$', r'<h3>\1</h3>', html_content, flags=re.MULTILINE)
+    
+    # Convert code blocks
+    html_content = re.sub(r'```(.*?)\n(.*?)\n```', r'<pre><code>\2</code></pre>', html_content, flags=re.DOTALL)
+    html_content = re.sub(r'`([^`]+)`', r'<code>\1</code>', html_content)
+    
+    # Convert bold and italic
+    html_content = re.sub(r'\*\*(.*?)\*\*', r'<strong>\1</strong>', html_content)
+    html_content = re.sub(r'\*(.*?)\*', r'<em>\1</em>', html_content)
+    
+    # Convert lists
+    html_content = re.sub(r'^- (.*?)$', r'<li>\1</li>', html_content, flags=re.MULTILINE)
+    html_content = re.sub(r'(<li>.*</li>)', r'<ul>\1</ul>', html_content, flags=re.DOTALL)
+    
+    # Convert line breaks
+    html_content = html_content.replace('\n', '<br>')
+    
+    return html_content
+
+
 def _generate_action_interface(action_fields: List[Dict[str, Any]], is_chat_env: bool) -> str:
     """Generate either a chat interface or action form based on environment type."""
     if is_chat_env:
@@ -1023,42 +1504,103 @@ def _generate_action_form(action_fields: List[Dict[str, Any]]) -> str:
     '''
 
 def _generate_action_form_fields(action_fields: List[Dict[str, Any]]) -> str:
-    """Generate HTML form fields for action input."""
+    """Generate HTML form fields for action input with enhanced metadata."""
     if not action_fields:
         return '<p>No action fields available</p>'
     
     fields_html = []
     for field in action_fields:
-        if field['type'] == 'checkbox':
-            fields_html.append(f'''
-                <div class="form-group">
-                    <label>
-                        <input type="checkbox" name="{field['name']}" value="true">
-                        {field['name']}
-                    </label>
-                </div>
-            ''')
-        elif field['type'] == 'tensor':
-            fields_html.append(f'''
-                <div class="form-group">
-                    <label for="{field['name']}">{field['name']} (comma-separated integers):</label>
-                    <input type="text" name="{field['name']}" id="{field['name']}" placeholder="e.g., 1,2,3,4,5" {"required" if field['required'] else ""}>
-                    <small>Enter token IDs as comma-separated integers</small>
-                </div>
-            ''')
-        elif field['type'] == 'text' and 'message' in field['name'].lower():
-            fields_html.append(f'''
-                <div class="form-group">
-                    <label for="{field['name']}">{field['name']}:</label>
-                    <textarea name="{field['name']}" id="{field['name']}" rows="3" placeholder="Enter {field['name']}..."></textarea>
-                </div>
-            ''')
-        else:
-            fields_html.append(f'''
-                <div class="form-group">
-                    <label for="{field['name']}">{field['name']}:</label>
-                    <input type="{field['type']}" name="{field['name']}" id="{field['name']}" placeholder="Enter {field['name']}..." {"required" if field['required'] else ""}>
-                </div>
-            ''')
+        field_html = _generate_single_field(field)
+        fields_html.append(field_html)
     
     return '\n'.join(fields_html)
+
+
+def _generate_single_field(field: Dict[str, Any]) -> str:
+    """Generate HTML for a single form field with enhanced metadata."""
+    field_name = field['name']
+    field_type = field['type']
+    required = field['required']
+    placeholder = field.get('placeholder', '')
+    help_text = field.get('help_text', '')
+    choices = field.get('choices', [])
+    min_value = field.get('min_value')
+    max_value = field.get('max_value')
+    default_value = field.get('default_value')
+    
+    # Build label with required indicator
+    label_text = field_name.replace('_', ' ').title()
+    if required:
+        label_text += ' <span style="color: red;">*</span>'
+    
+    # Build input attributes
+    input_attrs = []
+    if required:
+        input_attrs.append('required')
+    if placeholder:
+        input_attrs.append(f'placeholder="{placeholder}"')
+    if min_value is not None:
+        input_attrs.append(f'min="{min_value}"')
+    if max_value is not None:
+        input_attrs.append(f'max="{max_value}"')
+    if default_value is not None:
+        input_attrs.append(f'value="{default_value}"')
+    
+    attrs_str = ' '.join(input_attrs)
+    
+    if field_type == 'checkbox':
+        return f'''
+            <div class="form-group">
+                <label>
+                    <input type="checkbox" name="{field_name}" value="true" {attrs_str}>
+                    {label_text}
+                </label>
+                {f'<small class="help-text">{help_text}</small>' if help_text else ''}
+            </div>
+        '''
+    
+    elif field_type == 'select':
+        options_html = []
+        if not required:
+            options_html.append(f'<option value="">-- Select {label_text} --</option>')
+        
+        for choice in choices:
+            selected = 'selected' if str(choice) == str(default_value) else ''
+            options_html.append(f'<option value="{choice}" {selected}>{choice}</option>')
+        
+        return f'''
+            <div class="form-group">
+                <label for="{field_name}">{label_text}:</label>
+                <select name="{field_name}" id="{field_name}" {attrs_str}>
+                    {''.join(options_html)}
+                </select>
+                {f'<small class="help-text">{help_text}</small>' if help_text else ''}
+            </div>
+        '''
+    
+    elif field_type == 'tensor':
+        return f'''
+            <div class="form-group">
+                <label for="{field_name}">{label_text} (comma-separated integers):</label>
+                <input type="text" name="{field_name}" id="{field_name}" {attrs_str}>
+                <small class="help-text">{help_text or 'Enter token IDs as comma-separated integers (e.g., 1,2,3,4,5)'}</small>
+            </div>
+        '''
+    
+    elif field_type == 'text' and ('message' in field_name.lower() or 'code' in field_name.lower()):
+        return f'''
+            <div class="form-group">
+                <label for="{field_name}">{label_text}:</label>
+                <textarea name="{field_name}" id="{field_name}" rows="3" {attrs_str}></textarea>
+                {f'<small class="help-text">{help_text}</small>' if help_text else ''}
+            </div>
+        '''
+    
+    else:
+        return f'''
+            <div class="form-group">
+                <label for="{field_name}">{label_text}:</label>
+                <input type="{field_type}" name="{field_name}" id="{field_name}" {attrs_str}>
+                {f'<small class="help-text">{help_text}</small>' if help_text else ''}
+            </div>
+        '''

src/envs/chat_env/server/Dockerfile

@@ -17,6 +17,9 @@ RUN pip install torch transformers
 COPY src/core/ /app/src/core/
 COPY src/envs/chat_env/ /app/src/envs/chat_env/
 
+# Copy README for web interface documentation
+COPY src/envs/chat_env/README.md /app/README.md
+
 # Environment variables that can be overridden at runtime
 ENV TOKENIZER_NAME=gpt2
 ENV SYSTEM_PROMPT="You are a helpful AI assistant."

src/envs/chat_env/server/app.py

@@ -27,6 +27,7 @@ Usage:
 import os
 
 from core.env_server import create_app
+from core.env_server.web_interface import create_web_interface_app
 
 from ..models import ChatAction, ChatObservation
 from .chat_environment import ChatEnvironment
@@ -67,8 +68,8 @@ system_prompt = os.environ.get("SYSTEM_PROMPT", None)
 tokenizer = get_tokenizer()
 env = ChatEnvironment(tokenizer=tokenizer, system_prompt=system_prompt)
 
-# Create the FastAPI app with routes
-app = create_app(env, ChatAction, ChatObservation)
+# Create the FastAPI app with web interface and README integration
+app = create_app(env, ChatAction, ChatObservation, env_name="chat_env")
 
 
 if __name__ == "__main__":