Upload 4 files

Dockerfile

@@ -0,0 +1,18 @@
+FROM python:3.10-slim
+
+WORKDIR /app
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy the environment source
+COPY . .
+
+# Set environment variables for HF Spaces / Gradio
+ENV PYTHONUNBUFFERED=1
+ENV PYTHONPATH=/app
+
+EXPOSE 7860
+
+# Run the Gradio configuration app to interact with/view the environment
+CMD ["python", "app.py"]

app.py

@@ -0,0 +1,127 @@
+import multiprocessing
+import uvicorn
+from fastapi import FastAPI, Request
+from fastapi.responses import JSONResponse
+import gradio as gr
+import json
+import logging
+from core.environment import EmailOpsEnv
+from core.models import Action
+
+# Setup logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+app = FastAPI(title="OpenEnv - EmailOps API")
+env = EmailOpsEnv()
+
+# --- FastAPI Endpoints ---
+
+@app.post("/reset")
+async def reset(request: Request):
+    """Reset the environment with a specific task."""
+    try:
+        data = await request.json()
+        task_id = data.get("task_id", "easy")
+        obs = env.reset(task_id)
+        logger.info(f"Environment reset with task: {task_id}")
+        return obs.model_dump()
+    except Exception as e:
+        logger.error(f"Error resetting environment: {e}")
+        return JSONResponse(status_code=500, content={"detail": str(e)})
+
+@app.post("/step")
+async def step(request: Request):
+    """Take a step in the environment."""
+    try:
+        action_data = await request.json()
+        action = Action(**action_data)
+        obs, reward, done, metrics = env.step(action)
+        return {
+            "obs": obs.model_dump(),
+            "reward": reward,
+            "done": done,
+            "metrics": metrics
+        }
+    except Exception as e:
+        logger.error(f"Error stepping environment: {e}")
+        return JSONResponse(status_code=500, content={"detail": str(e)})
+
+@app.get("/state")
+async def state():
+    """Get the current state of the environment."""
+    return env.state().model_dump()
+
+# --- Gradio UI Logic ---
+
+def initialize_ui(task_name):
+    obs = env.reset(task_name)
+    return (
+        f"Task loaded: {task_name.upper()}\n{env.task.description}",
+        json.dumps(obs.model_dump(), indent=2),
+        "0.0",
+        str(env.metrics)
+    )
+
+def step_env_ui(action_type, email_id, folder_name, reply_body):
+    action_dict = {
+        "action_type": action_type,
+        "email_id": email_id if email_id else None,
+        "folder_name": folder_name if folder_name else None,
+        "reply_body": reply_body if reply_body else None
+    }
+    action = Action(**action_dict)
+    obs, score, done, metrics = env.step(action)
+    return (
+        json.dumps(obs.model_dump(), indent=2),
+        f"{score}",
+        str(metrics),
+        "Completed" if done else "In Progress"
+    )
+
+with gr.Blocks(title="OpenEnv - EmailOps Dashboard") as demo:
+    gr.Markdown("# Email Triage & Operations (OpenEnv)")
+    gr.Markdown("Interactive UI for monitoring and testing the EmailOps environment.")
+    
+    with gr.Row():
+        with gr.Column():
+            task_dropdown = gr.Dropdown(choices=["easy", "medium", "hard"], value="easy", label="Select Task")
+            init_btn = gr.Button("Initialize / Reset Environment")
+            task_desc = gr.Textbox(label="Task Description", lines=2)
+            
+            gr.Markdown("### Manual Action Overrides")
+            act_type = gr.Dropdown(
+                choices=["open_email", "close_email", "move_email", "reply", "delete_email", "flag_email", "submit"],
+                value="open_email", label="Action Type"
+            )
+            email_id = gr.Textbox(label="Email ID (optional)")
+            folder_name = gr.Textbox(label="Folder Name (optional, for move)")
+            reply_body = gr.Textbox(label="Reply Body (optional, for reply)")
+            
+            step_btn = gr.Button("Step Environment")
+        
+        with gr.Column():
+            gr.Markdown("### Observation & Reward")
+            observation_display = gr.Code(label="Current Observation", language="json")
+            with gr.Row():
+                score_display = gr.Textbox(label="Reward Score")
+                status_display = gr.Textbox(label="Status")
+            metrics_display = gr.Textbox(label="Metrics", lines=2)
+            
+    init_btn.click(
+        fn=initialize_ui,
+        inputs=[task_dropdown],
+        outputs=[task_desc, observation_display, score_display, metrics_display]
+    )
+    
+    step_btn.click(
+        fn=step_env_ui,
+        inputs=[act_type, email_id, folder_name, reply_body],
+        outputs=[observation_display, score_display, metrics_display, status_display]
+    )
+
+# Mount Gradio into FastAPI
+app = gr.mount_gradio_app(app, demo, path="/")
+
+if __name__ == "__main__":
+    uvicorn.run(app, host="0.0.0.0", port=7860)

inference.py

@@ -0,0 +1,101 @@
+import os
+import json
+import argparse
+from openai import OpenAI
+from core.environment import EmailOpsEnv
+from core.models import Action
+
+# Mandatory environment variables with defaults per OpenEnv spec
+API_BASE_URL = os.getenv("API_BASE_URL", "https://api.openai.com/v1")
+MODEL_NAME = os.getenv("MODEL_NAME", "gpt-4o-mini")
+HF_TOKEN = os.getenv("HF_TOKEN") # No default for token
+
+def run_baseline(api_key: str, model_name: str, base_url: str):
+    client = OpenAI(api_key=api_key, base_url=base_url)
+    env = EmailOpsEnv()
+    
+    tasks = ["easy", "medium", "hard"]
+    
+    print(f"Running baseline on model: {model_name}")
+    print("=" * 40)
+    
+    for task_name in tasks:
+        # START: Structured logging for OpenEnv automated grading
+        print(f"START: {task_name}")
+        
+        obs = env.reset(task_name)
+        
+        step_count = 0
+        max_steps = 15
+        is_done = False
+        total_reward = 0.0
+        
+        while not is_done and step_count < max_steps:
+            system_prompt = (
+                "You are an intelligent email operations agent. "
+                f"Your current goal is: {env.task.description}\n"
+                "You must perform actions to achieve this goal. Once you are finished, output the 'submit' action.\n"
+                "Available action types:\n"
+                " - open_email (requires email_id)\n"
+                " - close_email\n"
+                " - move_email (requires email_id, folder_name)\n"
+                " - reply (requires email_id, reply_body)\n"
+                " - delete_email (requires email_id)\n"
+                " - flag_email (requires email_id)\n"
+                " - submit"
+            )
+            
+            try:
+                response = client.beta.chat.completions.parse(
+                    model=model_name,
+                    messages=[
+                        {"role": "system", "content": system_prompt},
+                        {"role": "user", "content": f"Current Observation:\n{obs.model_dump_json(indent=2)}\nWhat is your next action?"}
+                    ],
+                    response_format=Action,
+                    temperature=0.1
+                )
+                
+                action = response.choices[0].message.parsed
+                if not action:
+                    break
+                
+                # STEP: Structured logging for OpenEnv automated grading
+                print(f"STEP: {action.model_dump_json()}")
+                       
+                obs, reward, is_done, metrics = env.step(action)
+                total_reward = reward
+                
+                if action.action_type == "submit":
+                    break
+                    
+            except Exception as e:
+                print(f"Error during inference: {e}")
+                break
+                
+            step_count += 1
+            
+        # END: Structured logging for OpenEnv automated grading
+        result = {
+            "task": task_name,
+            "steps": step_count,
+            "reward": total_reward,
+            "metrics": env.metrics
+        }
+        print(f"END: {json.dumps(result)}")
+        print("-" * 40)
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    # Prioritizing environment variables as per requirements
+    parser.add_argument("--api-key", type=str, default=HF_TOKEN)
+    parser.add_argument("--model", type=str, default=MODEL_NAME)
+    parser.add_argument("--base-url", type=str, default=API_BASE_URL)
+    args = parser.parse_args()
+    
+    # HF_TOKEN is mandatory for automated submissions
+    if not args.api_key:
+        print("Please set HF_TOKEN environment variable.")
+        exit(1)
+        
+    run_baseline(args.api_key, args.model, args.base_url)

requirements.txt

@@ -0,0 +1,5 @@
+pydantic>=2.0.0
+openai>=1.0.0
+gradio>=4.0.0
+fastapi
+uvicorn