Phase 3: CalendarAPI with 2 drifts + DriftInjector

drift.py

@@ -1,4 +1,28 @@
-"""DriftInjector — fires scheduled drift events against tools mid-episode.
+"""Drift injector — fires scheduled DriftEvents at the configured step."""
+from __future__ import annotations
 
-Will be filled in Phase 3.
-"""
+from models import DriftEvent, EpisodeState
+
+
+class DriftInjector:
+    """Stateless helper — reads drift plan from state and mutates tools."""
+
+    @staticmethod
+    def tick(state: EpisodeState, tools: dict) -> list[DriftEvent]:
+        """Fire any drifts whose fires_at_step == current state.step.
+
+        Returns list of events that fired this tick. Does NOT mark
+        detected_by_agent — that's done in environment.step() when
+        agent calls report_drift.
+        """
+        fired = []
+        for event in state.drift_plan:
+            if event.fires_at_step == state.step and not _already_fired(event):
+                tools[event.tool].apply_drift(event)
+                event.details["_fired"] = True
+                fired.append(event)
+        return fired
+
+
+def _already_fired(event: DriftEvent) -> bool:
+    return event.details.get("_fired", False)

tests/test_calendar.py

@@ -0,0 +1,182 @@
+"""CalendarAPI acceptance tests — Phase 3."""
+from __future__ import annotations
+
+import pytest
+
+from models import DriftEvent
+from tools.calendar import CalendarAPI
+
+
+def _fresh_calendar(seed_events: list[dict] | None = None) -> CalendarAPI:
+    seed = {"events": list(seed_events or [])}
+    return CalendarAPI(seed_data=seed)
+
+
+def _seeded_calendar() -> CalendarAPI:
+    return _fresh_calendar([
+        {
+            "event_id": "evt_1",
+            "title": "Kickoff",
+            "start": "2026-04-25T10:00:00Z",
+            "end": "2026-04-25T11:00:00Z",
+            "attendees": ["a@x.com"],
+            "status": "confirmed",
+        },
+        {
+            "event_id": "evt_2",
+            "title": "Review",
+            "start": "2026-04-26T10:00:00Z",
+            "end": "2026-04-26T11:00:00Z",
+            "attendees": ["b@x.com"],
+            "status": "confirmed",
+        },
+        {
+            "event_id": "evt_3",
+            "title": "Retro",
+            "start": "2026-04-27T10:00:00Z",
+            "end": "2026-04-27T11:00:00Z",
+            "attendees": ["c@x.com"],
+            "status": "confirmed",
+        },
+    ])
+
+
+def test_baseline_create_event() -> None:
+    cal = _fresh_calendar()
+    resp = cal.call(
+        "create_event",
+        {
+            "title": "Launch",
+            "start": "2026-04-25T10:00:00Z",
+            "end": "2026-04-25T11:00:00Z",
+            "attendees": ["a@x.com", "b@x.com"],
+        },
+    )
+    assert resp.ok is True
+    assert resp.status == 200
+    assert resp.body is not None
+    assert "attendees" in resp.body
+    assert "participants" not in resp.body
+    assert resp.body["status"] == "confirmed"
+    assert resp.body["attendees"] == ["a@x.com", "b@x.com"]
+    assert resp.body["event_id"].startswith("evt_")
+
+
+def test_drift_field_rename_create_event() -> None:
+    cal = _fresh_calendar()
+    event = DriftEvent(
+        tool="calendar",
+        endpoint="create_event",
+        kind="field_rename",
+        fires_at_step=1,
+        details={"from": "attendees", "to": "participants"},
+    )
+    cal.apply_drift(event)
+
+    schema = cal.get_schema("create_event")
+    assert "participants" in schema["params"]
+    assert "attendees" not in schema["params"]
+    assert "participants" in schema["required"]
+    assert "attendees" not in schema["required"]
+    assert "participants" in schema["response_shape"]
+    assert "attendees" not in schema["response_shape"]
+
+    bad = cal.call(
+        "create_event",
+        {
+            "title": "Launch",
+            "start": "2026-04-25T10:00:00Z",
+            "end": "2026-04-25T11:00:00Z",
+        },
+    )
+    assert bad.ok is False
+    assert bad.status == 400
+    assert bad.error is not None
+    assert "participants" in bad.error
+
+    ok = cal.call(
+        "create_event",
+        {
+            "title": "Launch",
+            "start": "2026-04-25T10:00:00Z",
+            "end": "2026-04-25T11:00:00Z",
+            "participants": [
+                {"email": "a@x.com", "role": "required"},
+                {"email": "b@x.com", "role": "optional"},
+            ],
+        },
+    )
+    assert ok.ok is True
+    assert ok.status == 200
+    assert ok.body is not None
+    assert "participants" in ok.body
+    assert "attendees" not in ok.body
+    assert isinstance(ok.body["participants"], list)
+    assert ok.body["participants"][0]["email"] == "a@x.com"
+
+
+def test_drift_tool_removal_delete_event() -> None:
+    cal = _seeded_calendar()
+    event = DriftEvent(
+        tool="calendar",
+        endpoint="delete_event",
+        kind="tool_removal",
+        fires_at_step=1,
+        details={"replacement": "update_event(status=cancelled)"},
+    )
+    cal.apply_drift(event)
+
+    gone = cal.call("delete_event", {"event_id": "evt_1"})
+    assert gone.ok is False
+    assert gone.status == 410
+
+    updated = cal.call("update_event", {"event_id": "evt_1", "status": "cancelled"})
+    assert updated.ok is True
+    assert updated.status == 200
+    assert updated.body is not None
+    assert updated.body["status"] == "cancelled"
+
+    still_there = [e for e in cal.events if e["event_id"] == "evt_1"]
+    assert len(still_there) == 1
+    assert still_there[0]["status"] == "cancelled"
+
+
+def test_update_event_not_found() -> None:
+    cal = _seeded_calendar()
+    resp = cal.call("update_event", {"event_id": "nonexistent", "status": "cancelled"})
+    assert resp.ok is False
+    assert resp.status == 404
+
+
+def test_list_events() -> None:
+    cal = _seeded_calendar()
+
+    wide = cal.call(
+        "list_events",
+        {"date_from": "2026-04-25T00:00:00Z", "date_to": "2026-04-28T00:00:00Z"},
+    )
+    assert wide.ok is True
+    assert wide.body is not None
+    assert len(wide.body["events"]) == 3
+
+    narrow = cal.call(
+        "list_events",
+        {"date_from": "2026-04-25T00:00:00Z", "date_to": "2026-04-25T23:59:59Z"},
+    )
+    assert narrow.ok is True
+    assert narrow.body is not None
+    assert len(narrow.body["events"]) == 1
+    assert narrow.body["events"][0]["event_id"] == "evt_1"
+
+
+def test_unknown_drift_kind_raises() -> None:
+    cal = _fresh_calendar()
+    event = DriftEvent(
+        tool="calendar",
+        endpoint="create_event",
+        kind="rate_limit_tightening",
+        fires_at_step=1,
+        details={},
+    )
+    with pytest.raises(ValueError):
+        cal.apply_drift(event)

tests/test_drift.py

@@ -0,0 +1,122 @@
+"""DriftInjector acceptance tests — Phase 3."""
+from __future__ import annotations
+
+from drift import DriftInjector
+from models import DriftEvent, EpisodeState
+from tools.calendar import CalendarAPI
+from tools.mail import MailAPI
+
+
+def _make_state(drifts: list[DriftEvent]) -> EpisodeState:
+    return EpisodeState(
+        episode_id="ep-test",
+        task_id="test-task",
+        difficulty="easy",
+        max_steps=10,
+        token_budget=4000,
+        token_budget_remaining=4000,
+        drift_plan=drifts,
+        ground_truth_final_state={},
+    )
+
+
+def _make_tools() -> dict:
+    mail = MailAPI(seed_data={"messages": [
+        {"id": "m1", "from": "a@x.com", "to": "u@org.com",
+         "subject": "s", "body": "b", "folder": "inbox"}
+    ]})
+    cal = CalendarAPI(seed_data={"events": [
+        {"event_id": "evt_1", "title": "x",
+         "start": "2026-04-25T10:00:00Z", "end": "2026-04-25T11:00:00Z",
+         "attendees": ["a@x.com"], "status": "confirmed"}
+    ]})
+    return {"mail": mail, "calendar": cal}
+
+
+def test_single_drift_fires_at_step() -> None:
+    drift = DriftEvent(
+        tool="mail", endpoint="list_messages", kind="field_rename",
+        fires_at_step=3, details={},
+    )
+    state = _make_state([drift])
+    tools = _make_tools()
+
+    state.step = 1
+    assert DriftInjector.tick(state, tools) == []
+    assert "messages" in tools["mail"].active_schemas["list_messages"].response_shape
+
+    state.step = 3
+    fired = DriftInjector.tick(state, tools)
+    assert len(fired) == 1
+    assert fired[0] is drift
+    mail_shape = tools["mail"].active_schemas["list_messages"].response_shape
+    assert "items" in mail_shape
+    assert "messages" not in mail_shape
+
+    state.step = 4
+    assert DriftInjector.tick(state, tools) == []
+
+
+def test_multiple_drifts_different_steps() -> None:
+    mail_drift = DriftEvent(
+        tool="mail", endpoint="send_message", kind="endpoint_deprecation",
+        fires_at_step=2, details={"replacement": "messages.send"},
+    )
+    cal_drift = DriftEvent(
+        tool="calendar", endpoint="create_event", kind="field_rename",
+        fires_at_step=5, details={},
+    )
+    state = _make_state([mail_drift, cal_drift])
+    tools = _make_tools()
+
+    state.step = 2
+    fired = DriftInjector.tick(state, tools)
+    assert [e.tool for e in fired] == ["mail"]
+    assert "send_message" not in tools["mail"].active_schemas
+    assert "messages.send" in tools["mail"].active_schemas
+    assert "attendees" in tools["calendar"].active_schemas["create_event"].params
+
+    state.step = 3
+    assert DriftInjector.tick(state, tools) == []
+
+    state.step = 5
+    fired = DriftInjector.tick(state, tools)
+    assert [e.tool for e in fired] == ["calendar"]
+    cal_params = tools["calendar"].active_schemas["create_event"].params
+    assert "participants" in cal_params
+    assert "attendees" not in cal_params
+
+    state.step = 6
+    assert DriftInjector.tick(state, tools) == []
+
+
+def test_drift_not_fired_before_step() -> None:
+    drift = DriftEvent(
+        tool="calendar", endpoint="create_event", kind="field_rename",
+        fires_at_step=5, details={},
+    )
+    state = _make_state([drift])
+    tools = _make_tools()
+
+    state.step = 2
+    fired = DriftInjector.tick(state, tools)
+    assert fired == []
+    cal_params = tools["calendar"].active_schemas["create_event"].params
+    assert "attendees" in cal_params
+    assert "participants" not in cal_params
+
+
+def test_detected_by_agent_unchanged_by_tick() -> None:
+    drift = DriftEvent(
+        tool="mail", endpoint="list_messages", kind="field_rename",
+        fires_at_step=1, details={},
+    )
+    state = _make_state([drift])
+    tools = _make_tools()
+    assert drift.detected_by_agent is False
+
+    state.step = 1
+    fired = DriftInjector.tick(state, tools)
+    assert len(fired) == 1
+    assert fired[0].detected_by_agent is False
+    assert state.drift_plan[0].detected_by_agent is False

tools/calendar.py

@@ -1,4 +1,164 @@
-"""CalendarAPI — list_events, create_event, update_event, delete_event + drifts.
+"""CalendarAPI — list_events, create_event, update_event, delete_event + 2 drift handlers."""
+from __future__ import annotations
 
-Will be filled in Phase 3.
-"""
+from models import DriftEvent, ToolResponse
+from tools.base import BaseTool, EndpointSchema
+
+
+_LIST_EVENTS_BASE = EndpointSchema(
+    name="list_events",
+    params={"date_from": "str", "date_to": "str", "limit": "int"},
+    required=["date_from", "date_to"],
+    response_shape={"events": "list"},
+    error_codes={200: "ok", 400: "bad_request"},
+)
+
+_CREATE_EVENT_BASE = EndpointSchema(
+    name="create_event",
+    params={
+        "title": "str", "start": "str", "end": "str",
+        "attendees": "list", "location": "str",
+    },
+    required=["title", "start", "end", "attendees"],
+    response_shape={
+        "event_id": "str", "title": "str", "start": "str", "end": "str",
+        "attendees": "list", "status": "str",
+    },
+    error_codes={200: "ok", 400: "bad_request", 422: "validation"},
+)
+
+_UPDATE_EVENT_BASE = EndpointSchema(
+    name="update_event",
+    params={
+        "event_id": "str", "title": "str", "start": "str", "end": "str",
+        "attendees": "list", "location": "str", "status": "str",
+    },
+    required=["event_id"],
+    response_shape={"event_id": "str", "status": "str", "title": "str"},
+    error_codes={200: "ok", 404: "not_found"},
+)
+
+_DELETE_EVENT_BASE = EndpointSchema(
+    name="delete_event",
+    params={"event_id": "str"},
+    required=["event_id"],
+    response_shape={"deleted": "bool", "event_id": "str"},
+    error_codes={200: "ok", 404: "not_found"},
+)
+
+
+class CalendarAPI(BaseTool):
+    name = "calendar"
+    baseline_schemas = {
+        "list_events": _LIST_EVENTS_BASE,
+        "create_event": _CREATE_EVENT_BASE,
+        "update_event": _UPDATE_EVENT_BASE,
+        "delete_event": _DELETE_EVENT_BASE,
+    }
+
+    def __init__(self, seed_data: dict) -> None:
+        super().__init__()
+        self.events: list[dict] = list(seed_data.get("events", []))
+        self._next_id: int = len(self.events) + 1
+        self.handlers = {
+            "list_events": self._list_events,
+            "create_event": self._create_event,
+            "update_event": self._update_event,
+            "delete_event": self._delete_event,
+        }
+
+    def _list_events(self, params: dict) -> ToolResponse:
+        date_from = params["date_from"]
+        date_to = params["date_to"]
+        # Overlap: event starts on/before date_to AND ends on/after date_from.
+        filtered = [
+            e for e in self.events
+            if e.get("start", "") <= date_to and e.get("end", "") >= date_from
+        ]
+        return ToolResponse(ok=True, status=200, body={"events": filtered[:10]})
+
+    def _create_event(self, params: dict) -> ToolResponse:
+        event_id = f"evt_{self._next_id}"
+        self._next_id += 1
+
+        title = params.get("title", "")
+        start = params.get("start", "")
+        end = params.get("end", "")
+        location = params.get("location", "")
+        status = params.get("status", "confirmed")
+
+        shape = self.active_schemas["create_event"].response_shape
+        drifted = "participants" in shape
+
+        if drifted:
+            if "participants" in params:
+                participants = list(params["participants"])
+            elif "attendees" in params:
+                participants = [
+                    {"email": e, "role": "required"} for e in params["attendees"]
+                ]
+            else:
+                participants = []
+            event = {
+                "event_id": event_id, "title": title, "start": start, "end": end,
+                "participants": participants, "location": location, "status": status,
+            }
+        else:
+            attendees = list(params.get("attendees", []))
+            event = {
+                "event_id": event_id, "title": title, "start": start, "end": end,
+                "attendees": attendees, "location": location, "status": status,
+            }
+
+        self.events.append(event)
+        return ToolResponse(ok=True, status=200, body=dict(event))
+
+    def _update_event(self, params: dict) -> ToolResponse:
+        event_id = params["event_id"]
+        for event in self.events:
+            if event.get("event_id") == event_id:
+                for field in (
+                    "title", "start", "end", "attendees", "participants",
+                    "location", "status",
+                ):
+                    if field in params:
+                        event[field] = params[field]
+                return ToolResponse(ok=True, status=200, body=dict(event))
+        return ToolResponse(
+            ok=False, status=404, error=f"event {event_id} not found"
+        )
+
+    def _delete_event(self, params: dict) -> ToolResponse:
+        event_id = params["event_id"]
+        for i, event in enumerate(self.events):
+            if event.get("event_id") == event_id:
+                self.events.pop(i)
+                return ToolResponse(
+                    ok=True, status=200,
+                    body={"deleted": True, "event_id": event_id},
+                )
+        return ToolResponse(
+            ok=False, status=404, error=f"event {event_id} not found"
+        )
+
+    def apply_drift(self, event: DriftEvent) -> None:
+        if event.kind == "field_rename" and event.endpoint == "create_event":
+            schema = self.active_schemas["create_event"]
+            schema.params.pop("attendees", None)
+            schema.params["participants"] = "list"
+            schema.required = [
+                "participants" if r == "attendees" else r for r in schema.required
+            ]
+            schema.response_shape.pop("attendees", None)
+            schema.response_shape["participants"] = "list"
+            return
+
+        if event.kind == "tool_removal" and event.endpoint == "delete_event":
+            self.active_schemas.pop("delete_event", None)
+            self.handlers.pop("delete_event", None)
+            return
+
+        raise ValueError(
+            f"CalendarAPI.apply_drift: unhandled drift "
+            f"kind={event.kind!r} endpoint={event.endpoint!r}"
+        )