Self-improving AI Employees for everyone
Python ai-agentsai-employeeai-employeesassistantautonomous-agentsco-employeescompanygrok-botinstinctloop-agentsmuseown-your-datapersonalself-hosted
"""Google Calendar — Wave 11.D.4 inlined."""
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, Operation, TaskQueue
from services.plugin.approval import ApprovalSpec
from .._credentials import GoogleCredential
from .._base import build_google_service, run_sync, track_google_usage
_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"
calendar_id: str = Field(
default="primary",
json_schema_extra={"loadOptionsMethod": "googleCalendarList"},
)
event_id: Optional[str] = Field(default=None, json_schema_extra=_UPDATE_OR_DELETE)
# Create fields
title: Optional[str] = Field(default=None, json_schema_extra=_CREATE)
description: Optional[str] = Field(default=None, json_schema_extra=_CREATE)
start_time: Optional[str] = Field(default=None, json_schema_extra=_CREATE)
end_time: Optional[str] = Field(default=None, json_schema_extra=_CREATE)
location: Optional[str] = Field(default=None, json_schema_extra=_CREATE)
attendees: Optional[str] = Field(default=None, json_schema_extra=_CREATE)
timezone: str = Field(default="UTC", json_schema_extra=_CREATE)
reminder_minutes: int = Field(default=30, json_schema_extra=_CREATE)
# List fields
start_date: Optional[str] = Field(default=None, json_schema_extra=_LIST)
end_date: Optional[str] = Field(default=None, json_schema_extra=_LIST)
max_results: int = Field(default=10, ge=1, le=250, json_schema_extra=_LIST)
single_events: bool = Field(default=True, json_schema_extra=_LIST)
order_by: str = Field(default="startTime", json_schema_extra=_LIST)
# Update + delete
send_updates: Literal["all", "externalOnly", "none"] = Field(
default="all",
json_schema_extra=_UPDATE_OR_DELETE,
)
# Update-only fields
update_title: Optional[str] = Field(default=None, json_schema_extra=_UPDATE)
update_start_time: Optional[str] = Field(default=None, json_schema_extra=_UPDATE)
update_end_time: Optional[str] = Field(default=None, json_schema_extra=_UPDATE)
update_description: Optional[str] = Field(default=None, json_schema_extra=_UPDATE)
update_location: Optional[str] = Field(default=None, 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
html_link: Optional[str] = None
status: Optional[str] = None
created: Optional[str] = None
updated: 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: Optional[str], default_offset_days: int = 0) -> str:
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() + "Z"
if value.startswith("today+"):
days = int(value.replace("today+", "").replace("d", ""))
return (now + timedelta(days=days)).isoformat() + "Z"
return value if value.endswith("Z") else value + "Z"
class CalendarNode(ActionNode):
type = "googleCalendar"
display_name = "Calendar"
subtitle = "Event Management"
group = ("google", "tool")
description = "Google Calendar create / list / update / delete events"
component_kind = "square"
tool_name = "google_calendar"
tool_description = "Manage Google Calendar events. Operations: create (new event), list (events in 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"},
)
annotations = {"destructive": False, "readonly": False, "open_world": True}
credentials = (GoogleCredential,)
task_queue = TaskQueue.REST_API
usable_as_tool = True
# An event change that notifies its guests reaches people outside.
approval = ApprovalSpec(
channel="Google Calendar",
action="Send calendar invites",
outcome_labels=("Invites sent", "Invites not sent"),
operations=frozenset({"create", "update", "delete"}),
when=lambda data: (data.get("send_updates") or "all") != "none"
and (bool(str(data.get("attendees") or "").strip()) or data.get("operation") in ("update", "delete")),
recipient=("attendees",),
recipient_otherwise="the event's guests",
body=("description", "update_description"),
details=(("Event", "title"), ("Starts", "start_time"), ("Ends", "end_time"), ("Where", "location")),
)
Params = CalendarParams
Output = CalendarOutput
@Operation("dispatch", cost={"service": "calendar", "action": "op", "count": 1})
async def dispatch(self, ctx: NodeContext, params: CalendarParams) -> CalendarOutput:
svc = await build_google_service("calendar", "v3", params.model_dump(), ctx.raw)
events_svc = svc.events()
op = params.operation
cal_id = params.calendar_id
if op == "create":
if not params.title:
raise RuntimeError("Event title is required")
if not params.start_time or not params.end_time:
raise RuntimeError("Start time and end time are required")
event = {
"summary": params.title,
"start": {"dateTime": params.start_time, "timeZone": params.timezone},
"end": {"dateTime": params.end_time, "timeZone": params.timezone},
}
if params.description:
event["description"] = params.description
if params.location:
event["location"] = params.location
if params.attendees:
att = [{"email": e.strip()} for e in params.attendees.split(",") if e.strip()]
if att:
event["attendees"] = att
if params.reminder_minutes:
event["reminders"] = {
"useDefault": False,
"overrides": [{"method": "popup", "minutes": int(params.reminder_minutes)}],
}
result = await run_sync(
lambda: events_svc.insert(
calendarId=cal_id,
body=event,
sendUpdates=params.send_updates,
).execute()
)
await track_google_usage("google_calendar", ctx.node_id, "create", 1, ctx.raw)
return CalendarOutput(
operation="create",
event_id=result.get("id"),
title=result.get("summary"),
start=result.get("start", {}).get("dateTime"),
end=result.get("end", {}).get("dateTime"),
html_link=result.get("htmlLink"),
status=result.get("status"),
created=result.get("created"),
)
if op == "list":
time_min = _iso_or_shortcut(params.start_date)
time_max = _iso_or_shortcut(params.end_date, default_offset_days=7)
single = params.single_events
kwargs = dict(
calendarId=cal_id,
timeMin=time_min,
timeMax=time_max,
maxResults=min(params.max_results, 250),
singleEvents=single,
)
if single:
kwargs["orderBy"] = params.order_by
result = await run_sync(lambda: events_svc.list(**kwargs).execute())
raw = result.get("items", [])
formatted = [
{
"event_id": e.get("id"),
"title": e.get("summary", "No Title"),
"start": e.get("start", {}).get("dateTime", e.get("start", {}).get("date")),
"end": e.get("end", {}).get("dateTime", e.get("end", {}).get("date")),
"description": e.get("description", ""),
"location": e.get("location", ""),
"status": e.get("status"),
"html_link": e.get("htmlLink"),
"attendees": [a.get("email") for a in e.get("attendees", [])],
}
for e in raw
]
await track_google_usage("google_calendar", ctx.node_id, "list", len(formatted), ctx.raw)
return CalendarOutput(
operation="list",
events=formatted,
count=len(formatted),
time_range={"start": time_min, "end": time_max},
)
if op in ("update", "delete"):
if not params.event_id:
raise RuntimeError("Event ID is required")
if op == "delete":
await run_sync(
lambda: events_svc.delete(
calendarId=cal_id,
eventId=params.event_id,
sendUpdates=params.send_updates,
).execute()
)
await track_google_usage("google_calendar", ctx.node_id, "delete", 1, ctx.raw)
return CalendarOutput(operation="delete", deleted=True, event_id=params.event_id)
event = await run_sync(lambda: events_svc.get(calendarId=cal_id, eventId=params.event_id).execute())
title = params.update_title or params.title
start = params.update_start_time or params.start_time
end = params.update_end_time or params.end_time
desc = params.update_description if params.update_description is not None else params.description
loc = params.update_location if params.update_location is not None else params.location
if title:
event["summary"] = title
if start:
tz = event.get("start", {}).get("timeZone", "UTC")
event["start"] = {"dateTime": start, "timeZone": tz}
if end:
tz = event.get("end", {}).get("timeZone", "UTC")
event["end"] = {"dateTime": end, "timeZone": tz}
if desc is not None:
event["description"] = desc
if loc is not None:
event["location"] = loc
result = await run_sync(
lambda: events_svc.update(
calendarId=cal_id,
eventId=params.event_id,
body=event,
sendUpdates=params.send_updates,
).execute()
)
await track_google_usage("google_calendar", ctx.node_id, "update", 1, ctx.raw)
return CalendarOutput(
operation="update",
event_id=result.get("id"),
title=result.get("summary"),
start=result.get("start", {}).get("dateTime"),
end=result.get("end", {}).get("dateTime"),
updated=result.get("updated"),
html_link=result.get("htmlLink"),
)
raise RuntimeError(f"Unknown Calendar operation: {op}")