Skip to content

Self-improving AI Employees for everyone

10.8 KB
Raw Blame
"""Outlook Calendar via Microsoft Graph — multi-op ActionNode + AI tool.

Operations (dispatched off ``params.operation``):
- create -> POST   /me/events
- list   -> GET    /me/calendarView?startDateTime=&endDateTime=
- update -> PATCH  /me/events/{id}
- delete -> DELETE /me/events/{id}

Times are ISO 8601. ``list`` accepts ``today`` / ``today+Nd`` shortcuts
for the start/end window (mirrors the Google Calendar node).
"""

from __future__ import annotations

from datetime import datetime, timedelta
from typing import List, Literal, Optional

from pydantic import BaseModel, ConfigDict, Field

from services.plugin import ActionNode, NodeContext, NodeUserError, Operation, TaskQueue
from services.plugin.approval import ApprovalSpec

from .._base import graph_request, mailbox_base, track_microsoft_usage
from .._credentials import MicrosoftCredential

_CREATE = {"displayOptions": {"show": {"operation": ["create"]}}}
_LIST = {"displayOptions": {"show": {"operation": ["list"]}}}
_UPDATE = {"displayOptions": {"show": {"operation": ["update"]}}}
_UPDATE_OR_DELETE = {"displayOptions": {"show": {"operation": ["update", "delete"]}}}


class CalendarParams(BaseModel):
    operation: Literal["create", "list", "update", "delete"] = "list"

    # Target mailbox calendar. Empty = your own; a shared mailbox address
    # (/users/{addr}) requires Full Access + Calendars.ReadWrite.Shared.
    mailbox: str = Field(default="", description="Shared mailbox address (empty = your own calendar).")

    event_id: str = Field(default="", json_schema_extra=_UPDATE_OR_DELETE)

    # Create
    title: str = Field(default="", json_schema_extra=_CREATE)
    body: str = Field(default="", json_schema_extra={"rows": 3, **_CREATE})
    start_time: str = Field(
        default="",
        json_schema_extra={"placeholder": "2026-08-10T14:00:00", **_CREATE},
    )
    end_time: str = Field(
        default="",
        json_schema_extra={"placeholder": "2026-08-10T15:00:00", **_CREATE},
    )
    location: str = Field(default="", json_schema_extra=_CREATE)
    attendees: str = Field(
        default="",
        json_schema_extra={"placeholder": "[email protected], [email protected]", **_CREATE},
    )
    timezone: str = Field(default="UTC", json_schema_extra=_CREATE)

    # List
    start_date: str = Field(default="", json_schema_extra={"placeholder": "today", **_LIST})
    end_date: str = Field(default="", json_schema_extra={"placeholder": "today+7d", **_LIST})
    max_results: int = Field(default=10, ge=1, le=250, json_schema_extra=_LIST)

    # Update
    update_title: str = Field(default="", json_schema_extra=_UPDATE)
    update_start_time: str = Field(default="", json_schema_extra=_UPDATE)
    update_end_time: str = Field(default="", json_schema_extra=_UPDATE)
    update_body: str = Field(default="", json_schema_extra={"rows": 3, **_UPDATE})
    update_location: str = Field(default="", json_schema_extra=_UPDATE)

    model_config = ConfigDict(extra="ignore")


class CalendarOutput(BaseModel):
    operation: Optional[str] = None
    event_id: Optional[str] = None
    title: Optional[str] = None
    start: Optional[str] = None
    end: Optional[str] = None
    web_link: Optional[str] = None
    location: Optional[str] = None
    events: Optional[List[dict]] = None
    count: Optional[int] = None
    time_range: Optional[dict] = None
    deleted: Optional[bool] = None

    model_config = ConfigDict(extra="allow")


def _iso_or_shortcut(value: str, default_offset_days: int = 0) -> str:
    """Resolve ISO datetime or ``today`` / ``today+Nd`` shortcut to ISO 8601."""
    now = datetime.utcnow()
    if not value or value.lower() == "today":
        base = now.replace(hour=0, minute=0, second=0, microsecond=0) if default_offset_days == 0 else now + timedelta(days=default_offset_days)
        return base.isoformat()
    if value.startswith("today+"):
        days = int(value.replace("today+", "").replace("d", ""))
        return (now + timedelta(days=days)).isoformat()
    return value


def _attendees(raw: str) -> list:
    parts = [p.strip() for chunk in raw.split(",") for p in chunk.split(";")]
    return [{"emailAddress": {"address": addr}, "type": "required"} for addr in parts if addr]


def _summarize(ev: dict) -> dict:
    return {
        "event_id": ev.get("id"),
        "title": ev.get("subject", "No Title"),
        "start": (ev.get("start") or {}).get("dateTime"),
        "end": (ev.get("end") or {}).get("dateTime"),
        "location": (ev.get("location") or {}).get("displayName", ""),
        "organizer": ((ev.get("organizer") or {}).get("emailAddress") or {}).get("address", ""),
        "web_link": ev.get("webLink"),
        "is_all_day": ev.get("isAllDay"),
    }


class CalendarNode(ActionNode):
    type = "msCalendar"
    display_name = "Outlook Calendar"
    subtitle = "Event Management"
    group = ("microsoft", "tool")
    description = "Microsoft Outlook Calendar create / list / update / delete events via Graph (workflow + AI tool)"
    component_kind = "square"
    tool_name = "ms_calendar"
    tool_description = (
        "Manage Outlook Calendar events via Microsoft Graph. Operations: "
        "create (new event), list (events in a date range), update (modify event), delete (remove event)."
    )
    handles = (
        {"name": "input-main", "kind": "input", "position": "left", "label": "Input", "role": "main"},
        {"name": "output-main", "kind": "output", "position": "right", "label": "Output", "role": "main"},
    )
    credentials = (MicrosoftCredential,)
    annotations = {"destructive": False, "readonly": False, "open_world": True}
    task_queue = TaskQueue.REST_API
    usable_as_tool = True
    # An event with attendees sends them invites.
    approval = ApprovalSpec(
        channel="Outlook Calendar",
        action="Send meeting invites",
        outcome_labels=("Invites sent", "Invites not sent"),
        operations=frozenset({"create", "update"}),
        when=lambda data: bool(str(data.get("attendees") or "").strip()),
        recipient=("attendees",),
        body=("body", "update_body"),
        details=(("Event", "title"), ("Starts", "start_time"), ("Ends", "end_time"), ("Where", "location")),
    )

    Params = CalendarParams
    Output = CalendarOutput

    @Operation("dispatch")
    async def dispatch(self, ctx: NodeContext, params: CalendarParams) -> CalendarOutput:
        op = params.operation
        if op == "create":
            return await self._create(ctx, params)
        if op == "list":
            return await self._list(ctx, params)
        if op == "update":
            return await self._update(ctx, params)
        if op == "delete":
            return await self._delete(ctx, params)
        raise NodeUserError(f"Unknown Calendar operation: {op}")

    async def _create(self, ctx: NodeContext, params: CalendarParams) -> CalendarOutput:
        if not params.title:
            raise NodeUserError("Event title is required")
        if not params.start_time or not params.end_time:
            raise NodeUserError("Start time and end time are required")

        event = {
            "subject": params.title,
            "start": {"dateTime": params.start_time, "timeZone": params.timezone},
            "end": {"dateTime": params.end_time, "timeZone": params.timezone},
        }
        if params.body:
            event["body"] = {"contentType": "Text", "content": params.body}
        if params.location:
            event["location"] = {"displayName": params.location}
        if params.attendees:
            event["attendees"] = _attendees(params.attendees)

        result = await graph_request(ctx, "POST", f"{mailbox_base(params.mailbox)}/events", json=event)
        await track_microsoft_usage(ctx.node_id, "create", 1, ctx.raw)
        summary = _summarize(result or {})
        return CalendarOutput(
            operation="create",
            event_id=summary["event_id"],
            title=summary["title"],
            start=summary["start"],
            end=summary["end"],
            location=summary["location"],
            web_link=summary["web_link"],
        )

    async def _list(self, ctx: NodeContext, params: CalendarParams) -> CalendarOutput:
        start = _iso_or_shortcut(params.start_date)
        end = _iso_or_shortcut(params.end_date, default_offset_days=7)
        data = await graph_request(
            ctx,
            "GET",
            f"{mailbox_base(params.mailbox)}/calendarView",
            params={
                "startDateTime": start,
                "endDateTime": end,
                "$top": min(params.max_results, 250),
                "$orderby": "start/dateTime",
                "$select": "id,subject,start,end,location,organizer,webLink,isAllDay",
            },
        )
        items = (data or {}).get("value", [])
        formatted = [_summarize(e) for e in items]
        await track_microsoft_usage(ctx.node_id, "list", len(formatted), ctx.raw)
        return CalendarOutput(
            operation="list",
            events=formatted,
            count=len(formatted),
            time_range={"start": start, "end": end},
        )

    async def _update(self, ctx: NodeContext, params: CalendarParams) -> CalendarOutput:
        if not params.event_id:
            raise NodeUserError("Event ID is required")

        patch: dict = {}
        if params.update_title:
            patch["subject"] = params.update_title
        if params.update_start_time:
            patch["start"] = {"dateTime": params.update_start_time, "timeZone": params.timezone}
        if params.update_end_time:
            patch["end"] = {"dateTime": params.update_end_time, "timeZone": params.timezone}
        if params.update_body:
            patch["body"] = {"contentType": "Text", "content": params.update_body}
        if params.update_location:
            patch["location"] = {"displayName": params.update_location}

        if not patch:
            raise NodeUserError("No update fields provided")

        result = await graph_request(ctx, "PATCH", f"{mailbox_base(params.mailbox)}/events/{params.event_id}", json=patch)
        await track_microsoft_usage(ctx.node_id, "update", 1, ctx.raw)
        summary = _summarize(result or {})
        return CalendarOutput(
            operation="update",
            event_id=summary["event_id"] or params.event_id,
            title=summary["title"],
            start=summary["start"],
            end=summary["end"],
            location=summary["location"],
            web_link=summary["web_link"],
        )

    async def _delete(self, ctx: NodeContext, params: CalendarParams) -> CalendarOutput:
        if not params.event_id:
            raise NodeUserError("Event ID is required")
        await graph_request(ctx, "DELETE", f"{mailbox_base(params.mailbox)}/events/{params.event_id}")
        await track_microsoft_usage(ctx.node_id, "delete", 1, ctx.raw)
        return CalendarOutput(operation="delete", deleted=True, event_id=params.event_id)