chore: import upstream snapshot with attribution

apps/sim/tools/google_calendar/invite.ts

@@ -0,0 +1,275 @@
+import {
+  CALENDAR_API_BASE,
+  type CalendarAttendee,
+  type GoogleCalendarApiEventResponse,
+  type GoogleCalendarInviteParams,
+  type GoogleCalendarInviteResponse,
+} from '@/tools/google_calendar/types'
+import { normalizeAttendees } from '@/tools/google_calendar/utils'
+import type { ToolConfig } from '@/tools/types'
+
+interface InviteResult {
+  data: GoogleCalendarApiEventResponse
+  totalAttendees: number
+  newAttendeesAdded: number
+  shouldReplace: boolean
+}
+
+/**
+ * The Google Calendar update method replaces the entire event resource, so to invite
+ * attendees we read the existing event, merge the attendee list, then PUT it back.
+ */
+async function inviteAttendees(
+  response: Response,
+  params: GoogleCalendarInviteParams | undefined
+): Promise<InviteResult> {
+  const existingEvent: GoogleCalendarApiEventResponse = await response.json()
+
+  if (!existingEvent.start || !existingEvent.end || !existingEvent.summary) {
+    throw new Error('Existing event is missing required fields (start, end, or summary)')
+  }
+
+  const newAttendeeList = normalizeAttendees(params?.attendees).map((attendee) => attendee.email)
+  const existingAttendees: CalendarAttendee[] = existingEvent.attendees ?? []
+  const shouldReplace =
+    params?.replaceExisting === true || String(params?.replaceExisting) === 'true'
+
+  const existingEmails = new Set(
+    existingAttendees.map((attendee) => attendee.email?.toLowerCase() ?? '')
+  )
+  const newAttendeesAdded = shouldReplace
+    ? newAttendeeList.length
+    : newAttendeeList.filter((email) => !existingEmails.has(email.toLowerCase())).length
+
+  let finalAttendees: CalendarAttendee[]
+  if (shouldReplace) {
+    finalAttendees = newAttendeeList.map((email) => ({ email, responseStatus: 'needsAction' }))
+  } else {
+    finalAttendees = [...existingAttendees]
+    for (const email of newAttendeeList) {
+      if (!existingEmails.has(email.toLowerCase())) {
+        finalAttendees.push({ email, responseStatus: 'needsAction' })
+      }
+    }
+  }
+
+  const updatedEvent: Record<string, unknown> = { ...existingEvent, attendees: finalAttendees }
+  const readOnlyFields = [
+    'id',
+    'etag',
+    'kind',
+    'created',
+    'updated',
+    'htmlLink',
+    'iCalUID',
+    'creator',
+    'organizer',
+  ]
+  for (const field of readOnlyFields) {
+    delete updatedEvent[field]
+  }
+
+  const calendarId = params?.calendarId?.trim() || 'primary'
+  const queryParams = new URLSearchParams()
+  queryParams.append('sendUpdates', params?.sendUpdates ?? 'all')
+  const putUrl = `${CALENDAR_API_BASE}/calendars/${encodeURIComponent(calendarId)}/events/${encodeURIComponent(params?.eventId?.trim() ?? '')}?${queryParams.toString()}`
+
+  const putResponse = await fetch(putUrl, {
+    method: 'PUT',
+    headers: {
+      Authorization: `Bearer ${params?.accessToken}`,
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify(updatedEvent),
+  })
+
+  if (!putResponse.ok) {
+    const errorData = await putResponse.json().catch(() => null)
+    throw new Error(errorData?.error?.message || 'Failed to invite attendees to calendar event')
+  }
+
+  const data: GoogleCalendarApiEventResponse = await putResponse.json()
+  return {
+    data,
+    totalAttendees: data.attendees?.length ?? 0,
+    newAttendeesAdded,
+    shouldReplace,
+  }
+}
+
+export const inviteTool: ToolConfig<GoogleCalendarInviteParams, GoogleCalendarInviteResponse> = {
+  id: 'google_calendar_invite',
+  name: 'Google Calendar Invite Attendees',
+  description: 'Invite attendees to an existing Google Calendar event',
+  version: '1.0.0',
+
+  oauth: {
+    required: true,
+    provider: 'google-calendar',
+  },
+
+  params: {
+    accessToken: {
+      type: 'string',
+      required: true,
+      visibility: 'hidden',
+      description: 'Access token for Google Calendar API',
+    },
+    calendarId: {
+      type: 'string',
+      required: false,
+      visibility: 'user-or-llm',
+      description: 'Google Calendar ID (e.g., primary or calendar@group.calendar.google.com)',
+    },
+    eventId: {
+      type: 'string',
+      required: true,
+      visibility: 'user-or-llm',
+      description: 'Google Calendar event ID to invite attendees to',
+    },
+    attendees: {
+      type: 'array',
+      required: true,
+      visibility: 'user-or-llm',
+      description: 'Array of attendee email addresses to invite',
+    },
+    sendUpdates: {
+      type: 'string',
+      required: false,
+      visibility: 'user-only',
+      description: 'How to send updates to attendees: all, externalOnly, or none (defaults to all)',
+    },
+    replaceExisting: {
+      type: 'boolean',
+      required: false,
+      visibility: 'user-only',
+      description: 'Whether to replace existing attendees or add to them (defaults to false)',
+    },
+  },
+
+  request: {
+    url: (params: GoogleCalendarInviteParams) => {
+      const calendarId = params.calendarId?.trim() || 'primary'
+      return `${CALENDAR_API_BASE}/calendars/${encodeURIComponent(calendarId)}/events/${encodeURIComponent(params.eventId.trim())}`
+    },
+    method: 'GET',
+    headers: (params: GoogleCalendarInviteParams) => ({
+      Authorization: `Bearer ${params.accessToken}`,
+      'Content-Type': 'application/json',
+    }),
+  },
+
+  transformResponse: async (response: Response, params) => {
+    const { data, totalAttendees, newAttendeesAdded, shouldReplace } = await inviteAttendees(
+      response,
+      params
+    )
+
+    let baseMessage: string
+    if (shouldReplace) {
+      baseMessage = `Successfully updated event "${data.summary}" with ${totalAttendees} attendee${totalAttendees !== 1 ? 's' : ''}`
+    } else if (newAttendeesAdded > 0) {
+      baseMessage = `Successfully added ${newAttendeesAdded} new attendee${newAttendeesAdded !== 1 ? 's' : ''} to event "${data.summary}" (total: ${totalAttendees})`
+    } else {
+      baseMessage = `No new attendees added to event "${data.summary}" - all specified attendees were already invited (total: ${totalAttendees})`
+    }
+
+    const emailNote =
+      params?.sendUpdates !== 'none'
+        ? ' Email invitations are being sent asynchronously - delivery may take a few minutes and depends on recipients’ Google Calendar settings.'
+        : ' No email notifications will be sent as requested.'
+
+    return {
+      success: true,
+      output: {
+        content: baseMessage + emailNote,
+        metadata: {
+          id: data.id,
+          htmlLink: data.htmlLink,
+          status: data.status,
+          summary: data.summary,
+          description: data.description,
+          location: data.location,
+          start: data.start,
+          end: data.end,
+          attendees: data.attendees,
+          creator: data.creator,
+          organizer: data.organizer,
+        },
+      },
+    }
+  },
+
+  outputs: {
+    content: {
+      type: 'string',
+      description: 'Attendee invitation confirmation message with email delivery status',
+    },
+    metadata: {
+      type: 'json',
+      description: 'Updated event metadata including attendee list and details',
+    },
+  },
+}
+
+interface GoogleCalendarInviteV2Response {
+  success: boolean
+  output: {
+    id: string
+    htmlLink: string
+    status: string
+    summary: string | null
+    description: string | null
+    location: string | null
+    start: GoogleCalendarApiEventResponse['start']
+    end: GoogleCalendarApiEventResponse['end']
+    attendees: CalendarAttendee[] | null
+    creator: GoogleCalendarApiEventResponse['creator'] | null
+    organizer: GoogleCalendarApiEventResponse['organizer'] | null
+  }
+}
+
+export const inviteV2Tool: ToolConfig<GoogleCalendarInviteParams, GoogleCalendarInviteV2Response> =
+  {
+    id: 'google_calendar_invite_v2',
+    name: 'Google Calendar Invite Attendees',
+    description:
+      'Invite attendees to an existing Google Calendar event. Returns API-aligned fields only.',
+    version: '2.0.0',
+    oauth: inviteTool.oauth,
+    params: inviteTool.params,
+    request: inviteTool.request,
+    transformResponse: async (response: Response, params) => {
+      const { data } = await inviteAttendees(response, params)
+
+      return {
+        success: true,
+        output: {
+          id: data.id,
+          htmlLink: data.htmlLink,
+          status: data.status,
+          summary: data.summary ?? null,
+          description: data.description ?? null,
+          location: data.location ?? null,
+          start: data.start,
+          end: data.end,
+          attendees: data.attendees ?? null,
+          creator: data.creator ?? null,
+          organizer: data.organizer ?? null,
+        },
+      }
+    },
+    outputs: {
+      id: { type: 'string', description: 'Event ID' },
+      htmlLink: { type: 'string', description: 'Event link' },
+      status: { type: 'string', description: 'Event status' },
+      summary: { type: 'string', description: 'Event title', optional: true },
+      description: { type: 'string', description: 'Event description', optional: true },
+      location: { type: 'string', description: 'Event location', optional: true },
+      start: { type: 'json', description: 'Event start' },
+      end: { type: 'json', description: 'Event end' },
+      attendees: { type: 'json', description: 'Event attendees', optional: true },
+      creator: { type: 'json', description: 'Event creator', optional: true },
+      organizer: { type: 'json', description: 'Event organizer', optional: true },
+    },
+  }