partiful-api-mcp 1.0.2__py3-none-any.whl

partiful_api_mcp/partiful/tools/approve_guests.py

@@ -0,0 +1,79 @@
+"""Approve guests."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from partiful_api_mcp.core.errors import ErrorCode, ToolError
+from partiful_api_mcp.core.tools import tool
+from partiful_api_mcp.partiful.client import call
+from partiful_api_mcp.partiful.events import EVENT_ID, GUEST_IDS, hosted
+from partiful_api_mcp.partiful.guests import all_guests
+
+if TYPE_CHECKING:
+    from partiful_api_mcp.core.context import ToolContext
+
+INPUT_SCHEMA: dict[str, Any] = {
+    "type": "object",
+    "properties": {
+        "event_id": EVENT_ID,
+        "guest_ids": {**GUEST_IDS, "description": "Pending guest_id values from list_guests (status pending)."},
+        "all": {"type": "boolean", "description": "Approve everyone who is pending instead. Default: false."},
+    },
+    "required": ["event_id"],
+    "additionalProperties": False,
+}
+
+EXAMPLE_RESPONSE: dict[str, Any] = {"event_id": "pL8wN2aDk4Fh7JsMq9Xe", "approved": 2, "still_pending": 1}
+
+
+async def _pending(ctx: ToolContext, args: dict[str, Any]) -> list[str]:
+    """The guest ids to approve; anything not pending on a Guest Approval event is refused."""
+    event = await hosted(ctx, args["event_id"])
+    if event.get("guestAction") != "APPLY":
+        raise ToolError("This event does not use Guest Approval.", ErrorCode.INVALID_INPUT)
+    pending = {doc["id"] for doc in await all_guests(ctx, args["event_id"]) if doc.get("status") == "PENDING_APPROVAL"}
+    if args.get("all"):
+        if not pending:
+            raise ToolError("Nobody is pending on this event.", ErrorCode.INVALID_INPUT)
+        return sorted(pending)
+    ids = list(dict.fromkeys(args.get("guest_ids") or []))
+    if not ids:
+        raise ToolError("Give guest_ids or all true.", ErrorCode.INVALID_INPUT)
+    if wrong := [guest_id for guest_id in ids if guest_id not in pending]:
+        raise ToolError(f"Not pending on this event: {', '.join(wrong)}.", ErrorCode.INVALID_INPUT)
+    return ids
+
+
+async def check_approve(ctx: ToolContext, args: dict[str, Any]) -> None:
+    """Before approval: ids that are not pending fail now."""
+    await _pending(ctx, args)
+
+
+@tool(
+    name="approve_guests",
+    title="Approve guests",
+    access="write",
+    confirm=True,
+    description="Approve pending guests on a Guest Approval event.",
+    details=(
+        "Moves the given pending guests, or all of them, to Approved, as Approve on the host's guest list "
+        "does. Partiful tells each approved guest by text or email. Ids that are not pending are refused "
+        "before the call waits for your approval. Returns how many were approved and how many still wait. "
+        "Hosts only. By default you confirm each call; you can switch that off for this tool."
+    ),
+    input_schema=INPUT_SCHEMA,
+    route="POST /events/{event_id}/guests/approve",
+    example_response=EXAMPLE_RESPONSE,
+    check=check_approve,
+)
+async def approve_guests(ctx: ToolContext, args: dict[str, Any]) -> Any:
+    ids = await _pending(ctx, args)
+    if args.get("all"):
+        await call(ctx, "approveAllGuests", {"eventId": args["event_id"], "fromStatus": "PENDING_APPROVAL"})
+    else:
+        await call(ctx, "updateGuestStatuses", {"eventId": args["event_id"], "guestIds": ids, "toStatus": "APPROVED"})
+    # Not getEventInfo's counts: they are cached and still showed the approved guest as pending (21.10.2026).
+    after = await all_guests(ctx, args["event_id"])
+    left = sum(1 for doc in after if doc.get("status") == "PENDING_APPROVAL")
+    return {"event_id": args["event_id"], "approved": len(ids), "still_pending": left}

partiful_api_mcp/partiful/tools/cancel_event.py

@@ -0,0 +1,69 @@
+"""Cancel event."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from partiful_api_mcp.core.errors import ErrorCode, ToolError
+from partiful_api_mcp.core.tools import tool
+from partiful_api_mcp.partiful.client import call
+from partiful_api_mcp.partiful.events import EVENT_ID, event_info, hosted, status
+
+if TYPE_CHECKING:
+    from partiful_api_mcp.core.context import ToolContext
+
+INPUT_SCHEMA: dict[str, Any] = {
+    "type": "object",
+    "properties": {
+        "event_id": EVENT_ID,
+        "message": {"type": "string", "maxLength": 480, "description": "Note to guests sent with the cancellation."},
+        "notify_guests": {
+            "type": "boolean",
+            "description": "Let Partiful tell the guests that the event is canceled. Default: true.",
+        },
+    },
+    "required": ["event_id"],
+    "additionalProperties": False,
+}
+
+EXAMPLE_RESPONSE: dict[str, Any] = {"event_id": "hK3vQ9xLm2Pa7RtYc4Wd", "status": "canceled", "guests_notified": True}
+
+
+async def check_cancel(ctx: ToolContext, args: dict[str, Any]) -> None:
+    """Before approval: someone else's or an already canceled event fails now."""
+    event = await hosted(ctx, args["event_id"])
+    if event.get("status") == "CANCELED":
+        raise ToolError("This event is already canceled.", ErrorCode.INVALID_INPUT)
+
+
+@tool(
+    name="cancel_event",
+    title="Cancel event",
+    access="write",
+    confirm=True,
+    description="Cancel an event. Partiful notifies the guests.",
+    details=(
+        "Cancels the event as Cancel event on its page does: the page stays up marked canceled. By default "
+        "Partiful texts the guests on the list with your message, so this reaches real people; notify_guests "
+        "false cancels without telling anyone. An event that is already canceled is refused. It cannot be "
+        "undone here. Hosts only. By default you confirm each call; you can switch that off for this tool."
+    ),
+    input_schema=INPUT_SCHEMA,
+    route="POST /events/{event_id}/cancel",
+    example_response=EXAMPLE_RESPONSE,
+    check=check_cancel,
+)
+async def cancel_event(ctx: ToolContext, args: dict[str, Any]) -> Any:
+    await check_cancel(ctx, args)
+    notify = args.get("notify_guests", True)
+    await call(
+        ctx,
+        "cancelEvent",
+        {
+            "eventId": args["event_id"],
+            "cancellationMessage": (args.get("message") or "").strip(),
+            "shouldSkipNotifyGuests": not notify,
+        },
+    )
+    after = await event_info(ctx, args["event_id"])
+    return {"event_id": args["event_id"], "status": status(after), "guests_notified": bool(notify)}

partiful_api_mcp/partiful/tools/check_in_guests.py

@@ -0,0 +1,64 @@
+"""Check in guests."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from partiful_api_mcp.core.errors import ErrorCode, ToolError
+from partiful_api_mcp.core.tools import tool
+from partiful_api_mcp.partiful.client import call
+from partiful_api_mcp.partiful.events import EVENT_ID, GUEST_IDS, hosted
+from partiful_api_mcp.partiful.guests import all_guests, checked_in
+
+if TYPE_CHECKING:
+    from partiful_api_mcp.core.context import ToolContext
+
+INPUT_SCHEMA: dict[str, Any] = {
+    "type": "object",
+    "properties": {
+        "event_id": EVENT_ID,
+        "guest_ids": GUEST_IDS,
+        "undo": {"type": "boolean", "description": "Remove the check-in instead. Default: false."},
+    },
+    "required": ["event_id", "guest_ids"],
+    "additionalProperties": False,
+}
+
+EXAMPLE_RESPONSE: dict[str, Any] = {
+    "event_id": "hK3vQ9xLm2Pa7RtYc4Wd",
+    "undo": False,
+    "changed": 2,
+    "checked_in_total": 14,
+}
+
+
+@tool(
+    name="check_in_guests",
+    title="Check in guests",
+    access="write",
+    confirm=False,
+    description="Mark guests as checked in at the door, or undo it.",
+    details=(
+        "Checks the given guests in, as the host's check-in list does, or takes the check-in back with undo. "
+        "Guests get no message. Ids that are not on the guest list are refused. Returns how many guests "
+        "changed and how many are checked in now. Hosts only."
+    ),
+    input_schema=INPUT_SCHEMA,
+    route="POST /events/{event_id}/guests/check-in",
+    example_response=EXAMPLE_RESPONSE,
+)
+async def check_in_guests(ctx: ToolContext, args: dict[str, Any]) -> Any:
+    event_id, undo = args["event_id"], bool(args.get("undo"))
+    await hosted(ctx, event_id)
+    ids = list(dict.fromkeys(args["guest_ids"]))
+    before = {doc["id"]: checked_in(doc) for doc in await all_guests(ctx, event_id)}
+    if missing := [guest_id for guest_id in ids if guest_id not in before]:
+        raise ToolError(f"Not on this event's guest list: {', '.join(missing)}.", ErrorCode.INVALID_INPUT)
+    await call(ctx, "updateCheckInStatus", {"eventId": event_id, "guestIds": ids, "checkIn": not undo})
+    after = {doc["id"]: checked_in(doc) for doc in await all_guests(ctx, event_id)}
+    return {
+        "event_id": event_id,
+        "undo": undo,
+        "changed": sum(1 for guest_id in ids if before[guest_id] != after.get(guest_id)),
+        "checked_in_total": sum(after.values()),
+    }

partiful_api_mcp/partiful/tools/create_event.py

@@ -0,0 +1,96 @@
+"""Create event."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from partiful_api_mcp.core.errors import ErrorCode, ToolError
+from partiful_api_mcp.core.tools import tool
+from partiful_api_mcp.partiful.client import call
+from partiful_api_mcp.partiful.editing import FIELDS, apply
+from partiful_api_mcp.partiful.events import detail, event_info, moment, utc_iso, zone
+from partiful_api_mcp.partiful.tools.get_event import EXAMPLE_RESPONSE as EVENT
+
+if TYPE_CHECKING:
+    from partiful_api_mcp.core.context import ToolContext
+
+# What the create form saves besides the inputs (web app defaults, 21.10.2026).
+_DEFAULTS: dict[str, Any] = {
+    "showHostList": True,
+    "showGuestCount": True,
+    "showGuestList": True,
+    "showActivityTimestamps": True,
+    "displayInviteButton": True,
+    "allowGuestPhotoUpload": True,
+    "enableGuestReminders": True,
+    "rsvpsEnabled": True,
+    "allowGuestsToInviteMutuals": True,
+}
+# Set by createEvent itself; the rest of the inputs go through the same edit as update_event.
+_ON_CREATE = ("title", "start_at", "end_at", "timezone", "description")
+
+INPUT_SCHEMA: dict[str, Any] = {
+    "type": "object",
+    "properties": {
+        **FIELDS,
+        "timezone": {
+            "type": "string",
+            "description": "IANA zone the event is shown in, e.g. America/New_York. Default: the browser's zone.",
+        },
+        "visibility": {
+            "type": "string",
+            "enum": ["private", "public"],
+            "description": "private: only people with the link (default). public: anyone on or off Partiful.",
+        },
+    },
+    "required": ["title", "start_at"],
+    "additionalProperties": False,
+}
+
+EXAMPLE_RESPONSE: dict[str, Any] = {
+    **EVENT,
+    "guests": {"going": 0, "maybe": 0, "cant_go": 0, "invited": 0, "waitlist": 0, "pending": 0},
+}
+
+
+@tool(
+    name="create_event",
+    title="Create event",
+    access="write",
+    confirm=False,
+    description="New event page. Nobody is invited until you call invite_guests.",
+    details=(
+        "Creates and publishes an event page hosted by this account, as Create on partiful.com does, with "
+        "Partiful's default theme. It is private (only people with the link) unless visibility is public. "
+        "Nobody is invited or texted; share url or call invite_guests. Times without an offset are read in "
+        "timezone. Guest Approval and a guest limit exclude each other, so a call with both is refused. "
+        "Returns the new event."
+    ),
+    input_schema=INPUT_SCHEMA,
+    route="POST /events",
+    example_response=EXAMPLE_RESPONSE,
+)
+async def create_event(ctx: ToolContext, args: dict[str, Any]) -> Any:
+    tz = zone(args.get("timezone") or ctx.profile.timezone)
+    start = moment(args["start_at"], tz, "start_at")
+    event: dict[str, Any] = {
+        **_DEFAULTS,
+        "title": args["title"].strip(),
+        "startDate": utc_iso(start),
+        "timezone": tz.key,
+        "description": args.get("description") or "",
+        "status": "UNSAVED",
+        "visibility": args.get("visibility") or "private",
+    }
+    if args.get("end_at"):
+        end = moment(args["end_at"], tz, "end_at")
+        if end <= start:
+            raise ToolError("end_at must be after start_at.", ErrorCode.INVALID_INPUT)
+        event["endDate"] = utc_iso(end)
+    event_id = await call(ctx, "createEvent", {"event": event, "cohostIds": []})
+    if not isinstance(event_id, str) or not event_id:
+        raise ToolError("Partiful did not create the event.", ErrorCode.TARGET_ERROR)
+    rest = {key: value for key, value in args.items() if key in FIELDS and key not in _ON_CREATE}
+    if rest:
+        await apply(ctx, event_id, await event_info(ctx, event_id), rest)
+    return detail(await event_info(ctx, event_id))

partiful_api_mcp/partiful/tools/delete_event.py

@@ -0,0 +1,49 @@
+"""Delete event."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from partiful_api_mcp.core.tools import tool
+from partiful_api_mcp.partiful.client import call
+from partiful_api_mcp.partiful.events import EVENT_ID, hosted
+
+if TYPE_CHECKING:
+    from partiful_api_mcp.core.context import ToolContext
+
+INPUT_SCHEMA: dict[str, Any] = {
+    "type": "object",
+    "properties": {"event_id": EVENT_ID},
+    "required": ["event_id"],
+    "additionalProperties": False,
+}
+
+EXAMPLE_RESPONSE: dict[str, Any] = {"event_id": "hK3vQ9xLm2Pa7RtYc4Wd", "deleted": True}
+
+
+async def check_delete(ctx: ToolContext, args: dict[str, Any]) -> None:
+    """Before approval: someone else's event fails now."""
+    await hosted(ctx, args["event_id"])
+
+
+@tool(
+    name="delete_event",
+    title="Delete event",
+    access="write",
+    confirm=True,
+    description="Delete an event you host for everyone, with its guest list.",
+    details=(
+        "Deletes the event as Delete event in its settings does: the page, guest list, photos and messages "
+        "are gone for everyone and cannot be restored. Guests who RSVPd may be told by Partiful. To keep the "
+        "page and tell guests, use cancel_event. Hosts only. By default you confirm each call; you can "
+        "switch that off for this tool."
+    ),
+    input_schema=INPUT_SCHEMA,
+    route="DELETE /events/{event_id}",
+    example_response=EXAMPLE_RESPONSE,
+    check=check_delete,
+)
+async def delete_event(ctx: ToolContext, args: dict[str, Any]) -> Any:
+    await hosted(ctx, args["event_id"])
+    await call(ctx, "deleteEvent", {"eventId": args["event_id"]})
+    return {"event_id": args["event_id"], "deleted": True}

partiful_api_mcp/partiful/tools/duplicate_event.py

@@ -0,0 +1,83 @@
+"""Duplicate event."""
+
+from __future__ import annotations
+
+from datetime import datetime
+from typing import TYPE_CHECKING, Any
+
+from partiful_api_mcp.core.errors import ErrorCode, ToolError
+from partiful_api_mcp.core.tools import tool
+from partiful_api_mcp.partiful import firestore
+from partiful_api_mcp.partiful.client import call, id_token
+from partiful_api_mcp.partiful.events import EVENT_ID, detail, event_info, hosted, moment, zone
+from partiful_api_mcp.partiful.tools.get_event import EXAMPLE_RESPONSE as EVENT
+
+if TYPE_CHECKING:
+    from partiful_api_mcp.core.context import ToolContext
+
+INPUT_SCHEMA: dict[str, Any] = {
+    "type": "object",
+    "properties": {
+        "event_id": EVENT_ID,
+        "start_at": {
+            "type": "string",
+            "description": "Start of the copy, ISO 8601. Without an offset it is read in the event's time zone.",
+        },
+        "title": {
+            "type": "string",
+            "minLength": 1,
+            "maxLength": 200,
+            "description": "Title of the copy. Default: the same.",
+        },
+    },
+    "required": ["event_id", "start_at"],
+    "additionalProperties": False,
+}
+
+EXAMPLE_RESPONSE: dict[str, Any] = {
+    "copied_from": "aQ4tX9cEn6Hb2LsVw8Rk",
+    **EVENT,
+    "event_id": "bK7dR3nMp5Gc9TzXy1Qf",
+    "start_at": "2026-12-12T19:00:00-05:00",
+    "end_at": "2026-12-12T23:00:00-05:00",
+    "guests": {"going": 0, "maybe": 0, "cant_go": 0, "invited": 0, "waitlist": 0, "pending": 0},
+}
+
+
+@tool(
+    name="duplicate_event",
+    title="Duplicate event",
+    access="write",
+    confirm=False,
+    description="Copy an event with its settings to a new date. The copy has no guests yet.",
+    details=(
+        "Makes a copy as Duplicate on the event page does: title, description, location, theme, questionnaire "
+        "and RSVP settings, no guests and no messages. The copy starts at start_at and keeps the original's "
+        "length; Partiful does not copy the RSVP deadline. Nobody is invited. Returns the new event. Hosts only."
+    ),
+    input_schema=INPUT_SCHEMA,
+    route="POST /events/{event_id}/duplicate",
+    example_response=EXAMPLE_RESPONSE,
+)
+async def duplicate_event(ctx: ToolContext, args: dict[str, Any]) -> Any:
+    uid, _ = await id_token(ctx)
+    source = await hosted(ctx, args["event_id"])
+    tz = zone(source.get("timezone") or ctx.profile.timezone)
+    start = moment(args["start_at"], tz, "start_at")
+    copy_id = await call(ctx, "cloneEvent", {"clonedEventId": args["event_id"], "timezone": tz.key})
+    if not isinstance(copy_id, str) or not copy_id:
+        raise ToolError("Partiful did not copy the event.", ErrorCode.TARGET_ERROR)
+    changes: dict[str, Any] = {"startDate": start, "updatedBy": firestore.Ref(f"users/{uid}")}
+    old_start, old_end = _time(source.get("startDate")), _time(source.get("endDate"))
+    if old_start and old_end and old_end > old_start:
+        changes["endDate"] = start + (old_end - old_start)
+    if args.get("title"):
+        changes["title"] = args["title"].strip()
+    await firestore.update(ctx, f"events/{copy_id}", changes, () if "endDate" in changes else ("endDate",))
+    return {"copied_from": args["event_id"], **detail(await event_info(ctx, copy_id))}
+
+
+def _time(value: Any) -> datetime | None:
+    if not isinstance(value, str) or not value[:1].isdigit():
+        return None
+    return datetime.fromisoformat(value.replace("Z", "+00:00"))

partiful_api_mcp/partiful/tools/export_guest_list.py

@@ -0,0 +1,83 @@
+"""Export guest list."""
+
+from __future__ import annotations
+
+import csv
+import io
+from typing import TYPE_CHECKING, Any
+
+from partiful_api_mcp.core.errors import ErrorCode, ToolError
+from partiful_api_mcp.core.tools import tool
+from partiful_api_mcp.partiful.client import API, WEB, id_token
+from partiful_api_mcp.partiful.events import EVENT_ID, STATUS_NAMES, STATUSES, hosted
+
+if TYPE_CHECKING:
+    from partiful_api_mcp.core.context import ToolContext
+
+INPUT_SCHEMA: dict[str, Any] = {
+    "type": "object",
+    "properties": {
+        "event_id": EVENT_ID,
+        "statuses": {
+            "type": "array",
+            "items": {"type": "string", "enum": STATUS_NAMES},
+            "description": "RSVP statuses to include: going, maybe, cant_go, invited, waitlist, pending. Default: all.",
+        },
+    },
+    "required": ["event_id"],
+    "additionalProperties": False,
+}
+
+EXAMPLE_RESPONSE: dict[str, Any] = {
+    "event_id": "hK3vQ9xLm2Pa7RtYc4Wd",
+    "statuses": ["going"],
+    "rows": 1,
+    "filename": "rooftop-dinner-guests.csv",
+    "csv": (
+        "Name,Status,Checked in,Check-in Time,RSVP date,Dietary restrictions\r\n"
+        "Maya Chen,Going,No,,2026-11-02 18:21:18-05:00,Vegetarian\r\n"
+    ),
+}
+
+
+@tool(
+    name="export_guest_list",
+    title="Export guest list",
+    access="read",
+    confirm=False,
+    description="The guest list as CSV, the same file as the Export CSV button.",
+    details=(
+        "Returns the file the host's Export CSV button downloads, for the chosen RSVP statuses. Columns are "
+        "Partiful's: Name, Status, Checked in, Check-in Time, RSVP date, then one column per Guest Questionnaire "
+        "question. Status is Partiful's label, for example Approved on a Guest Approval event. The file text "
+        "comes back in csv, not as a link, with rows (guests in the file) and a suggested filename. The file "
+        "has no guest ids, emails or phone numbers; for guest ids use list_guests. Hosts only."
+    ),
+    input_schema=INPUT_SCHEMA,
+    route="GET /events/{event_id}/guests/export",
+    example_response=EXAMPLE_RESPONSE,
+)
+async def export_guest_list(ctx: ToolContext, args: dict[str, Any]) -> Any:
+    event = await hosted(ctx, args["event_id"])
+    names = list(dict.fromkeys(args.get("statuses") or STATUS_NAMES))
+    query: list[tuple[str, str]] = [("eventId", args["event_id"])]
+    query += [("statuses", value) for name in names for value in STATUSES[name]]
+    query.append(("questionnaire", "true"))
+    uid, token = await id_token(ctx)
+    response = await ctx.call(
+        "GET",
+        f"{API}/getGuestsCsv?" + "&".join(f"{key}={value}" for key, value in query),
+        headers={"origin": WEB, "referer": f"{WEB}/", "authorization": f"Bearer {token}", "x-user-id": uid},
+    )
+    if response.status != 200:
+        raise ToolError("Partiful did not export the guest list.", ErrorCode.TARGET_ERROR)
+    text = response.text
+    rows = max(0, len(list(csv.reader(io.StringIO(text)))) - 1) if text.strip() else 0
+    slug = "-".join("".join(c if c.isalnum() else " " for c in (event.get("title") or "event").lower()).split())
+    return {
+        "event_id": args["event_id"],
+        "statuses": names,
+        "rows": rows,
+        "filename": f"{slug or 'event'}-guests.csv",
+        "csv": text,
+    }

partiful_api_mcp/partiful/tools/get_event.py

@@ -0,0 +1,60 @@
+"""Get event."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from partiful_api_mcp.core.tools import tool
+from partiful_api_mcp.partiful.events import EVENT_ID, detail, event_info
+
+if TYPE_CHECKING:
+    from partiful_api_mcp.core.context import ToolContext
+
+INPUT_SCHEMA: dict[str, Any] = {
+    "type": "object",
+    "properties": {"event_id": EVENT_ID},
+    "required": ["event_id"],
+    "additionalProperties": False,
+}
+
+EXAMPLE_RESPONSE: dict[str, Any] = {
+    "event_id": "hK3vQ9xLm2Pa7RtYc4Wd",
+    "title": "Rooftop dinner",
+    "start_at": "2026-11-14T19:00:00-05:00",
+    "end_at": "2026-11-14T23:00:00-05:00",
+    "timezone": "America/New_York",
+    "location": "21 Mercer St, New York",
+    "status": "active",
+    "guests": {"going": 28, "maybe": 9, "cant_go": 4, "invited": 31, "waitlist": 0, "pending": 0},
+    "url": "https://partiful.com/e/hK3vQ9xLm2Pa7RtYc4Wd",
+    "description": "Bring a drink to share.",
+    "rsvp_deadline": "2026-11-12T18:00:00-05:00",
+    "max_guests": 60,
+    "waitlist": True,
+    "guest_approval": False,
+    "questions": ["Dietary restrictions"],
+    "visibility": "private",
+    "short_url": "https://go.partiful.com/aB3dE5fG",
+}
+
+
+@tool(
+    name="get_event",
+    title="Get event",
+    access="read",
+    confirm=False,
+    description=(
+        "Full event: title, description, start and end, location, RSVP deadline, guest limit, Guest Approval "
+        "and waitlist settings, link."
+    ),
+    details=(
+        "Returns one event as its page shows it to the host, with guests per RSVP status and the Guest "
+        "Questionnaire questions. Times are in the event's time zone. Works for any event the account can "
+        "open; the write tools need an event it hosts."
+    ),
+    input_schema=INPUT_SCHEMA,
+    route="GET /events/{event_id}",
+    example_response=EXAMPLE_RESPONSE,
+)
+async def get_event(ctx: ToolContext, args: dict[str, Any]) -> Any:
+    return detail(await event_info(ctx, args["event_id"]))