Merge hf/main and keep hackathon proxy fix

Dockerfile

@@ -23,6 +23,6 @@ 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 sh -c 'curl -f "http://localhost:${PORT:-7860}/health" || exit 1'
 
-CMD ["uv", "run", "python", "-m", "uvicorn", "server.app:app", "--host", "0.0.0.0", "--port", "8000"]
+CMD ["sh", "-c", "exec uv run python -m uvicorn server.app:app --host 0.0.0.0 --port ${PORT:-7860}"]

README.md

@@ -1,3 +1,14 @@
+---
+title: Smart Calendar Resolver
+emoji: 📅
+colorFrom: blue
+colorTo: green
+sdk: docker
+app_file: app.py
+pinned: false
+---
+
+
 # Smart Calendar Resolver — OpenEnv Environment
 
 A deterministic, multi-step OpenEnv environment for evaluating agent reasoning in real-world scheduling workflows.

calender_en/inference.py

@@ -2,84 +2,176 @@
 
 import json
 import os
-from typing import Any, List
+from dataclasses import dataclass, field
+from datetime import datetime
+from typing import Any, List, Optional
+
+from openai import OpenAI
 
 try:
-    from calender_en.models import CalenderEnAction
+    from calender_en.client import CalenderEnEnv
+    from calender_en.models import CalenderEnAction, CalenderEnObservation
     from calender_en.server.calender_en_environment import CalenderEnEnvironment
 except ModuleNotFoundError:
-    from models import CalenderEnAction
+    from client import CalenderEnEnv
+    from models import CalenderEnAction, CalenderEnObservation
     from server.calender_en_environment import CalenderEnEnvironment
 
-from openai import OpenAI
-
 TASK_NAME = "smart_calendar_resolution"
 ENV_NAME = "calender_en"
 DEFAULT_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.",
-        ),
-    ]
+@dataclass
+class InferenceConfig:
+    env_base_url: str = field(default_factory=lambda: os.getenv("ENV_BASE_URL", ""))
+    llm_api_base_url: str = field(default_factory=lambda: os.getenv("API_BASE_URL", ""))
+    llm_api_key: str = field(default_factory=lambda: os.getenv("API_KEY", ""))
+    model_name: str = field(
+        default_factory=lambda: os.getenv("MODEL_NAME", DEFAULT_MODEL_NAME)
+    )
+
+
+@dataclass
+class StepOutcome:
+    observation: CalenderEnObservation
+    reward: float
+    done: bool
+
+
+class LocalEnvRunner:
+    def __init__(self) -> None:
+        self._env = CalenderEnEnvironment()
 
+    def reset(self) -> CalenderEnObservation:
+        return self._env.reset()
 
-def _env(name: str) -> str | None:
-    value = os.getenv(name)
-    if value is None:
+    def step(self, action: CalenderEnAction) -> StepOutcome:
+        observation = self._env.step(action)
+        return StepOutcome(
+            observation=observation,
+            reward=float(observation.reward),
+            done=bool(observation.done),
+        )
+
+    def close(self) -> None:
         return None
-    value = value.strip()
-    return value or None
 
 
-def _should_use_llm_proxy() -> bool:
-    return _env("API_BASE_URL") is not None or _env("API_KEY") is not None
+class RemoteEnvRunner:
+    def __init__(self, base_url: str) -> None:
+        self._client = CalenderEnEnv(base_url=base_url)
+
+    def reset(self) -> CalenderEnObservation:
+        return self._client.reset().observation
+
+    def step(self, action: CalenderEnAction) -> StepOutcome:
+        result = self._client.step(action)
+        return StepOutcome(
+            observation=result.observation,
+            reward=float(result.reward or 0.0),
+            done=bool(result.done),
+        )
+
+    def close(self) -> None:
+        self._client.close()
+
 
+def _runner(config: InferenceConfig) -> LocalEnvRunner | RemoteEnvRunner:
+    if config.env_base_url:
+        return RemoteEnvRunner(config.env_base_url)
+    return LocalEnvRunner()
 
-def _get_model_name() -> str:
-    return _env("MODEL_NAME") or DEFAULT_MODEL_NAME
 
+def _should_use_llm_proxy(config: InferenceConfig) -> bool:
+    return bool(config.llm_api_base_url or config.llm_api_key)
 
-def _create_client() -> OpenAI:
-    api_base_url = _env("API_BASE_URL")
-    api_key = _env("API_KEY")
-    model_name = _env("MODEL_NAME")
 
+def _create_proxy_client(config: InferenceConfig) -> OpenAI:
     missing = [
         name
         for name, value in (
-            ("API_BASE_URL", api_base_url),
-            ("API_KEY", api_key),
-            ("MODEL_NAME", model_name),
+            ("API_BASE_URL", config.llm_api_base_url),
+            ("API_KEY", config.llm_api_key),
+            ("MODEL_NAME", config.model_name),
         )
-        if value is None
+        if not value
     ]
     if missing:
-        missing_text = ", ".join(missing)
         raise RuntimeError(
             "Missing required hackathon environment variables: "
-            f"{missing_text}. The validator injects these automatically."
+            + ", ".join(missing)
+        )
+    return OpenAI(base_url=config.llm_api_base_url, api_key=config.llm_api_key)
+
+
+def _common_slots(observation: CalenderEnObservation) -> List[str]:
+    participant_slots = [set(slots) for slots in observation.availability.values()]
+    if not participant_slots:
+        raise ValueError("Observation does not include participant availability.")
+    return sorted(set.intersection(*participant_slots))
+
+
+def _parse_slot_start(slot: str) -> datetime:
+    return datetime.strptime(slot[:16], "%Y-%m-%d %H:%M")
+
+
+def _parse_deadline(deadline: str) -> datetime:
+    normalized = deadline.replace(" UTC", "")
+    for fmt in ("%Y-%m-%d %H:%M", "%Y-%m-%d"):
+        try:
+            return datetime.strptime(normalized, fmt)
+        except ValueError:
+            continue
+    raise ValueError(f"Unsupported deadline format: {deadline}")
+
+
+def _select_slot(observation: CalenderEnObservation) -> str:
+    common_slots = _common_slots(observation)
+    deadline = observation.constraints.get("deadline")
+    if deadline:
+        cutoff = _parse_deadline(deadline)
+        valid_slots = [slot for slot in common_slots if _parse_slot_start(slot) <= cutoff]
+        if valid_slots:
+            return valid_slots[0]
+    return common_slots[0]
+
+
+def _fallback_note(stage: str) -> str:
+    notes = {
+        "understand_request": "Identify the meeting objective, participants, and deadline.",
+        "evaluate_availability": "Intersect participant availability and filter slots before the deadline.",
+        "propose_slot": "Choose the earliest common 30 minute slot before the deadline.",
+        "confirm_schedule": "Confirmed with all participants and calendar invite is ready.",
+    }
+    return notes[stage]
+
+
+def _planned_action(observation: CalenderEnObservation) -> CalenderEnAction:
+    stage = observation.next_expected_stage
+    if stage is None:
+        raise ValueError("No next stage available.")
+
+    if stage == "understand_request":
+        return CalenderEnAction(stage=stage, final_note=_fallback_note(stage))
+
+    if stage == "evaluate_availability":
+        return CalenderEnAction(stage=stage, final_note=_fallback_note(stage))
+
+    slot = _select_slot(observation)
+    if stage == "propose_slot":
+        return CalenderEnAction(
+            stage=stage,
+            proposed_time_slot=slot,
+            final_note=_fallback_note(stage),
         )
 
-    return OpenAI(base_url=api_base_url, api_key=api_key)
+    return CalenderEnAction(
+        stage=stage,
+        proposed_time_slot=slot,
+        confirm_schedule=True,
+        final_note=_fallback_note(stage),
+    )
 
 
 def _extract_message_text(response: Any) -> str:
@@ -116,7 +208,8 @@ def _parse_action_json(payload: str) -> CalenderEnAction:
 
 def _generate_action_with_proxy(
     client: OpenAI,
-    observation: Any,
+    config: InferenceConfig,
+    observation: CalenderEnObservation,
     planned_action: CalenderEnAction,
 ) -> CalenderEnAction:
     prompt_payload = {
@@ -129,7 +222,7 @@ def _generate_action_with_proxy(
         "planned_action": planned_action.model_dump(),
     }
     response = client.chat.completions.create(
-        model=_get_model_name(),
+        model=config.model_name,
         temperature=0,
         messages=[
             {
@@ -160,51 +253,50 @@ def _format_action(action: CalenderEnAction) -> str:
 
 
 def main() -> None:
-    env = CalenderEnEnvironment()
+    config = InferenceConfig()
+    env = _runner(config)
     rewards: List[str] = []
     steps = 0
     success = False
-    use_llm_proxy = _should_use_llm_proxy()
-    client = _create_client() if use_llm_proxy else None
-    model_name = _get_model_name()
+    client = _create_proxy_client(config) if _should_use_llm_proxy(config) else None
 
-    print(f"[START] task={TASK_NAME} env={ENV_NAME} model={model_name}")
+    print(f"[START] task={TASK_NAME} env={ENV_NAME} model={config.model_name}")
 
     try:
         observation = env.reset()
-        for planned_action in _policy():
-            steps += 1
-            error = "null"
+        while not observation.done and observation.next_expected_stage is not None:
+            planned_action = _planned_action(observation)
             action = planned_action
+            steps += 1
             try:
-                action = (
-                    _generate_action_with_proxy(client, observation, planned_action)
-                    if client is not None
-                    else planned_action
-                )
-                observation = env.step(action)
-                reward_text = f"{observation.reward:.2f}"
-                done_text = str(observation.done).lower()
+                if client is not None:
+                    action = _generate_action_with_proxy(
+                        client, config, observation, planned_action
+                    )
+                outcome = env.step(action)
+                observation = outcome.observation
+                reward_text = f"{outcome.reward:.2f}"
                 rewards.append(reward_text)
                 print(
                     f"[STEP] step={steps} action={_format_action(action)} "
-                    f"reward={reward_text} done={done_text} error={error}"
+                    f"reward={reward_text} done={str(outcome.done).lower()} error=null"
                 )
-                success = observation.done
+                success = outcome.done
             except Exception as exc:
-                reward_text = "0.00"
-                rewards.append(reward_text)
+                rewards.append("0.00")
                 print(
                     f"[STEP] step={steps} action={_format_action(action)} "
-                    f"reward={reward_text} done=false error={str(exc)}"
+                    f"reward=0.00 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}")
+        env.close()
+        print(
+            f"[END] success={str(success).lower()} steps={steps} rewards={','.join(rewards)}"
+        )
 
 
 if __name__ == "__main__":

calender_en/server/app.py

@@ -71,11 +71,12 @@ def main() -> None:
         uvicorn calender_en.server.app:app --workers 4
     """
     import argparse
+    import os
     import uvicorn
 
     parser = argparse.ArgumentParser()
     parser.add_argument("--host", default="0.0.0.0")
-    parser.add_argument("--port", type=int, default=8000)
+    parser.add_argument("--port", type=int, default=int(os.getenv("PORT", "7860")))
     args = parser.parse_args()
     uvicorn.run(app, host=args.host, port=args.port)
 

server/app.py

@@ -1,6 +1,11 @@
 from calender_en.server.app import app, main as package_main
 
 
+@app.get("/")
+def root():
+    return {"message": "Smart Calendar Resolver is running"}
+
+
 def main() -> None:
     package_main()
 

tests/test_inference.py

@@ -1,5 +1,6 @@
 from contextlib import redirect_stdout
 from io import StringIO
+import json
 
 from calender_en import inference
 
@@ -13,7 +14,10 @@ def test_inference_runs_end_to_end_without_crashing() -> None:
     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[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])
 
@@ -30,26 +34,39 @@ def test_inference_output_is_deterministic() -> None:
     assert first.getvalue() == second.getvalue()
 
 
+def test_inference_reads_model_name_from_environment(monkeypatch) -> None:
+    output = StringIO()
+    monkeypatch.setenv("MODEL_NAME", "hf-eval-check")
+
+    with redirect_stdout(output):
+        inference.main()
+
+    lines = output.getvalue().strip().splitlines()
+    assert lines[0] == (
+        "[START] task=smart_calendar_resolution env=calender_en model=hf-eval-check"
+    )
+
+
 def test_inference_uses_hackathon_proxy_env_vars(monkeypatch) -> None:
     captured: dict[str, object] = {}
 
     class FakeResponse:
-        class Choice:
+        def __init__(self, content: str):
             class Message:
-                content = (
-                    '{"stage":"understand_request","proposed_time_slot":null,'
-                    '"confirm_schedule":false,'
-                    '"final_note":"Identify the meeting objective, participants, and deadline."}'
-                )
+                def __init__(self, value: str):
+                    self.content = value
 
-            message = Message()
+            class Choice:
+                def __init__(self, value: str):
+                    self.message = Message(value)
 
-        choices = [Choice()]
+            self.choices = [Choice(content)]
 
     class FakeCompletions:
         def create(self, **kwargs):
             captured["request"] = kwargs
-            return FakeResponse()
+            payload = json.loads(kwargs["messages"][1]["content"])
+            return FakeResponse(json.dumps(payload["planned_action"]))
 
     class FakeChat:
         completions = FakeCompletions()
@@ -64,16 +81,6 @@ def test_inference_uses_hackathon_proxy_env_vars(monkeypatch) -> None:
     monkeypatch.setenv("API_KEY", "proxy-test-key")
     monkeypatch.setenv("MODEL_NAME", "meta-hackathon-model")
     monkeypatch.setattr(inference, "OpenAI", FakeOpenAI)
-    monkeypatch.setattr(
-        inference,
-        "_policy",
-        lambda: [
-            inference.CalenderEnAction(
-                stage="understand_request",
-                final_note="Identify the meeting objective, participants, and deadline.",
-            )
-        ],
-    )
 
     output = StringIO()
     with redirect_stdout(output):

uv.lock

@@ -263,12 +263,14 @@ name = "calender-env-v1"
 version = "0.1.0"
 source = { virtual = "." }
 dependencies = [
+    { name = "openai" },
     { name = "openenv-core", extra = ["core"] },
     { name = "pytest" },
 ]
 
 [package.metadata]
 requires-dist = [
+    { name = "openai", specifier = ">=2.30.0" },
     { name = "openenv-core", extras = ["core"], specifier = ">=0.2.2" },
     { name = "pytest", specifier = ">=8.0.0" },
 ]