Upload folder using huggingface_hub

Dockerfile

@@ -0,0 +1,81 @@
+# 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.
+
+# Multi-stage build using openenv-base
+# This Dockerfile is flexible and works for both:
+# - In-repo environments (with local OpenEnv sources)
+# - Standalone environments (with openenv from PyPI/Git)
+# The build script (openenv build) handles context detection and sets appropriate build args.
+
+ARG BASE_IMAGE=ghcr.io/meta-pytorch/openenv-base:latest
+FROM ${BASE_IMAGE} AS builder
+
+WORKDIR /app
+
+# Ensure git is available (required for installing dependencies from VCS)
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends git && \
+    rm -rf /var/lib/apt/lists/*
+
+# Build argument to control whether we're building standalone or in-repo
+ARG BUILD_MODE=in-repo
+ARG ENV_NAME=executive_inbox
+
+# Copy environment code (always at root of build context)
+COPY . /app/env
+
+# For in-repo builds, openenv is already vendored in the build context
+# For standalone builds, openenv will be installed via pyproject.toml
+WORKDIR /app/env
+
+# Ensure uv is available (for local builds where base image lacks it)
+RUN if ! command -v uv >/dev/null 2>&1; then \
+        curl -LsSf https://astral.sh/uv/install.sh | sh && \
+        mv /root/.local/bin/uv /usr/local/bin/uv && \
+        mv /root/.local/bin/uvx /usr/local/bin/uvx; \
+    fi
+    
+# Install dependencies using uv sync
+# If uv.lock exists, use it; otherwise resolve on the fly
+RUN --mount=type=cache,target=/root/.cache/uv \
+    if [ -f uv.lock ]; then \
+        uv sync --frozen --no-install-project --no-editable; \
+    else \
+        uv sync --no-install-project --no-editable; \
+    fi
+
+RUN --mount=type=cache,target=/root/.cache/uv \
+    if [ -f uv.lock ]; then \
+        uv sync --frozen --no-editable; \
+    else \
+        uv sync --no-editable; \
+    fi
+
+# Final runtime stage
+FROM ${BASE_IMAGE}
+
+WORKDIR /app
+
+# Copy the virtual environment from builder
+COPY --from=builder /app/env/.venv /app/.venv
+
+# Copy the environment code
+COPY --from=builder /app/env /app/env
+
+# Set PATH to use the virtual environment
+ENV PATH="/app/.venv/bin:$PATH"
+
+# Set PYTHONPATH so imports work correctly
+ENV PYTHONPATH="/app/env:$PYTHONPATH"
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
+    CMD curl -f http://localhost:8000/health || exit 1
+
+# Run the FastAPI server
+# The module path is constructed to work with the /app/env structure
+ENV ENABLE_WEB_INTERFACE=true
+CMD ["sh", "-c", "cd /app/env && uvicorn server.app:app --host 0.0.0.0 --port 8000"]

README.md

@@ -1,11 +1,69 @@
 ---
-title: Executive Inbox
-emoji: 🚀
-colorFrom: gray
-colorTo: blue
+title: Executive Inbox Environment (RL)
+emoji: ⏱️
+colorFrom: pink
+colorTo: indigo
 sdk: docker
 pinned: false
-license: mit
+app_port: 8000
+base_path: /web
+tags:
+  - openenv
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Executive Inbox Environment — Native Architecture
+
+A robust text-based OpenEnv environment built on top of the native PyTorch `openenv.core.env_server.Environment` class architecture. This environment simulates a stressful day in the life of an Executive Assistant or busy executive, forcing the `Action` space to parse emails, check calendars, reschedule personal conflicts around work emergencies, and reply via thread IDs.
+
+Developed strictly to align with OpenEnv Statement 3.2 (Personalized Tasks & Email/Calendar Parsing).
+
+## Quick Start
+
+You can test a programmatic AI policy (looping over actions to find the solution) by running the evaluator test:
+
+```bash
+uv run python examples/heuristic_policy.py
+```
+This loop runs **10 distinct episodes** against our generative procedural combinatorics.
+
+You can also run the deterministic single-step example:
+```bash
+uv run python examples/executive_inbox_example.py
+```
+
+## Features for Deep Reinforcement Learning
+
+The environment was ripped off the `FastMCP` architecture and rebuilt precisely to support Reinforcement Learning evaluations:
+
+1. **Native Observations & Validations**: 
+   - We utilize `ExecutiveInboxAction(action_type=...)` and our `step()` function returns a structured `ExecutiveInboxObservation(output: Any, error: str, done: bool, reward: float)`.
+2. **Procedural Complexity (No Memorizing)**:
+   - Built on `data_pools.py`, we randomly sample combinations of "Crisis Emails", "Personal Conflicts", and "Noise Events" and drop them randomly into a 9-to-5 calendar layout every single episode. 
+   - All email IDs (e.g. `e_1x9w`) and meeting IDs (`c_00k4`) are randomly generated on `reset()`.
+3. **Double Overlaps**:
+   - The environment purposefully seeds **two separate conflicts** occurring simultaneously at distinct times.
+   - For example: *A VIP crisis at 10:00 AM overlaps a flight, and a server outage at 3:00 PM overlaps a doctor's appointment.*
+4. **Rich Constraints**:
+   - `move_meeting` enforces that the new meeting block cannot be placed on an occupied time block (like 2:00 PM), failing gracefully and penalizing the agent.
+5. **Delegations Tools**:
+   - Includes full implementations of `reply_to_email` and `delegate_meeting` to fulfill the "Personalized Constraints" and "Delegation" feedback block from evaluators.
+
+## Reward & Shaping Mechanics
+
+- Max Step count is set to **15 steps**. Reaching the limit terminates the episode with `Done=True` and `Reward=-1.0`.
+- Every valid tool call returns a `-0.01` negative penalty to enforce efficient operations (the heuristic optimal solver takes 6 steps to win).
+- Every **Invalid Action** (missing parameters, or hallucinating an `email_id` that does not exist in the current random layout) throws a `-0.1` invalid step penalty and increments the verification `state.invalid_actions_taken`.
+- Resolving **Both Conflicts** and sending **Both Confirmatory Emails** terminates the episode with `Done=True` and awards `+1.0`.
+
+## Architecture
+
+```
+executive_inbox/
+├── models.py                   # Pydantic schemas (ExecutiveInboxAction/Observation)
+├── client.py                   # Model dump overrides for local testing
+├── server/
+│   ├── executive_inbox_environment.py # Native environment loop + validations
+│   ├── data_pools.py           # Combinatorial random pools of scenarios
+│   └── app.py                  # OpenEnv FastAPI app
+└── README.md
+```

__init__.py

@@ -0,0 +1,23 @@
+# 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.
+
+"""Executive Inbox Environment."""
+
+from .models import ExecutiveInboxAction, ExecutiveInboxObservation
+
+# Allow server-side imports to work even when optional MCP/client deps are missing.
+try:
+    from .client import ExecutiveInboxEnv
+except ModuleNotFoundError:
+    ExecutiveInboxEnv = None  # type: ignore[assignment]
+
+__all__ = [
+    "ExecutiveInboxAction",
+    "ExecutiveInboxObservation",
+]
+
+if ExecutiveInboxEnv is not None:
+    __all__.append("ExecutiveInboxEnv")

client.py

@@ -0,0 +1,82 @@
+# 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.
+
+"""Executive Inbox Environment Client."""
+
+from typing import Dict
+
+from openenv.core import EnvClient
+from openenv.core.client_types import StepResult
+
+from .models import ExecutiveInboxAction, ExecutiveInboxObservation, ExecutiveInboxState
+
+
+class ExecutiveInboxEnv(
+    EnvClient[ExecutiveInboxAction, ExecutiveInboxObservation, ExecutiveInboxState]
+):
+    """
+    Client for the Executive Inbox Environment.
+
+    This client maintains a persistent WebSocket connection to the environment server,
+    enabling efficient multi-step interactions with lower latency.
+    Each client instance has its own dedicated environment session on the server.
+
+    Example:
+        >>> # Connect to a running server
+        >>> with ExecutiveInboxEnv(base_url="http://localhost:8000") as client:
+        ...     result = client.reset()
+        ...     print(result.observation.output)
+        ...
+        ...     result = client.step(ExecutiveInboxAction(action_type="get_calendar"))
+        ...     print(result.observation.output)
+
+    Example with Docker:
+        >>> # Automatically start container and connect
+        >>> client = ExecutiveInboxEnv.from_docker_image("executive_inbox-env:latest")
+        >>> try:
+        ...     result = client.reset()
+        ...     result = client.step(ExecutiveInboxAction(action_type="get_calendar"))
+        ... finally:
+        ...     client.close()
+    """
+
+    def _step_payload(self, action: ExecutiveInboxAction) -> Dict:
+        """
+        Convert ExecutiveInboxAction to JSON payload for step message.
+        """
+        return action.model_dump(exclude_none=True)
+
+    def _parse_result(self, payload: Dict) -> StepResult[ExecutiveInboxObservation]:
+        """
+        Parse server response into StepResult[ExecutiveInboxObservation].
+        """
+        obs_data = payload.get("observation", {})
+        
+        observation = ExecutiveInboxObservation(
+            output=obs_data.get("output", None),
+            error=obs_data.get("error", None),
+            done=obs_data.get("done", payload.get("done", False)),
+            reward=obs_data.get("reward", payload.get("reward", 0.0)),
+        )
+
+        return StepResult(
+            observation=observation,
+            reward=payload.get("reward", 0.0),
+            done=payload.get("done", False),
+        )
+
+    def _parse_state(self, payload: Dict) -> ExecutiveInboxState:
+        """
+        Parse server response into ExecutiveInboxState object.
+        """
+        return ExecutiveInboxState(
+            episode_id=payload.get("episode_id"),
+            step_count=payload.get("step_count", 0),
+            conflict_resolved=payload.get("conflict_resolved", False),
+            emails_sent=payload.get("emails_sent", 0),
+            invalid_actions_taken=payload.get("invalid_actions_taken", 0),
+            is_timeout=payload.get("is_timeout", False)
+        )

models.py

@@ -0,0 +1,46 @@
+# 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 the Executive Inbox Environment.
+"""
+
+from typing import Any, Optional
+from pydantic import BaseModel, Field
+
+# We use openenv.core.env_server.types for State based on the previous working file
+from openenv.core.env_server.types import State
+
+class ExecutiveInboxAction(BaseModel):
+    """Native action schema for the Executive Inbox Environment."""
+    action_type: str = Field(..., description="Action to perform (e.g., 'read_inbox', 'move_meeting', 'delegate_meeting')")
+    
+    # Optional arguments depending on the tool chosen
+    email_id: Optional[str] = None
+    to: Optional[str] = None
+    subject: Optional[str] = None
+    body: Optional[str] = None
+    meeting_id: Optional[str] = None
+    new_time: Optional[str] = None
+    delegate_email: Optional[str] = None
+
+class ExecutiveInboxObservation(BaseModel):
+    """Native observation schema passed back to the RL policy."""
+    output: Any = Field(description="The functional output string or dict array from the environment tool.")
+    error: Optional[str] = Field(default=None, description="Detailed error message if the action failed.")
+    done: bool = Field(default=False, description="Whether the episode has terminated.")
+    reward: float = Field(default=0.0, description="The reward accumulated on this step.")
+
+class ExecutiveInboxState(State):
+    """Episode state metadata for the Executive Inbox environment."""
+    conflict_resolved: bool = Field(default=False, description="Whether the schedule conflict is resolved")
+    partial_conflicts_resolved: int = Field(default=0, description="Number of individual conflict pairs resolved")
+    emails_sent: int = Field(default=0, description="Number of emails sent")
+    crisis_emails_opened: int = Field(default=0, description="Number of true crisis emails opened")
+    correct_meeting_moves: int = Field(default=0, description="Number of correct crisis meetings moved or delegated")
+    correct_replies: int = Field(default=0, description="Number of correct crisis-thread replies with resolution language")
+    invalid_actions_taken: int = Field(default=0, description="Counter for hallucinated or invalid tool calls")
+    is_timeout: bool = Field(default=False, description="Whether the episode ended due to hitting the max step limit")

openenv.yaml

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

pyproject.toml

@@ -0,0 +1,45 @@
+# 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.
+
+[build-system]
+requires = ["setuptools>=45", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "openenv-executive_inbox"
+version = "0.1.0"
+description = "Executive Inbox environment for OpenEnv"
+requires-python = ">=3.10"
+dependencies = [
+    # Core OpenEnv runtime (provides FastAPI server + HTTP client types)
+    # install from github
+    # "openenv-core[core] @ git+https://github.com/meta-pytorch/OpenEnv.git",
+    "openenv-core[core]==0.2.1",
+    # Environment-specific dependencies
+    # Add all dependencies needed for your environment here
+    # Examples:
+    # "numpy>=1.19.0",
+    # "torch>=2.0.0",
+    # "gymnasium>=0.29.0",
+    # "openspiel>=1.0.0",
+    # "smolagents>=1.22.0,<2",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.0.0",
+    "pytest-cov>=4.0.0",
+]
+
+[project.scripts]
+# Server entry point - enables running via: uv run --project . server
+# or: python -m executive_inbox.server.app
+server = "executive_inbox.server.app:main"
+
+[tool.setuptools]
+include-package-data = true
+packages = ["executive_inbox", "executive_inbox.server"]
+package-dir = { "executive_inbox" = ".", "executive_inbox.server" = "server" }

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.
+
+"""Executive Inbox environment server components."""
+
+from .executive_inbox_environment import ExecutiveInboxEnvironment
+
+__all__ = ["ExecutiveInboxEnvironment"]

server/app.py

@@ -0,0 +1,79 @@
+# 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 Executive Inbox Environment.
+
+This module creates an HTTP server that exposes the ExecutiveInboxEnvironment
+over HTTP and WebSocket endpoints, compatible with EnvClient.
+
+Endpoints:
+    - POST /reset: Reset the environment
+    - POST /step: Execute an action
+    - GET /state: Get current environment state
+    - GET /schema: Get action/observation schemas
+    - WS /ws: WebSocket endpoint for persistent sessions
+
+Usage:
+    # Development (with auto-reload):
+    uvicorn server.app:app --reload --host 0.0.0.0 --port 8000
+
+    # Production:
+    uvicorn server.app:app --host 0.0.0.0 --port 8000 --workers 4
+
+    # Or run directly:
+    python -m server.app
+"""
+
+try:
+    from openenv.core.env_server.http_server import create_app
+except Exception as e:  # pragma: no cover
+    raise ImportError(
+        "openenv is required for the web interface. Install dependencies with '\n    uv sync\n'"
+    ) from e
+
+# Import from local models.py (PYTHONPATH includes /app/env in Docker)
+from models import ExecutiveInboxAction, ExecutiveInboxObservation
+
+from .executive_inbox_environment import ExecutiveInboxEnvironment
+
+
+# Create the app with web interface and README integration
+app = create_app(
+    ExecutiveInboxEnvironment,
+    ExecutiveInboxAction,
+    ExecutiveInboxObservation,
+    env_name="executive_inbox",
+    max_concurrent_envs=1,  # increase this number to allow more concurrent WebSocket sessions
+)
+
+
+def main():
+    """
+    Entry point for direct execution via uv run or python -m.
+
+    This function enables running the server without Docker:
+        uv run --project . server
+        uv run --project . server --port 8001
+        python -m executive_inbox.server.app
+
+    Args:
+    For production deployments, consider using uvicorn directly with
+    multiple workers:
+        uvicorn executive_inbox.server.app:app --workers 4
+    """
+    import argparse
+    import uvicorn
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--host", default="0.0.0.0")
+    parser.add_argument("--port", type=int, default=8000)
+    args = parser.parse_args()
+    uvicorn.run(app, host=args.host, port=args.port)
+
+
+if __name__ == "__main__":
+    main()

server/data_pools.py

@@ -0,0 +1,117 @@
+"""
+Combinatorial Data Pools for the Executive Inbox Environment.
+Provides modular templates to exponentially scale the scenario permutations during RL training.
+"""
+
+# ==============================================================================
+# 1. CRISIS SCENARIOS (Work Overlaps)
+# ==============================================================================
+
+CRISIS_TYPES = [
+    {"type": "Client Attrition", "calendar_title": "VIP Client Strategy Meeting", "owner_prefix": ["boss", "vp.sales", "head.revenue"]},
+    {"type": "Server Outage", "calendar_title": "Prod Outage War Room", "owner_prefix": ["cto", "vp.eng", "head.infra"]},
+    {"type": "PR Disaster", "calendar_title": "Comms & PR Review", "owner_prefix": ["head.of.pr", "cmo", "vp.comms"]},
+    {"type": "Legal Threat", "calendar_title": "Legal Review (Feature Launch)", "owner_prefix": ["general.counsel", "head.legal", "vp.legal"]}
+]
+
+CRISIS_SUBJECTS = [
+    "Important sync at {time}",
+    "Required attendance: meeting at {time}",
+    "Need everyone in the war room at {time}",
+    "Strategy discussion - {time}",
+    "Please join the {time} call",
+    "Emergency Huddle - {time}",
+    "All-hands crisis response ({time})",
+    "Drop everything: sync at {time}",
+    "Immediate attention required ({time})",
+    "Briefing session at {time} sharp"
+]
+
+# Note: We omit explicit cheating keywords like "URGENT" or "EMERGENCY" where possible, 
+# forcing the agent to rely on semantic context.
+CRISIS_BODIES = [
+    "We have a massive situation unfolding. I'm pulling the whole team into a room at {time}. Clear your calendar.",
+    "The executive team is furious about the latest developments. We need a resolution plan drawn up by {time}. Be there.",
+    "This is arguably the worst time for this to happen. I am assembling a response team at {time}. Do not miss this.",
+    "I just got off the phone with the board. We need to do damage control immediately. Syncing at {time}.",
+    "We are bleeding revenue by the minute. Everyone needs to be hands-on-keyboard in the conference room at {time}.",
+    "The press is already starting to ask questions. We need to get our story straight. Meet me in my office at {time}.",
+    "Our legal exposure here is massive. We are pulling everyone into a mandatory review session at {time}.",
+    "The situation has escalated. We need an all-hands-on-deck response starting exactly at {time}."
+]
+
+# ==============================================================================
+# 2. PERSONAL CONFLICTS (Immovable Personal Commitments)
+# ==============================================================================
+
+PERSONAL_TYPES = [
+    {"type": "Recital", "calendar_title": "Daughter's Piano Recital"},
+    {"type": "Flight", "calendar_title": "Flight Options (Do not schedule)"},
+    {"type": "Doctor", "calendar_title": "Specialist Consultation"},
+    {"type": "Contractor", "calendar_title": "Contractor Arrival Window"},
+    {"type": "Dinner", "calendar_title": "Anniversary Dinner"},
+    {"type": "Childcare", "calendar_title": "School Pickup (Coordination)"}
+]
+
+PERSONAL_SENDERS = [
+    "school@academy.edu", "alerts@delta.com", "noreply@medical-portal.net", 
+    "dispatch@plumbing.com", "reservations@opentable.com", "nanny@care.com",
+    "frontdesk@pediatrics.org", "updates@united.com", "scheduling@hvac-pros.com"
+]
+
+PERSONAL_SUBJECTS = [
+    "Reminder: Appointment at {time}",
+    "Upcoming schedule: {time}",
+    "Confirmation for {time}",
+    "Your {time} itinerary",
+    "Action Required: Coverage needed at {time}",
+    "Arrival window confirmed ({time})",
+    "Don't forget: today at {time}",
+    "Reservation details - {time}"
+]
+
+PERSONAL_BODIES = [
+    "This is a final confirmation that your appointment begins promptly at {time}. Please ensure you arrive 15 minutes early.",
+    "We are writing to confirm your slot today at {time}. If you need to reschedule, you will be subject to a strict cancellation fee.",
+    "Please remember that you need to be physically present at {time}. We cannot hold your spot if you are late.",
+    "Your departure/arrival window is set for {time}. Let us know immediately if this changes, as we have no other availability this week.",
+    "Just a quick reminder about the commitment at {time}. It's very important that you are on time today!",
+    "I won't be able to handle things at {time} as planned. You will absolutely need to step in and cover this slot.",
+    "The schedule is locked in for {time}. See you then!"
+]
+
+
+# ==============================================================================
+# 3. NOISE EMAILS (Daily Office Chatter)
+# ==============================================================================
+
+NOISE_EMAILS = [
+    {"subject": "Weekly Newsletter", "sender": "updates@producthunt.com", "body": "Here are the top 10 products of the week. Number 3 will shock you!"},
+    {"subject": "Happy Hour on Friday?", "sender": "sarah.team@company.com", "body": "Hey everyone, are we still doing drinks at O'Malleys this Friday? Need a headcount."},
+    {"subject": "Your Amazon.com order has shipped", "sender": "auto-confirm@amazon.com", "body": "Your order for 'Ergonomic Office Chair' has shipped and will arrive tomorrow."},
+    {"subject": "Expense Report Not Yet Submitted", "sender": "finance-bot@company.com", "body": "You have 3 unsubmitted expenses from your trip to New York. Please submit by EOD."},
+    {"subject": "Lunch in 10?", "sender": "mark.dev@company.com", "body": "Heading down to the cafeteria. Want me to grab you a sandwich?"},
+    {"subject": "New login from Mac OS", "sender": "security@it-support.net", "body": "We detected a new login to your account from a Mac device. If this was you, ignore this email."},
+    {"subject": "Re: Project Alpha timeline", "sender": "jessica.pm@company.com", "body": "I think we can hit the Q3 deadline if we cut the reporting feature. Thoughts?"},
+    {"subject": "Can you review my PR?", "sender": "intern.bob@company.com", "body": "I just pushed the fix for the login bug. PR #4092. Let me know if it looks okay!"},
+    {"subject": "Client prep notes for tomorrow", "sender": "vp.sales@company.com", "body": "Not urgent today. I just want your notes before tomorrow's client prep."},
+    {"subject": "Draft talking points for next week's review", "sender": "cmo@company.com", "body": "Please send the draft deck when you have a chance. This is for next week, not today's fire drill."},
+    {"subject": "Quick legal wording pass", "sender": "head.legal@company.com", "body": "Can you glance at the wording later this afternoon? No immediate action needed."},
+    {"subject": "System Maintenance Tonight", "sender": "eng-leads@company.com", "body": "The staging databases will be down for maintenance between 1 AM and 3 AM tonight."},
+    {"subject": "Did you leave your jacket in the conference room?", "sender": "office.manager@company.com", "body": "Someone left a blue Patagonia jacket in room 4B."}
+]
+
+NOISE_CALENDAR = [
+    {"title": "Focus Time", "participants": []},
+    {"title": "1:1 with Jane", "participants": ["jane.manager@company.com"]},
+    {"title": "Weekly Team Sync", "participants": ["eng-team@company.com", "design-team@company.com"]},
+    {"title": "Product Roadmap Review", "participants": ["execs@company.com", "jessica.pm@company.com"]},
+    {"title": "Dentist Follow-up", "participants": []},
+    {"title": "Interview: Frontend Engineer", "participants": ["recruiting@company.com", "candidate@gmail.com"]},
+    {"title": "Vendor Pitch: CloudFlare", "participants": ["sales@cloudflare.com", "it-leads@company.com"]},
+    {"title": "All-Hands Rehearsal", "participants": ["ceo@company.com", "comms@company.com"]},
+    {"title": "Executive Check-in", "participants": ["vp.sales@company.com", "chief.of.staff@company.com"]},
+    {"title": "Legal Draft Review", "participants": ["head.legal@company.com", "chief.of.staff@company.com"]},
+    {"title": "Lunch / Run", "participants": []},
+    {"title": "Architecture Brainstorm", "participants": ["mark.dev@company.com", "sarah.team@company.com"]}
+]

server/executive_inbox_environment.py

@@ -0,0 +1,442 @@
+from typing import Any, Dict, List, Optional
+import random
+import string
+
+from openenv.core.env_server import Environment
+from ..models import ExecutiveInboxAction, ExecutiveInboxObservation, ExecutiveInboxState
+
+def semi_random_id(prefix: str) -> str:
+    """Generate a stable but random-looking ID for scenarios."""
+    chars = string.ascii_lowercase + string.digits
+    return f"{prefix}_{''.join(random.choices(chars, k=4))}"
+
+
+class ExecutiveInboxEnvironment(
+    Environment[
+        ExecutiveInboxAction, ExecutiveInboxObservation, ExecutiveInboxState
+    ]
+):
+    """
+    Simulates an executive inbox where an AI agent must handle calendar conflicts 
+    and email threads. Built with procedurally generated state to prevent memorization.
+    """
+    MAX_STEPS = 15
+
+    def __init__(self, num_conflicts: int = 2, dense_reward: bool = True):
+        super().__init__()
+        self._num_conflicts = max(1, min(num_conflicts, 2))
+        self._dense_reward = dense_reward
+        self._step_count = 0
+        self._inbox = []
+        self._sent_emails = []
+        self._calendar = []
+        self._done = False
+        self._reward = 0.0
+        self._state = ExecutiveInboxState()
+        self._reset_environment()
+
+    @property
+    def name(self) -> str:
+        return "ExecutiveInboxEnvironment"
+
+    @property
+    def state(self) -> ExecutiveInboxState:
+        return self._state
+
+    def reset(self) -> ExecutiveInboxObservation:
+        self._reset_environment()
+        return ExecutiveInboxObservation(
+            output="Environment initialized.",
+            done=self._done,
+            reward=self._reward
+        )
+
+    def _reset_environment(self):
+        """Internal reset to procedurally generate a fresh scenario."""
+        self._step_count = 0
+        self._state = ExecutiveInboxState()
+        self._init_scenario()
+
+    def _init_scenario(self):
+        """Initialize procedural variables for the scenario."""
+        from .data_pools import NOISE_EMAILS, NOISE_CALENDAR, CRISIS_TYPES, CRISIS_SUBJECTS, CRISIS_BODIES, PERSONAL_TYPES, PERSONAL_SENDERS, PERSONAL_SUBJECTS, PERSONAL_BODIES
+        
+        # 1. Base Variables
+        times = ["9:00 AM", "10:00 AM", "1:00 PM", "2:00 PM", "3:00 PM", "4:00 PM"]
+        
+        # Pick one or two distinct conflict times depending on the curriculum setting.
+        self._conflict_times = random.sample(times, self._num_conflicts)
+        
+        domain = random.choice(["company.com", "corp.net", "enterprise.org"])
+        vip_domain = random.choice(["bigcorp.com", "megacorp.com", "globaltech.io"])
+        
+        # 2. Pick the Scenarios
+        crises = random.sample(CRISIS_TYPES, self._num_conflicts)
+        conflicts = random.sample(PERSONAL_TYPES, self._num_conflicts)
+        
+        # Save validation targets
+        self._targets = []
+        for i in range(self._num_conflicts):
+            self._targets.append({
+                "time": self._conflict_times[i],
+                "owner_email": f"{random.choice(crises[i]['owner_prefix'])}@{domain}",
+                "meeting_id": semi_random_id("c"),
+                "crisis_data": crises[i],
+                "conflict_data": conflicts[i],
+                "delegate_email": "chief.of.staff@company.com",
+                "crisis_email_id": None,
+                "crisis_subject": None,
+                "personal_email_id": None,
+                "personal_meeting_id": None,
+                "delegated_to": None,
+                "opened_crisis_email": False,
+                "moved_correct_meeting": False,
+                "replied_with_resolution": False,
+                "resolved": False
+            })
+            
+        # 3. Build Inbox
+        self._inbox = []
+        
+        for target in self._targets:
+            # Dynamic String Compilation
+            c_subj = random.choice(CRISIS_SUBJECTS).format(time=target["time"])
+            c_body = random.choice(CRISIS_BODIES).format(time=target["time"], vip_domain=vip_domain)
+            c_body += (
+                f" If you cannot attend, delegate the meeting to {target['delegate_email']}."
+            )
+            
+            p_sender = random.choice(PERSONAL_SENDERS)
+            p_subj = random.choice(PERSONAL_SUBJECTS).format(time=target["time"])
+            p_body = random.choice(PERSONAL_BODIES).format(time=target["time"])
+
+            # Schema Drift: 10% chance to lowercase subject
+            if random.random() < 0.10: c_subj = c_subj.lower()
+            if random.random() < 0.10: p_subj = p_subj.lower()
+
+            # Crisis Email
+            crisis_email = {
+                "id": semi_random_id("e"),
+                "sender": target["owner_email"],
+                "subject": c_subj,
+                "date": "Today 08:30 AM",
+                "body": c_body
+            }
+            self._inbox.append(crisis_email)
+            target["crisis_email_id"] = crisis_email["id"]
+            target["crisis_subject"] = crisis_email["subject"]
+            
+            # Personal Conflict Email
+            personal_email = {
+                "id": semi_random_id("e"),
+                "sender": p_sender,
+                "subject": p_subj,
+                "date": "Today 08:00 AM",
+                "body": p_body
+            }
+            self._inbox.append(personal_email)
+            target["personal_email_id"] = personal_email["id"]
+        
+        # Noise Emails (Pick 3-5 random ones)
+        num_noise = random.randint(3, 5)
+        for noise in random.sample(NOISE_EMAILS, num_noise):
+            self._inbox.append({
+                "id": semi_random_id("e"),
+                "sender": noise["sender"],
+                "subject": noise["subject"],
+                "date": f"Today 0{random.randint(6,9)}:00 AM",
+                "body": noise["body"]
+            })
+            
+        random.shuffle(self._inbox)
+        self._sent_emails = []
+        
+        # 4. Build Calendar
+        self._calendar = []
+        
+        for target in self._targets:
+            # Crisis Event
+            self._calendar.append({
+                "id": target["meeting_id"],
+                "time": target["time"],
+                "title": target["crisis_data"]["calendar_title"],
+                "participants": [target["delegate_email"], f"vip@{vip_domain}"]
+            })
+            
+            # Personal Event
+            personal_meeting = {
+                "id": semi_random_id("c"),
+                "time": target["time"],
+                "title": target["conflict_data"]["calendar_title"],
+                "participants": [random.choice(PERSONAL_SENDERS)]
+            }
+            self._calendar.append(personal_meeting)
+            target["personal_meeting_id"] = personal_meeting["id"]
+        
+        # Noise Events (Pick 2-3 randomly, assigned to non-conflict times)
+        num_noise_events = random.randint(2, 3)
+        available_times = [t for t in times if t not in self._conflict_times]
+        
+        if num_noise_events > len(available_times):
+            num_noise_events = len(available_times)
+            
+        random_times_for_noise = random.sample(available_times, num_noise_events)
+        
+        for i, noise_cal in enumerate(random.sample(NOISE_CALENDAR, num_noise_events)):
+            self._calendar.append({
+                "id": semi_random_id("c"),
+                "time": random_times_for_noise[i],
+                "title": noise_cal["title"],
+                "participants": noise_cal["participants"]
+            })
+            
+        random.shuffle(self._calendar)
+        
+        self._done = False
+        self._reward = 0.0
+
+    def _add_reward(self, amount: float) -> None:
+        if self._dense_reward:
+            self._reward += amount
+
+    def _find_target_for_email(self, email_id: str) -> Optional[Dict[str, Any]]:
+        return next((target for target in self._targets if target["crisis_email_id"] == email_id), None)
+
+    def _find_target_for_meeting(self, meeting_id: str) -> Optional[Dict[str, Any]]:
+        return next((target for target in self._targets if target["meeting_id"] == meeting_id), None)
+
+    def _body_mentions_resolution(self, body: str) -> bool:
+        body_text = body.lower()
+        keywords = ["moved", "rescheduled", "delegate", "delegated", "updated the schedule"]
+        return any(keyword in body_text for keyword in keywords)
+
+    def _has_resolution_reply(self, target: Dict[str, Any]) -> bool:
+        owner_email = str(target["owner_email"]).lower()
+        crisis_subject = str(target.get("crisis_subject", "")).lower()
+        for email in self._sent_emails:
+            to = str(email.get("to", "")).lower()
+            subject = str(email.get("subject", "")).lower()
+            body = str(email.get("body", ""))
+            if to != owner_email:
+                continue
+            if crisis_subject and crisis_subject not in subject:
+                continue
+            if self._body_mentions_resolution(body):
+                return True
+        return False
+
+    def _validate_task(self):
+        """Check if all overlapping conflicts are successfully resolved."""
+        if self._done:
+            return
+
+        resolved_count = 0
+
+        for target in self._targets:
+            # Check if the crisis meeting was moved off the conflict time
+            crisis_meeting = next((m for m in self._calendar if m["id"] == target["meeting_id"]), None)
+            
+            moved_off_conflict = bool(crisis_meeting and crisis_meeting["time"] != target["time"])
+            delegated_correctly = (
+                str(target.get("delegated_to", "")).lower()
+                == str(target.get("delegate_email", "")).lower()
+            )
+            sent_resolution = self._has_resolution_reply(target)
+            
+            if (moved_off_conflict or delegated_correctly) and sent_resolution:
+                resolved_count += 1
+                if not target["resolved"]:
+                    target["resolved"] = True
+                    self._state.partial_conflicts_resolved += 1
+                    self._add_reward(0.30)
+                
+        if resolved_count == len(self._targets):
+            self._done = True
+            self._state.conflict_resolved = True
+            if self._dense_reward:
+                self._reward += 0.70
+            else:
+                self._reward = 1.0
+
+    def step(self, action: ExecutiveInboxAction) -> ExecutiveInboxObservation:
+        """Process an action and return the observation and reward."""
+        self._step_count += 1
+        
+        # Penalize for inefficient exploration
+        self._reward -= 0.01
+
+        # Check for Max Steps Limit Timeout
+        if self._step_count >= self.MAX_STEPS:
+            self._done = True
+            self._state.is_timeout = True
+            if self._dense_reward:
+                self._reward = max(self._reward - 0.50, -1.0)
+            else:
+                self._reward = -1.0
+            return ExecutiveInboxObservation(
+                output=None,
+                error=f"Timeout reached. Maximum of {self.MAX_STEPS} steps allowed.",
+                done=self._done,
+                reward=self._reward
+            )
+
+        output = None
+        error = None
+        
+        # 1. read_inbox
+        if action.action_type == "read_inbox":
+            if action.email_id:
+                email = next((e for e in self._inbox if e["id"] == action.email_id), None)
+                if email:
+                    output = email
+                    target = self._find_target_for_email(action.email_id)
+                    if target is not None and not target["opened_crisis_email"]:
+                        target["opened_crisis_email"] = True
+                        self._state.crisis_emails_opened += 1
+                        self._add_reward(0.10)
+                else:
+                    self._reward -= 0.1
+                    self._state.invalid_actions_taken += 1
+                    error = f"Error: Email with ID {action.email_id} not found."
+            else:
+                # Summarize without bodies
+                output = [{"id": e["id"], "sender": e["sender"], "subject": e["subject"]} for e in self._inbox]
+
+        # 2. send_email
+        elif action.action_type == "send_email":
+            if not action.to or not action.subject or not action.body:
+                self._reward -= 0.1
+                self._state.invalid_actions_taken += 1
+                error = "Error: Cannot send email without all fields (to, subject, body)."
+            else:
+                new_id = f"email_{len(self._sent_emails) + 1}"
+                self._sent_emails.append({
+                    "id": new_id, "to": action.to, "subject": action.subject, "body": action.body
+                })
+                self._state.emails_sent += 1
+                self._validate_task()
+                output = f"Email sent successfully to {action.to}"
+
+        # 3. reply_to_email
+        elif action.action_type == "reply_to_email":
+            if not action.email_id or not action.body:
+                self._reward -= 0.1
+                self._state.invalid_actions_taken += 1
+                error = "Error: Cannot reply without email_id and body."
+            else:
+                original_email = next((e for e in self._inbox if e["id"] == action.email_id), None)
+                if not original_email:
+                    self._reward -= 0.1
+                    self._state.invalid_actions_taken += 1
+                    error = f"Error: Email with ID {action.email_id} not found."
+                else:
+                    to = original_email["sender"]
+                    subject = f"Re: {original_email['subject']}"
+                    new_id = f"email_{len(self._sent_emails) + 1}"
+                    self._sent_emails.append({
+                        "id": new_id, "to": to, "subject": subject, "body": action.body
+                    })
+                    self._state.emails_sent += 1
+                    target = self._find_target_for_email(action.email_id)
+                    if (
+                        target is not None
+                        and self._body_mentions_resolution(action.body)
+                        and not target["replied_with_resolution"]
+                    ):
+                        target["replied_with_resolution"] = True
+                        self._state.correct_replies += 1
+                        self._add_reward(0.15)
+                    self._validate_task()
+                    output = f"Replied to {to} successfully."
+
+        # 4. get_calendar
+        elif action.action_type == "get_calendar":
+            output = self._calendar
+
+        # 5. move_meeting
+        elif action.action_type == "move_meeting":
+            if not action.meeting_id or not action.new_time:
+                self._reward -= 0.1
+                self._state.invalid_actions_taken += 1
+                error = "Error: Cannot move meeting without providing meeting_id and new_time."
+            else:
+                # Constraint Check
+                occupied = next((m for m in self._calendar if m["time"] == action.new_time and m["id"] != action.meeting_id), None)
+                if occupied:
+                    self._reward -= 0.1
+                    self._state.invalid_actions_taken += 1
+                    error = f"Error: Cannot move meeting to {action.new_time}. That slot is already occupied by '{occupied['title']}'."
+                else:
+                    meeting_found = False
+                    for meeting in self._calendar:
+                        if meeting["id"] == action.meeting_id:
+                            old_time = meeting["time"]
+                            meeting["time"] = action.new_time
+                            meeting_found = True
+                            target = self._find_target_for_meeting(action.meeting_id)
+                            if (
+                                target is not None
+                                and action.new_time != target["time"]
+                                and not target["moved_correct_meeting"]
+                            ):
+                                target["moved_correct_meeting"] = True
+                                self._state.correct_meeting_moves += 1
+                                self._add_reward(0.20)
+                            self._validate_task()
+                            output = f"Meeting '{meeting['title']}' moved from {old_time} to {action.new_time}."
+                            break
+                    if not meeting_found:
+                        self._reward -= 0.1
+                        self._state.invalid_actions_taken += 1
+                        error = f"Error: Meeting with ID {action.meeting_id} not found."
+
+        # 6. delegate_meeting
+        elif action.action_type == "delegate_meeting":
+            if not action.meeting_id or not action.delegate_email:
+                self._reward -= 0.1
+                self._state.invalid_actions_taken += 1
+                error = "Error: Cannot delegate meeting without meeting_id and delegate_email."
+            else:
+                target = next((t for t in self._targets if t["meeting_id"] == action.meeting_id), None)
+                if target is None:
+                    self._reward -= 0.1
+                    self._state.invalid_actions_taken += 1
+                    error = "Error: Only crisis meetings can be delegated."
+                elif action.delegate_email.lower() != target["delegate_email"].lower():
+                    self._reward -= 0.1
+                    self._state.invalid_actions_taken += 1
+                    error = (
+                        "Error: Invalid delegate. Route crisis meetings to "
+                        f"{target['delegate_email']}."
+                    )
+                else:
+                    meeting_found = False
+                    for i, meeting in enumerate(self._calendar):
+                        if meeting["id"] == action.meeting_id:
+                            title = meeting["title"]
+                            self._calendar.pop(i)
+                            target["delegated_to"] = action.delegate_email
+                            if not target["moved_correct_meeting"]:
+                                target["moved_correct_meeting"] = True
+                                self._state.correct_meeting_moves += 1
+                                self._add_reward(0.20)
+                            meeting_found = True
+                            self._validate_task()
+                            output = f"Meeting '{title}' (ID {action.meeting_id}) successfully delegated to {action.delegate_email}."
+                            break
+                    if not meeting_found:
+                        self._reward -= 0.1
+                        self._state.invalid_actions_taken += 1
+                        error = f"Error: Meeting with ID {action.meeting_id} not found on calendar."
+                    
+        else:
+            self._reward -= 0.1
+            self._state.invalid_actions_taken += 1
+            error = f"Error: Unknown action type '{action.action_type}'"
+
+        return ExecutiveInboxObservation(
+            output=output,
+            error=error,
+            done=self._done,
+            reward=self._reward
+        )

server/requirements.txt

@@ -0,0 +1,6 @@
+openenv-core[core]==0.2.1
+fastapi>=0.115.0
+uvicorn>=0.24.0
+
+
+