Skip to content

AI-powered virtual executive team — a single coherent executive persona backed by 8 specialist agents (FastAPI + Next.js).

fix(calendar): read workspace-mcp's plain-text reply when booking or cancelling (#510)

Rufus635de4a8d69a
diff --git a/packages/core/openexecutive/api/routes/decisions.py b/packages/core/openexecutive/api/routes/decisions.py
index 7fb04fc6..d6ab4805 100644
--- a/packages/core/openexecutive/api/routes/decisions.py
+++ b/packages/core/openexecutive/api/routes/decisions.py
@@ -440,7 +440,13 @@ async def _approve_booking(
async def _cancel_booking(instance: DecisionInstance) -> None:
"""Meeting booking: delete the event an approval created, if any."""
if not instance.external_event_id:
- return
+ if instance.status == STATUS_PROPOSED:
+ return
+ # Booked, but the event id was never read: refuse rather than report
+ # a cancel that leaves the meeting on everyone's calendar.
+ from openexecutive.orchestrator.calendar_tools import _NO_EVENT_ID
+
+ raise HTTPException(status_code=409, detail=_NO_EVENT_ID)
from openexecutive.orchestrator.calendar_tools import _do_delete_event
from openexecutive.orchestrator.mcp_gateway import get_active_gateway
diff --git a/packages/core/openexecutive/integrations/workspace/google.py b/packages/core/openexecutive/integrations/workspace/google.py
index 5a1beb67..8fe0af26 100644
--- a/packages/core/openexecutive/integrations/workspace/google.py
+++ b/packages/core/openexecutive/integrations/workspace/google.py
@@ -273,7 +273,7 @@ class GoogleMail:
def _extract_meet_link(event: dict[str, Any]) -> str | None:
"""Pull the Google Meet video URL out of a created-event response.
- The workspace-mcp ``manage_event`` returns the Calendar event object; the
+ For a Calendar event object (as JSON), the
Meet link lives under ``conferenceData.entryPoints[].uri`` for the ``video``
entry point. Some servers also surface ``hangoutLink`` directly. Tolerant of
both snake_case and camelCase key spellings.
@@ -293,6 +293,81 @@ def _extract_meet_link(event: dict[str, Any]) -> str | None:
return None
+# workspace-mcp answers ``manage_event`` in plain text ("Successfully created
+# event 'X' for [email protected]. Link: https://www.google.com/calendar/event?eid=...
+# Google Meet: https://meet.google.com/..."), and a failure as the error's
+# text. Only the gateway's own refusals are JSON.
+_CREATED_PREFIX = "successfully created event"
+_DELETED_PREFIX = "successfully deleted event"
+_EVENT_LINK_RE = re.compile(r"Link:\s*(\S+)")
+_MEET_LINK_RE = re.compile(r"(?:Google Meet|Conference):\s*(https://\S+)")
+
+
+def _json_object(raw: Any) -> dict[str, Any] | None:
+ if isinstance(raw, dict):
+ return raw
+ try:
+ parsed = json.loads(raw)
+ except (TypeError, ValueError):
+ return None
+ return parsed if isinstance(parsed, dict) else None
+
+
+def _event_id_from_link(link: str) -> str | None:
+ """The event id inside a Calendar ``htmlLink``: its ``eid`` parameter is
+ base64url of ``"<event id> <calendar id>"``."""
+ import base64
+ from urllib.parse import parse_qs, urlparse
+
+ eid = (parse_qs(urlparse(link).query).get("eid") or [""])[0]
+ if not eid:
+ return None
+ try:
+ decoded = base64.urlsafe_b64decode(eid + "=" * (-len(eid) % 4)).decode("utf-8")
+ except (ValueError, UnicodeDecodeError):
+ return None
+ event_id = decoded.split(" ", 1)[0].strip()
+ return event_id or None
+
+
+def _parse_created_event(raw: Any) -> dict[str, Any]:
+ """``{"event_id", "raw"[, "meet_link"]}`` for a created event, else
+ ``{"error"}``. A confirmed create is a success even when no id can be read
+ from it: reporting it failed would invite a second, duplicate booking."""
+ result = _json_object(raw)
+ if result is not None:
+ if "error" in result:
+ return {"error": result["error"]}
+ event_id = result.get("id") or result.get("event_id") or result.get("eventId")
+ out: dict[str, Any] = {"event_id": event_id, "raw": result}
+ meet_link = _extract_meet_link(result)
+ if meet_link:
+ out["meet_link"] = meet_link
+ return out
+ text = raw if isinstance(raw, str) else str(raw)
+ if not text.strip().lower().startswith(_CREATED_PREFIX):
+ return {"error": f"unexpected manage_event response: {text.strip()[:200]}"}
+ link = _EVENT_LINK_RE.search(text)
+ event_id = _event_id_from_link(link.group(1)) if link else None
+ if event_id is None:
+ logger.warning("calendar: created an event but read no id from its link")
+ out = {"event_id": event_id, "raw": {"text": text}}
+ meet = _MEET_LINK_RE.search(text)
+ if meet:
+ out["meet_link"] = meet.group(1)
+ return out
+
+
+def _parse_deleted_event(raw: Any) -> dict[str, Any]:
+ result = _json_object(raw)
+ if result is not None:
+ return result
+ text = raw if isinstance(raw, str) else str(raw)
+ if text.strip().lower().startswith(_DELETED_PREFIX):
+ return {"ok": True}
+ return {"error": f"unexpected manage_event response: {text.strip()[:200]}"}
+
+
class GoogleCalendar:
"""Google Calendar through workspace-mcp's single ``manage_event`` tool."""
@@ -323,19 +398,7 @@ class GoogleCalendar:
"name": "google_workspace__manage_event",
"arguments": arguments,
})
- result = json.loads(raw) if isinstance(raw, str) else raw
- # If the MCP returned an error dict, surface it directly.
- if isinstance(result, dict) and "error" in result:
- return {"error": result["error"]}
- if not isinstance(result, dict):
- return {"error": f"unexpected manage_event response: {str(result)[:200]}"}
- # The MCP returns the event object; extract the id field.
- event_id = result.get("id") or result.get("event_id") or result.get("eventId")
- meet_link = _extract_meet_link(result)
- out: dict[str, Any] = {"event_id": event_id, "raw": result}
- if meet_link:
- out["meet_link"] = meet_link
- return out
+ return _parse_created_event(raw)
except Exception as exc:
logger.exception("calendar: manage_event create failed")
return {"error": str(exc)}
@@ -355,8 +418,7 @@ class GoogleCalendar:
"send_updates": "all",
},
})
- result = json.loads(raw) if isinstance(raw, str) else raw
- return result if isinstance(result, dict) else {"ok": True}
+ return _parse_deleted_event(raw)
except Exception as exc:
logger.exception("calendar: manage_event delete failed")
return {"error": str(exc)}
diff --git a/packages/core/openexecutive/orchestrator/calendar_tools.py b/packages/core/openexecutive/orchestrator/calendar_tools.py
index 0435f17c..3064416c 100644
--- a/packages/core/openexecutive/orchestrator/calendar_tools.py
+++ b/packages/core/openexecutive/orchestrator/calendar_tools.py
@@ -976,6 +976,12 @@ async def _do_delete_event(
return await get_calendar_provider().delete_event(gateway, external_event_id)
+_NO_EVENT_ID = (
+ "This meeting was booked, but its calendar event id wasn't recorded, so it "
+ "can't be cancelled from here. Delete it in the calendar itself."
+)
+
+
async def handle_cancel_calendar_event(tool_input: dict[str, Any]) -> str:
"""Cancel a booked event by its decision_instance_id."""
from openexecutive.memory.decision_ledger import (
@@ -1013,6 +1019,11 @@ async def handle_cancel_calendar_event(tool_input: dict[str, Any]) -> str:
"error": f"cannot cancel a decision_instance with status={instance.status!r}",
})
+ # A booked meeting whose event id was never read can't be deleted here:
+ # saying it was cancelled would leave it on everyone's calendar.
+ if instance.status != "proposed" and not instance.external_event_id:
+ return json.dumps({"error": _NO_EVENT_ID})
+
# If there's an actual calendar event, delete it via the MCP.
if instance.external_event_id:
gateway = get_active_gateway()
diff --git a/packages/core/tests/unit/test_calendar_tools.py b/packages/core/tests/unit/test_calendar_tools.py
index 69df3611..8be3d9cb 100644
--- a/packages/core/tests/unit/test_calendar_tools.py
+++ b/packages/core/tests/unit/test_calendar_tools.py
@@ -545,6 +545,27 @@ def test_cancel_event_marks_reversed() -> None:
gw.call_tool.assert_awaited_once()
+def test_cancel_refuses_a_booking_whose_event_id_was_never_read() -> None:
+ from openexecutive.memory.decision_ledger import get_decision_instance, mark_resolved
+ from openexecutive.memory.episodic import DB_PATH
+
+ pid = _add_person("Alice", "[email protected]")
+ r = _call({
+ "title": "Sync", "start": _iso(FUTURE), "end": _iso(FUTURE_END),
+ "attendee_person_ids": [pid], "confidence": 0.9,
+ })
+ iid = r["decision_instance_id"]
+ mark_resolved(iid, "approved_unchanged", external_event_id=None, db_path=DB_PATH)
+
+ gw = _fake_gateway()
+ with patch("openexecutive.orchestrator.mcp_gateway.get_active_gateway", return_value=gw):
+ result = json.loads(asyncio.run(handle_cancel_calendar_event({"decision_instance_id": iid})))
+ assert "can't be cancelled from here" in result["error"]
+ gw.call_tool.assert_not_awaited()
+ instance = get_decision_instance(iid)
+ assert instance is not None and instance.status == "approved_unchanged"
+
+
def test_cancel_nonexistent_returns_error() -> None:
with patch("openexecutive.orchestrator.mcp_gateway.get_active_gateway",
return_value=_fake_gateway()):
diff --git a/packages/core/tests/unit/test_decisions_route.py b/packages/core/tests/unit/test_decisions_route.py
index 16c45652..5ebd1617 100644
--- a/packages/core/tests/unit/test_decisions_route.py
+++ b/packages/core/tests/unit/test_decisions_route.py
@@ -258,6 +258,20 @@ def test_cancel_approved_event(client: TestClient, db: Path) -> None:
fake_gw.call_tool.assert_awaited_once()
+def test_cancel_refuses_a_booking_with_no_event_id(client: TestClient, db: Path) -> None:
+ iid = _seed(db)
+ mark_resolved(iid, "approved_unchanged", db_path=db)
+ fake_gw = type("GW", (), {})()
+ fake_gw.call_tool = AsyncMock()
+
+ with patch("openexecutive.orchestrator.mcp_gateway.get_active_gateway", return_value=fake_gw):
+ res = client.post(f"/decisions/{iid}/cancel")
+
+ assert res.status_code == 409
+ assert "Delete it in the calendar itself" in res.json()["detail"]
+ fake_gw.call_tool.assert_not_awaited()
+
+
def test_cancel_unknown_404(client: TestClient) -> None:
res = client.post("/decisions/99999/cancel")
assert res.status_code == 404
diff --git a/packages/core/tests/unit/test_workspace_google.py b/packages/core/tests/unit/test_workspace_google.py
index 3d7864f4..57999be7 100644
--- a/packages/core/tests/unit/test_workspace_google.py
+++ b/packages/core/tests/unit/test_workspace_google.py
@@ -264,3 +264,46 @@ def test_fetch_never_logs_the_body(caplog: Any) -> None:
module_logger.removeHandler(caplog.handler)
assert "123456" not in caplog.text and "Offer" not in caplog.text
assert f"{len(raw)} chars" in caplog.text
+
+
+def _eid(event_id: str, calendar: str = "[email protected]") -> str:
+ import base64
+
+ return base64.urlsafe_b64encode(f"{event_id} {calendar}".encode()).decode().rstrip("=")
+
+
+def test_create_event_reads_workspace_mcp_plain_text_reply() -> None:
+ # What workspace-mcp's manage_event actually answers: text, not JSON.
+ text = (
+ f"Successfully created event 'Sync' for [email protected]. "
+ f"Link: https://www.google.com/calendar/event?eid={_eid('abc123xyz')}\n"
+ "Saved start: 2030-01-01T10:00:00+00:00\nSaved end: 2030-01-01T10:30:00+00:00 "
+ "Google Meet: https://meet.google.com/aaa-bbbb-ccc"
+ )
+ with patch("openexecutive.config.get_settings", return_value=_settings()):
+ result = asyncio.run(GoogleCalendar().create_event(_gateway(text), _payload()))
+ assert "error" not in result
+ assert result["event_id"] == "abc123xyz"
+ assert result["meet_link"] == "https://meet.google.com/aaa-bbbb-ccc"
+
+
+def test_create_event_confirmed_without_a_readable_id_is_still_a_success() -> None:
+ text = "Successfully created event 'Sync' for [email protected]. Link: No link available"
+ with patch("openexecutive.config.get_settings", return_value=_settings()):
+ result = asyncio.run(GoogleCalendar().create_event(_gateway(text), _payload()))
+ assert "error" not in result
+ assert result["event_id"] is None
+
+
+def test_create_event_text_failure_is_an_error() -> None:
+ text = "Error calling tool 'manage_event': API error 403: insufficient permissions"
+ with patch("openexecutive.config.get_settings", return_value=_settings()):
+ result = asyncio.run(GoogleCalendar().create_event(_gateway(text), _payload()))
+ assert "403" in result["error"]
+
+
+def test_delete_event_reads_plain_text_reply() -> None:
+ ok = "Successfully deleted event (ID: evt-1) from calendar 'primary' for [email protected]."
+ assert asyncio.run(GoogleCalendar().delete_event(_gateway(ok), "evt-1")) == {"ok": True}
+ failed = asyncio.run(GoogleCalendar().delete_event(_gateway("Event not found"), "evt-1"))
+ assert "error" in failed