SmartCalendarResolver

.agents/skills/openenv-cli/.gitignore

@@ -0,0 +1 @@
+.codex

.agents/skills/openenv-cli/SKILL.md

@@ -0,0 +1,18 @@
+---
+name: openenv-cli
+description: "OpenEnv CLI (`openenv`) for scaffolding, validating, building, and pushing OpenEnv environments."
+---
+
+Install: `pip install openenv-core`
+
+The OpenEnv CLI command `openenv` is available.
+Use `openenv --help` to view available commands.
+
+Generated with `openenv-core v0.2.3`. Run `openenv skills add --force` to regenerate.
+
+## Tips
+
+- Start with `openenv init <env_name>` to scaffold a new environment
+- Validate projects with `openenv validate`
+- Build and deploy with `openenv build` and `openenv push`
+- Use `openenv <command> --help` for command-specific options

.codex/skills/openenv-cli

@@ -0,0 +1 @@
+../../.agents/skills/openenv-cli

.dockerignore

@@ -0,0 +1,5 @@
+.git
+.venv
+__pycache__
+*.pyc
+.pytest_cache

.python-version

@@ -0,0 +1 @@
+3.14

Dockerfile

@@ -0,0 +1,28 @@
+ARG BASE_IMAGE=ghcr.io/meta-pytorch/openenv-base:latest
+FROM ${BASE_IMAGE}
+
+WORKDIR /app/env
+ENV UV_PYTHON=python3
+
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends git && \
+    rm -rf /var/lib/apt/lists/*
+
+COPY . /app/env
+
+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
+
+RUN --mount=type=cache,target=/root/.cache/uv \
+    uv sync
+
+ENV PATH="/app/env/.venv/bin:$PATH"
+ENV PYTHONPATH="/app/env:$PYTHONPATH"
+
+HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
+    CMD curl -f http://localhost:8000/health || exit 1
+
+CMD ["uv", "run", "python", "-m", "uvicorn", "server.app:app", "--host", "0.0.0.0", "--port", "8000"]

calender_en/.dockerignore

@@ -0,0 +1,5 @@
+.git
+.venv
+__pycache__
+*.pyc
+.pytest_cache

calender_en/Dockerfile

@@ -0,0 +1,50 @@
+# Root Dockerfile to support `docker build -t smart-calendar-env .`
+
+ARG BASE_IMAGE=ghcr.io/meta-pytorch/openenv-base:latest
+FROM ${BASE_IMAGE} AS builder
+
+WORKDIR /app
+
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends git && \
+    rm -rf /var/lib/apt/lists/*
+
+COPY . /app/env
+WORKDIR /app/env
+
+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
+
+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
+
+FROM ${BASE_IMAGE}
+
+WORKDIR /app
+
+COPY --from=builder /app/env/.venv /app/.venv
+COPY --from=builder /app/env /app/env
+
+ENV PATH="/app/.venv/bin:$PATH"
+ENV PYTHONPATH="/app/env:$PYTHONPATH"
+
+
+
+HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
+    CMD curl -f http://localhost:8000/health || exit 1
+
+CMD ["sh", "-c", "cd /app/env && uvicorn server.app:app --host 0.0.0.0 --port 8000"]

calender_en/README.md

@@ -0,0 +1,106 @@
+---
+title: SmartCalendarResolver
+emoji: "📅"
+colorFrom: green
+colorTo: blue
+sdk: docker
+pinned: false
+app_port: 8000
+base_path: /web
+tags:
+  - openenv
+  - scheduling
+---
+
+# SmartCalendarResolver
+
+SmartCalendarResolver is a deterministic OpenEnv scheduling environment. Each episode walks through a fixed four-stage workflow:
+
+1. understand request
+2. evaluate availability
+3. propose slot
+4. confirm schedule
+
+The environment uses a small in-code dataset with easy, medium, and hard scenarios. There is no randomness.
+
+## Action Model
+
+`CalenderEnAction` fields:
+
+- `stage`: one of `understand_request`, `evaluate_availability`, `propose_slot`, `confirm_schedule`
+- `proposed_time_slot`: optional slot string used during proposal or confirmation
+- `confirm_schedule`: boolean used only during confirmation
+- `final_note`: short reasoning or confirmation note
+
+## Observation Model
+
+`CalenderEnObservation` fields:
+
+- `request`
+- `availability`
+- `constraints`
+- `step_count`
+- `reward`
+- `done`
+- `feedback`
+- `next_expected_stage`
+
+## Reward Behavior
+
+- Correct stage ordering is rewarded.
+- Correct slot selection is rewarded.
+- Respecting deadline and earliest-slot constraints is rewarded.
+- Proper final confirmation is rewarded.
+- Invalid or repeated actions are penalized.
+
+## Local Development
+
+Install dependencies:
+
+```bash
+uv sync
+```
+
+Validate the environment:
+
+```bash
+uv run openenv validate .
+```
+
+Run the deterministic baseline:
+
+```bash
+uv run python inference.py
+```
+
+Start the FastAPI server:
+
+```bash
+uv run python server/app.py
+```
+
+Health check:
+
+```bash
+curl http://localhost:8000/health
+```
+
+## Docker
+
+Build:
+
+```bash
+docker build -t smart-calendar-env .
+```
+
+Run:
+
+```bash
+docker run -p 8000:8000 smart-calendar-env
+```
+
+Then verify:
+
+```bash
+curl http://localhost:8000/health
+```

calender_en/__init__.py

@@ -0,0 +1,16 @@
+# 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.
+
+"""Calender En Environment."""
+
+from .client import CalenderEnEnv
+from .models import CalenderEnAction, CalenderEnObservation
+
+__all__ = [
+    "CalenderEnAction",
+    "CalenderEnObservation",
+    "CalenderEnEnv",
+]

calender_en/client.py

@@ -0,0 +1,109 @@
+# 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.
+
+"""Calender En Environment Client."""
+
+from typing import Dict
+
+from openenv.core import EnvClient
+from openenv.core.client_types import StepResult
+from openenv.core.env_server.types import State
+
+from .models import CalenderEnAction, CalenderEnObservation
+
+
+class CalenderEnEnv(
+    EnvClient[CalenderEnAction, CalenderEnObservation, State]
+):
+    """
+    Client for the Calender En 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 CalenderEnEnv(base_url="http://localhost:8000") as client:
+        ...     result = client.reset()
+        ...     print(result.observation.request)
+        ...
+        ...     result = client.step(
+        ...         CalenderEnAction(stage="understand_request", final_note="Identify participants and deadline.")
+        ...     )
+        ...     print(result.observation.feedback)
+
+    Example with Docker:
+        >>> # Automatically start container and connect
+        >>> client = CalenderEnEnv.from_docker_image("calender_en-env:latest")
+        >>> try:
+        ...     result = client.reset()
+        ...     result = client.step(
+        ...         CalenderEnAction(stage="understand_request", final_note="Identify participants and deadline.")
+        ...     )
+        ... finally:
+        ...     client.close()
+    """
+
+    def _step_payload(self, action: CalenderEnAction) -> Dict:
+        """
+        Convert CalenderEnAction to JSON payload for step message.
+
+        Args:
+            action: CalenderEnAction instance
+
+        Returns:
+            Dictionary representation suitable for JSON encoding
+        """
+        return {
+            "stage": action.stage,
+            "proposed_time_slot": action.proposed_time_slot,
+            "confirm_schedule": action.confirm_schedule,
+            "final_note": action.final_note,
+        }
+
+    def _parse_result(self, payload: Dict) -> StepResult[CalenderEnObservation]:
+        """
+        Parse server response into StepResult[CalenderEnObservation].
+
+        Args:
+            payload: JSON response data from server
+
+        Returns:
+            StepResult with CalenderEnObservation
+        """
+        obs_data = payload.get("observation", {})
+        observation = CalenderEnObservation(
+            request=obs_data.get("request", ""),
+            availability=obs_data.get("availability", {}),
+            constraints=obs_data.get("constraints", {}),
+            step_count=obs_data.get("step_count", 0),
+            reward=obs_data.get("reward", payload.get("reward", 0.0)),
+            done=payload.get("done", False),
+            feedback=obs_data.get("feedback", ""),
+            next_expected_stage=obs_data.get("next_expected_stage"),
+        )
+
+        return StepResult(
+            observation=observation,
+            reward=payload.get("reward"),
+            done=payload.get("done", False),
+        )
+
+    def _parse_state(self, payload: Dict) -> State:
+        """
+        Parse server response into State object.
+
+        Args:
+            payload: JSON response from state request
+
+        Returns:
+            State object with episode_id and step_count
+        """
+        return State(
+            episode_id=payload.get("episode_id"),
+            step_count=payload.get("step_count", 0),
+        )

calender_en/inference.py

@@ -0,0 +1,91 @@
+"""Deterministic baseline for the SmartCalendarResolver environment."""
+
+from typing import List
+
+try:
+    from calender_en.models import CalenderEnAction
+    from calender_en.server.calender_en_environment import CalenderEnEnvironment
+except ModuleNotFoundError:
+    from models import CalenderEnAction
+    from server.calender_en_environment import CalenderEnEnvironment
+
+TASK_NAME = "smart_calendar_resolution"
+ENV_NAME = "calender_en"
+MODEL_NAME = "deterministic-baseline"
+
+
+def _policy() -> List[CalenderEnAction]:
+    return [
+        CalenderEnAction(
+            stage="understand_request",
+            final_note="Identify the meeting objective, participants, and deadline.",
+        ),
+        CalenderEnAction(
+            stage="evaluate_availability",
+            final_note="Intersect participant availability and filter slots before the deadline.",
+        ),
+        CalenderEnAction(
+            stage="propose_slot",
+            proposed_time_slot="2026-04-08 10:00-10:30 UTC",
+            final_note="Choose the earliest common 30 minute slot before the deadline.",
+        ),
+        CalenderEnAction(
+            stage="confirm_schedule",
+            proposed_time_slot="2026-04-08 10:00-10:30 UTC",
+            confirm_schedule=True,
+            final_note="Confirmed with all participants and calendar invite is ready.",
+        ),
+    ]
+
+
+def _format_action(action: CalenderEnAction) -> str:
+    parts = [f"stage={action.stage}"]
+    if action.proposed_time_slot:
+        parts.append(f"slot={action.proposed_time_slot}")
+    parts.append(f"confirm={str(action.confirm_schedule).lower()}")
+    if action.final_note:
+        parts.append(f"note={action.final_note}")
+    return "|".join(parts)
+
+
+def main() -> None:
+    env = CalenderEnEnvironment()
+    rewards: List[str] = []
+    steps = 0
+    success = False
+
+    print(f"[START] task={TASK_NAME} env={ENV_NAME} model={MODEL_NAME}")
+
+    try:
+        env.reset()
+        for action in _policy():
+            steps += 1
+            error = "null"
+            try:
+                observation = env.step(action)
+                reward_text = f"{observation.reward:.2f}"
+                done_text = str(observation.done).lower()
+                rewards.append(reward_text)
+                print(
+                    f"[STEP] step={steps} action={_format_action(action)} "
+                    f"reward={reward_text} done={done_text} error={error}"
+                )
+                success = observation.done
+            except Exception as exc:
+                reward_text = "0.00"
+                rewards.append(reward_text)
+                print(
+                    f"[STEP] step={steps} action={_format_action(action)} "
+                    f"reward={reward_text} done=false error={str(exc)}"
+                )
+                success = False
+                break
+    except Exception:
+        success = False
+    finally:
+        rewards_text = ",".join(rewards)
+        print(f"[END] success={str(success).lower()} steps={steps} rewards={rewards_text}")
+
+
+if __name__ == "__main__":
+    main()

calender_en/models.py

@@ -0,0 +1,59 @@
+# 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 SmartCalendarResolver environment."""
+
+from typing import Dict, List, Literal, Optional
+
+from openenv.core.env_server.types import Action, Observation
+from pydantic import Field
+
+StageName = Literal[
+    "understand_request",
+    "evaluate_availability",
+    "propose_slot",
+    "confirm_schedule",
+]
+
+
+class CalenderEnAction(Action):
+    """Typed action for the deterministic scheduling workflow."""
+
+    stage: StageName = Field(..., description="Current scheduling stage being executed")
+    proposed_time_slot: Optional[str] = Field(
+        default=None,
+        description="Candidate slot proposed by the agent when proposing or confirming",
+    )
+    confirm_schedule: bool = Field(
+        default=False,
+        description="Whether the agent is explicitly confirming the selected schedule",
+    )
+    final_note: str = Field(
+        default="",
+        description="Short reasoning or confirmation note for the current stage",
+    )
+
+
+class CalenderEnObservation(Observation):
+    """Observation for the SmartCalendarResolver workflow."""
+
+    request: str = Field(default="", description="Scheduling request under consideration")
+    availability: Dict[str, List[str]] = Field(
+        default_factory=dict,
+        description="Participant availability windows for the active scenario",
+    )
+    constraints: Dict[str, str] = Field(
+        default_factory=dict,
+        description="Scheduling constraints such as duration, priority, and deadline",
+    )
+    step_count: int = Field(default=0, description="Current number of steps taken")
+    reward: float = Field(default=0.0, description="Reward assigned to the latest step")
+    done: bool = Field(default=False, description="Whether the episode is complete")
+    feedback: str = Field(default="", description="Environment feedback for the latest action")
+    next_expected_stage: Optional[StageName] = Field(
+        default="understand_request",
+        description="Next valid stage expected by the environment",
+    )

calender_en/openenv.yaml

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

calender_en/openenv_calender_en.egg-info/PKG-INFO

@@ -0,0 +1,9 @@
+Metadata-Version: 2.4
+Name: openenv-calender_en
+Version: 0.1.0
+Summary: Calender En environment for OpenEnv
+Requires-Python: >=3.10
+Requires-Dist: openenv-core[core]>=0.2.2
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0.0; extra == "dev"

calender_en/openenv_calender_en.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+README.md
+pyproject.toml
+./__init__.py
+./client.py
+./inference.py
+./models.py
+openenv_calender_en.egg-info/PKG-INFO
+openenv_calender_en.egg-info/SOURCES.txt
+openenv_calender_en.egg-info/dependency_links.txt
+openenv_calender_en.egg-info/entry_points.txt
+openenv_calender_en.egg-info/requires.txt
+openenv_calender_en.egg-info/top_level.txt
+server/__init__.py
+server/app.py
+server/calender_en_environment.py

calender_en/openenv_calender_en.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

calender_en/openenv_calender_en.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+server = calender_en.server.app:main

calender_en/openenv_calender_en.egg-info/requires.txt

@@ -0,0 +1,5 @@
+openenv-core[core]>=0.2.2
+
+[dev]
+pytest>=8.0.0
+pytest-cov>=4.0.0

calender_en/openenv_calender_en.egg-info/top_level.txt

@@ -0,0 +1 @@
+calender_en

calender_en/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-calender_en"
+version = "0.1.0"
+description = "Calender En 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.2",
+    # 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 calender_en.server.app
+server = "calender_en.server.app:main"
+
+[tool.setuptools]
+include-package-data = true
+packages = ["calender_en", "calender_en.server"]
+package-dir = { "calender_en" = ".", "calender_en.server" = "server" }

calender_en/server/Dockerfile

@@ -0,0 +1,80 @@
+# 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=calender_en
+
+# 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
+CMD ["sh", "-c", "cd /app/env && uvicorn server.app:app --host 0.0.0.0 --port 8000"]

calender_en/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.
+
+"""Calender En environment server components."""
+
+from .calender_en_environment import CalenderEnEnvironment
+
+__all__ = ["CalenderEnEnvironment"]

calender_en/server/app.py

@@ -0,0 +1,84 @@
+# 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 Calender En Environment.
+
+This module creates an HTTP server that exposes the CalenderEnEnvironment
+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
+
+try:
+    from ..models import CalenderEnAction, CalenderEnObservation
+    from .calender_en_environment import CalenderEnEnvironment
+except ImportError:
+    import sys
+    from pathlib import Path
+
+    sys.path.append(str(Path(__file__).resolve().parents[1]))
+    from models import CalenderEnAction, CalenderEnObservation
+    from server.calender_en_environment import CalenderEnEnvironment
+
+
+# Create the app with web interface and README integration
+app = create_app(
+    CalenderEnEnvironment,
+    CalenderEnAction,
+    CalenderEnObservation,
+    env_name="calender_en",
+    max_concurrent_envs=1,  # increase this number to allow more concurrent WebSocket sessions
+)
+
+
+def main() -> None:
+    """
+    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 calender_en.server.app
+
+    For production deployments, consider using uvicorn directly with
+    multiple workers:
+        uvicorn calender_en.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()

calender_en/server/calender_en_environment.py

@@ -0,0 +1,306 @@
+"""Deterministic SmartCalendarResolver environment implementation."""
+
+from typing import Dict, List, Optional, TypedDict
+from uuid import uuid4
+
+from openenv.core.env_server.interfaces import Environment
+from openenv.core.env_server.types import State
+
+try:
+    from ..models import CalenderEnAction, CalenderEnObservation, StageName
+except ImportError:
+    from models import CalenderEnAction, CalenderEnObservation, StageName
+
+
+class Scenario(TypedDict):
+    difficulty: str
+    request: str
+    participants: List[str]
+    availability: Dict[str, List[str]]
+    constraints: Dict[str, str]
+    ground_truth: str
+
+
+SCENARIOS: List[Scenario] = [
+    {
+        "difficulty": "easy",
+        "request": "Schedule a 30 minute kickoff between Alex and Priya before April 9.",
+        "participants": ["Alex", "Priya"],
+        "availability": {
+            "Alex": [
+                "2026-04-08 10:00-10:30 UTC",
+                "2026-04-08 14:00-14:30 UTC",
+            ],
+            "Priya": [
+                "2026-04-08 10:00-10:30 UTC",
+                "2026-04-08 16:00-16:30 UTC",
+            ],
+        },
+        "constraints": {
+            "duration": "30 minutes",
+            "priority": "kickoff meeting should happen at the earliest common slot",
+            "deadline": "2026-04-09 18:00 UTC",
+        },
+        "ground_truth": "2026-04-08 10:00-10:30 UTC",
+    },
+    {
+        "difficulty": "medium",
+        "request": "Book a 45 minute design review for Mei, Jordan, and Sam before April 12 noon.",
+        "participants": ["Mei", "Jordan", "Sam"],
+        "availability": {
+            "Mei": [
+                "2026-04-10 13:00-13:45 UTC",
+                "2026-04-11 09:00-09:45 UTC",
+            ],
+            "Jordan": [
+                "2026-04-10 13:00-13:45 UTC",
+                "2026-04-11 11:00-11:45 UTC",
+            ],
+            "Sam": [
+                "2026-04-10 13:00-13:45 UTC",
+                "2026-04-11 09:00-09:45 UTC",
+            ],
+        },
+        "constraints": {
+            "duration": "45 minutes",
+            "priority": "use the earliest shared slot that avoids missing the review deadline",
+            "deadline": "2026-04-12 12:00 UTC",
+        },
+        "ground_truth": "2026-04-10 13:00-13:45 UTC",
+    },
+    {
+        "difficulty": "hard",
+        "request": "Find a 60 minute executive sync for Elena, Ravi, Noor, and Luis before April 15 15:00 UTC.",
+        "participants": ["Elena", "Ravi", "Noor", "Luis"],
+        "availability": {
+            "Elena": [
+                "2026-04-14 08:00-09:00 UTC",
+                "2026-04-15 09:00-10:00 UTC",
+            ],
+            "Ravi": [
+                "2026-04-14 08:00-09:00 UTC",
+                "2026-04-15 14:00-15:00 UTC",
+            ],
+            "Noor": [
+                "2026-04-14 08:00-09:00 UTC",
+                "2026-04-14 16:00-17:00 UTC",
+            ],
+            "Luis": [
+                "2026-04-14 08:00-09:00 UTC",
+                "2026-04-15 09:00-10:00 UTC",
+            ],
+        },
+        "constraints": {
+            "duration": "60 minutes",
+            "priority": "executive sync must include every participant and happen before the deadline",
+            "deadline": "2026-04-15 15:00 UTC",
+        },
+        "ground_truth": "2026-04-14 08:00-09:00 UTC",
+    },
+]
+
+STAGES: List[StageName] = [
+    "understand_request",
+    "evaluate_availability",
+    "propose_slot",
+    "confirm_schedule",
+]
+
+
+class CalenderEnEnvironment(Environment):
+    """A deterministic multi-step scheduling environment."""
+
+    SUPPORTS_CONCURRENT_SESSIONS: bool = True
+
+    def __init__(self) -> None:
+        self._state = State(episode_id=str(uuid4()), step_count=0)
+        self._reset_count = 0
+        self._scenario: Optional[Scenario] = None
+        self._completed_stages: List[StageName] = []
+        self._history: List[Dict[str, object]] = []
+        self._selected_slot: Optional[str] = None
+        self._done = False
+        self._solved = False
+
+    def reset(self) -> CalenderEnObservation:
+        self._state = State(episode_id=str(uuid4()), step_count=0)
+        self._scenario = SCENARIOS[self._reset_count % len(SCENARIOS)]
+        self._reset_count += 1
+        self._completed_stages = []
+        self._history = []
+        self._selected_slot = None
+        self._done = False
+        self._solved = False
+        return self._observation(
+            reward=0.0,
+            done=False,
+            feedback=(
+                f"Loaded {self._scenario['difficulty']} scheduling scenario for "
+                f"{', '.join(self._scenario['participants'])}."
+            ),
+            next_expected_stage=STAGES[0],
+        )
+
+    def step(self, action: CalenderEnAction) -> CalenderEnObservation:  # type: ignore[override]
+        if self._scenario is None:
+            raise RuntimeError("Environment must be reset before step().")
+
+        self._state.step_count += 1
+        expected_stage = self._expected_stage()
+        if expected_stage is None:
+            return self._observation(
+                reward=-1.0,
+                done=True,
+                feedback="Episode is already complete. Call reset() to start a new scenario.",
+                next_expected_stage=None,
+            )
+
+        if action.stage in self._completed_stages:
+            return self._observation(
+                reward=-1.5,
+                done=self._done,
+                feedback=f"Stage '{action.stage}' was already completed. Repeated actions are penalized.",
+                next_expected_stage=expected_stage,
+            )
+
+        if action.stage != expected_stage:
+            return self._observation(
+                reward=-1.0,
+                done=False,
+                feedback=f"Invalid stage order. Expected '{expected_stage}' next.",
+                next_expected_stage=expected_stage,
+            )
+
+        handler = getattr(self, f"_handle_{action.stage}")
+        reward, feedback = handler(action)
+        self._history.append(
+            {
+                "stage": action.stage,
+                "proposed_time_slot": action.proposed_time_slot,
+                "confirm_schedule": action.confirm_schedule,
+                "reward": reward,
+                "feedback": feedback,
+            }
+        )
+        self._completed_stages.append(action.stage)
+        next_stage = self._expected_stage()
+        self._done = next_stage is None
+        return self._observation(
+            reward=reward,
+            done=self._done,
+            feedback=feedback,
+            next_expected_stage=next_stage,
+        )
+
+    @property
+    def state(self) -> State:
+        return self._state
+
+    @property
+    def history(self) -> List[Dict[str, object]]:
+        return list(self._history)
+
+    @property
+    def solved(self) -> bool:
+        return self._solved
+
+    def _expected_stage(self) -> Optional[StageName]:
+        if len(self._completed_stages) >= len(STAGES):
+            return None
+        return STAGES[len(self._completed_stages)]
+
+    def _handle_understand_request(self, action: CalenderEnAction) -> tuple[float, str]:
+        note = action.final_note.lower()
+        if action.proposed_time_slot or action.confirm_schedule:
+            return -0.5, "Understanding stage should not propose or confirm a schedule yet."
+        if "participant" in note or "deadline" in note or "objective" in note:
+            return 1.0, "Request understood. Participants and deadline were identified correctly."
+        return 0.5, "Request acknowledged. More explicit mention of participants or deadline would be better."
+
+    def _handle_evaluate_availability(self, action: CalenderEnAction) -> tuple[float, str]:
+        note = action.final_note.lower()
+        if action.proposed_time_slot or action.confirm_schedule:
+            return -0.5, "Availability stage should evaluate options before proposing a slot."
+        common_slots = self._common_slots()
+        if not common_slots:
+            return -2.0, "Scenario is misconfigured because no common slots exist."
+        if "earliest" in note or "intersect" in note or "shared" in note:
+            return 1.5, f"Availability evaluated. Common slot candidates: {', '.join(common_slots)}."
+        return 1.0, f"Availability checked. Common slot candidates: {', '.join(common_slots)}."
+
+    def _handle_propose_slot(self, action: CalenderEnAction) -> tuple[float, str]:
+        proposed_slot = action.proposed_time_slot
+        if not proposed_slot:
+            return -2.0, "A proposed_time_slot is required during the propose_slot stage."
+        if action.confirm_schedule:
+            return -0.5, "Do not confirm the meeting before the confirmation stage."
+        reward = 0.0
+        feedback_parts: List[str] = []
+        if proposed_slot not in self._common_slots():
+            reward -= 2.0
+            feedback_parts.append("Proposed slot is not available for every participant.")
+        else:
+            reward += 1.5
+            feedback_parts.append("Proposed slot satisfies shared availability.")
+        if proposed_slot == self._scenario["ground_truth"]:
+            reward += 2.0
+            feedback_parts.append("Proposed slot matches the correct deterministic solution.")
+            self._selected_slot = proposed_slot
+        else:
+            feedback_parts.append(
+                f"Correct slot is {self._scenario['ground_truth']} based on earliest valid availability."
+            )
+            self._selected_slot = proposed_slot
+        if "earliest" in action.final_note.lower() or "deadline" in action.final_note.lower():
+            reward += 0.5
+            feedback_parts.append("Proposal note reflects the deadline and priority constraints.")
+        return reward, " ".join(feedback_parts)
+
+    def _handle_confirm_schedule(self, action: CalenderEnAction) -> tuple[float, str]:
+        proposed_slot = action.proposed_time_slot or self._selected_slot
+        if not action.confirm_schedule:
+            return -2.0, "Confirmation stage requires confirm_schedule=True."
+        if not proposed_slot:
+            return -1.5, "Confirmation requires a concrete time slot."
+        if proposed_slot != self._scenario["ground_truth"]:
+            return -1.0, "Confirmation used the wrong slot."
+        reward = 2.0
+        note = action.final_note.lower()
+        if "confirmed" in note or "invite" in note:
+            reward += 1.0
+            feedback = "Schedule confirmed with a valid final note."
+        else:
+            feedback = "Schedule confirmed, but the final note should explicitly mention confirmation."
+        self._selected_slot = proposed_slot
+        self._solved = True
+        return reward, feedback
+
+    def _common_slots(self) -> List[str]:
+        if self._scenario is None:
+            return []
+        participant_slots = [
+            set(self._scenario["availability"][participant])
+            for participant in self._scenario["participants"]
+        ]
+        common = set.intersection(*participant_slots)
+        return sorted(common)
+
+    def _observation(
+        self,
+        reward: float,
+        done: bool,
+        feedback: str,
+        next_expected_stage: Optional[StageName],
+    ) -> CalenderEnObservation:
+        if self._scenario is None:
+            raise RuntimeError("Scenario is not initialized.")
+        return CalenderEnObservation(
+            request=self._scenario["request"],
+            availability=self._scenario["availability"],
+            constraints=self._scenario["constraints"],
+            step_count=self._state.step_count,
+            reward=reward,
+            done=done,
+            feedback=feedback,
+            next_expected_stage=next_expected_stage,
+        )

calender_en/server/requirements.txt

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

inference.py

@@ -0,0 +1,5 @@
+from calender_en.inference import main
+
+
+if __name__ == "__main__":
+    main()

main.py

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

openenv.yaml

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

pyproject.toml

@@ -0,0 +1,13 @@
+[project]
+name = "calender-env-v1"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+    "openenv-core[core]>=0.2.2",
+    "pytest>=8.0.0",
+]
+
+[project.scripts]
+server = "server.app:main"

server/__init__.py

@@ -0,0 +1 @@
+"""Root deployment wrappers for the SmartCalendarResolver server."""

server/app.py

@@ -0,0 +1,9 @@
+from calender_en.server.app import app, main as package_main
+
+
+def main() -> None:
+    package_main()
+
+
+if __name__ == "__main__":
+    main()

tests/conftest.py

@@ -0,0 +1,11 @@
+import sys
+from pathlib import Path
+
+
+ROOT = Path(__file__).resolve().parents[1]
+PACKAGE_ROOT = ROOT / "calender_en"
+
+for path in (ROOT, PACKAGE_ROOT):
+    path_str = str(path)
+    if path_str not in sys.path:
+        sys.path.insert(0, path_str)

tests/test_app.py

@@ -0,0 +1,12 @@
+from fastapi.testclient import TestClient
+
+from calender_en.server.app import app
+
+
+def test_health_endpoint_returns_healthy() -> None:
+    client = TestClient(app)
+
+    response = client.get("/health")
+
+    assert response.status_code == 200
+    assert response.json() == {"status":"healthy"}

tests/test_environment.py

@@ -0,0 +1,163 @@
+from calender_en.models import CalenderEnAction
+from calender_en.server.calender_en_environment import CalenderEnEnvironment
+
+
+def _advance_to_proposal(env: CalenderEnEnvironment) -> None:
+    env.step(
+        CalenderEnAction(
+            stage="understand_request",
+            final_note="Identify participants, objective, and deadline.",
+        )
+    )
+    env.step(
+        CalenderEnAction(
+            stage="evaluate_availability",
+            final_note="Intersect shared availability and choose the earliest feasible option.",
+        )
+    )
+
+
+def test_reset_returns_valid_initial_observation() -> None:
+    env = CalenderEnEnvironment()
+
+    observation = env.reset()
+
+    assert observation.request
+    assert observation.availability
+    assert observation.constraints
+    assert observation.step_count == 0
+    assert observation.reward == 0.0
+    assert observation.done is False
+    assert observation.next_expected_stage == "understand_request"
+    assert env.state.step_count == 0
+    assert env.history == []
+    assert env.solved is False
+
+
+def test_step_follows_expected_multi_stage_flow() -> None:
+    env = CalenderEnEnvironment()
+    env.reset()
+
+    understand = env.step(
+        CalenderEnAction(
+            stage="understand_request",
+            final_note="Identify participants, objective, and deadline.",
+        )
+    )
+    availability = env.step(
+        CalenderEnAction(
+            stage="evaluate_availability",
+            final_note="Intersect shared availability and prioritize the earliest option.",
+        )
+    )
+    proposal = env.step(
+        CalenderEnAction(
+            stage="propose_slot",
+            proposed_time_slot="2026-04-08 10:00-10:30 UTC",
+            final_note="Pick the earliest shared slot before the deadline.",
+        )
+    )
+    confirmation = env.step(
+        CalenderEnAction(
+            stage="confirm_schedule",
+            proposed_time_slot="2026-04-08 10:00-10:30 UTC",
+            confirm_schedule=True,
+            final_note="Confirmed and invite is ready.",
+        )
+    )
+
+    assert understand.next_expected_stage == "evaluate_availability"
+    assert availability.next_expected_stage == "propose_slot"
+    assert proposal.next_expected_stage == "confirm_schedule"
+    assert confirmation.done is True
+    assert confirmation.next_expected_stage is None
+    assert env.solved is True
+
+
+def test_deterministic_scenario_cycling() -> None:
+    env = CalenderEnEnvironment()
+
+    requests = [env.reset().request for _ in range(4)]
+
+    assert requests[0] != requests[1]
+    assert requests[1] != requests[2]
+    assert requests[0] == requests[3]
+
+
+def test_correct_slot_scores_higher_than_wrong_slot() -> None:
+    correct_env = CalenderEnEnvironment()
+    correct_env.reset()
+    _advance_to_proposal(correct_env)
+    correct = correct_env.step(
+        CalenderEnAction(
+            stage="propose_slot",
+            proposed_time_slot="2026-04-08 10:00-10:30 UTC",
+            final_note="Pick the earliest shared slot before the deadline.",
+        )
+    )
+
+    wrong_env = CalenderEnEnvironment()
+    wrong_env.reset()
+    _advance_to_proposal(wrong_env)
+    wrong = wrong_env.step(
+        CalenderEnAction(
+            stage="propose_slot",
+            proposed_time_slot="2026-04-08 14:00-14:30 UTC",
+            final_note="Pick a slot even if it is not shared.",
+        )
+    )
+
+    assert correct.reward > wrong.reward
+
+
+def test_state_updates_episode_id_step_count_history_and_solved() -> None:
+    env = CalenderEnEnvironment()
+
+    first_reset = env.reset()
+    first_episode_id = env.state.episode_id
+    assert first_reset.step_count == 0
+    assert env.history == []
+    assert env.solved is False
+
+    env.step(
+        CalenderEnAction(
+            stage="understand_request",
+            final_note="Identify participants, objective, and deadline.",
+        )
+    )
+    assert env.state.step_count == 1
+    assert len(env.history) == 1
+    assert env.history[0]["stage"] == "understand_request"
+    assert env.solved is False
+
+    env.step(
+        CalenderEnAction(
+            stage="evaluate_availability",
+            final_note="Intersect shared availability and prioritize the earliest option.",
+        )
+    )
+    env.step(
+        CalenderEnAction(
+            stage="propose_slot",
+            proposed_time_slot="2026-04-08 10:00-10:30 UTC",
+            final_note="Pick the earliest shared slot before the deadline.",
+        )
+    )
+    env.step(
+        CalenderEnAction(
+            stage="confirm_schedule",
+            proposed_time_slot="2026-04-08 10:00-10:30 UTC",
+            confirm_schedule=True,
+            final_note="Confirmed and invite is ready.",
+        )
+    )
+
+    assert env.state.step_count == 4
+    assert len(env.history) == 4
+    assert env.solved is True
+
+    env.reset()
+    assert env.state.episode_id != first_episode_id
+    assert env.state.step_count == 0
+    assert env.history == []
+    assert env.solved is False

tests/test_inference.py

@@ -0,0 +1,30 @@
+from contextlib import redirect_stdout
+from io import StringIO
+
+from calender_en import inference
+
+
+def test_inference_runs_end_to_end_without_crashing() -> None:
+    output = StringIO()
+
+    with redirect_stdout(output):
+        inference.main()
+
+    rendered = output.getvalue()
+    lines = rendered.strip().splitlines()
+    assert len(lines) == 6
+    assert lines[0] == "[START] task=smart_calendar_resolution env=calender_en model=deterministic-baseline"
+    assert lines[-1] == "[END] success=true steps=4 rewards=1.00,1.50,4.00,3.00"
+    assert all(line.startswith("[STEP]") for line in lines[1:5])
+
+
+def test_inference_output_is_deterministic() -> None:
+    first = StringIO()
+    second = StringIO()
+
+    with redirect_stdout(first):
+        inference.main()
+    with redirect_stdout(second):
+        inference.main()
+
+    assert first.getvalue() == second.getvalue()