fix(outlook): don't promote a lone date-only bound to all-day on update

Regression from the previous round's date-only promotion. A single date-only
startDateTime or endDateTime satisfied "all provided bounds are date-only", so
the tool promoted to all-day and derived the missing side from the supplied one
— turning a partial reschedule of a timed or multi-day event into a one-day
all-day event and dropping the original other bound.

Implicit promotion now requires BOTH bounds to be date-only, matching
calendar_create_event. A lone date-only bound is ambiguous (convert to all-day,
or just move that edge?) and a PATCH cannot read the event's existing bounds to
disambiguate, so it stays on the timed path and leaves the other side untouched.
Deriving a missing bound remains allowed when isAllDay is set explicitly, since
that is stated intent rather than a guess.

Also pins the explicit-isAllDay-false + date-only override with a regression
test: the block always sends isAllDay for create, so an untouched switch arrives
as false, and the data shape has to win or the fix would be unreachable from the
UI.

Author: waleedlatif1

apps/sim/tools/outlook/calendar-tools.test.ts

@@ -116,6 +116,71 @@ describe('outlook calendar tools', () => {
       endDateTime: '2025-06-03T11:00:00Z',
     })
     expect(timed.isAllDay).toBeUndefined()
+
+    // Mixed date-only + timed is a timed event starting at midnight, not all-day.
+    const mixed = createBody({
+      accessToken: 't',
+      subject: 'Sync',
+      startDateTime: '2025-06-03',
+      endDateTime: '2025-06-03T11:00:00Z',
+    })
+    expect(mixed.isAllDay).toBeUndefined()
+  })
+
+  it('promotes date-only bounds even when isAllDay is explicitly false', () => {
+    // The block always sends isAllDay for create, so an untouched All Day switch arrives
+    // as `false`. Date-only bounds have no time, so honoring that false would emit a
+    // zero-length midnight window — the shape wins over the flag, by design.
+    const createBody = outlookCalendarCreateEventTool.request.body as (
+      p: unknown
+    ) => Record<string, unknown>
+    const created = createBody({
+      accessToken: 't',
+      subject: 'Company holiday',
+      startDateTime: '2025-06-03',
+      endDateTime: '2025-06-03',
+      isAllDay: false,
+    })
+    expect(created.isAllDay).toBe(true)
+    expect(created.end).toEqual({ dateTime: '2025-06-04T00:00:00', timeZone: 'UTC' })
+
+    const updateBody = outlookCalendarUpdateEventTool.request.body as (
+      p: unknown
+    ) => Record<string, unknown>
+    const updated = updateBody({
+      accessToken: 't',
+      eventId: 'e1',
+      startDateTime: '2025-06-03',
+      endDateTime: '2025-06-04',
+      isAllDay: false,
+    })
+    expect(updated.isAllDay).toBe(true)
+  })
+
+  it('does not promote a lone date-only bound on update', () => {
+    const body = outlookCalendarUpdateEventTool.request.body as (
+      p: unknown
+    ) => Record<string, unknown>
+    // Moving only the start of an existing timed/multi-day event must not collapse it into
+    // a one-day all-day event: the other bound is left untouched for Graph to preserve.
+    const movedStart = body({ accessToken: 't', eventId: 'e1', startDateTime: '2025-06-10' })
+    expect(movedStart.isAllDay).toBeUndefined()
+    expect(movedStart.start).toEqual({ dateTime: '2025-06-10T00:00:00', timeZone: 'UTC' })
+    expect('end' in movedStart).toBe(false)
+
+    const movedEnd = body({ accessToken: 't', eventId: 'e1', endDateTime: '2025-06-12' })
+    expect(movedEnd.isAllDay).toBeUndefined()
+    expect('start' in movedEnd).toBe(false)
+
+    // An explicit isAllDay:true is stated intent, so deriving the missing bound is allowed.
+    const explicit = body({
+      accessToken: 't',
+      eventId: 'e1',
+      isAllDay: true,
+      startDateTime: '2025-06-10',
+    })
+    expect(explicit.isAllDay).toBe(true)
+    expect(explicit.end).toEqual({ dateTime: '2025-06-11T00:00:00', timeZone: 'UTC' })
   })
 
   it('rejects an all-day conversion that supplies no bounds', () => {

apps/sim/tools/outlook/calendar_update_event.ts

@@ -132,13 +132,16 @@ export const outlookCalendarUpdateEventTool: ToolConfig<
       // PATCH is a partial update: only include fields the caller actually provided.
       const event: Record<string, unknown> = {}
 
-      // Date-only bounds carry no time, so they can only mean an all-day event — promote
-      // them even when the caller didn't set the flag (see calendar_create_event).
       const providedBounds = [params.startDateTime, params.endDateTime].filter(Boolean)
-      const allProvidedBoundsDateOnly =
-        providedBounds.length > 0 && providedBounds.every((bound) => isDateOnly(bound))
-      const settingAllDay =
-        (params.isAllDay !== undefined && toBool(params.isAllDay)) || allProvidedBoundsDateOnly
+      const explicitAllDay = params.isAllDay !== undefined && toBool(params.isAllDay)
+      // Promote implicitly only when BOTH bounds are date-only (matching
+      // calendar_create_event). A *single* date-only bound is ambiguous — it could mean
+      // "convert to all-day" or "just move the start" — and a PATCH cannot read the
+      // event's existing bounds to tell. Deriving the missing side would silently collapse
+      // a timed or multi-day event into a one-day all-day event, so a lone date-only bound
+      // stays on the timed path and leaves the other side untouched.
+      const bothBoundsDateOnly = isDateOnly(params.startDateTime) && isDateOnly(params.endDateTime)
+      const settingAllDay = explicitAllDay || bothBoundsDateOnly
 
       if (params.subject !== undefined) {
         event.subject = params.subject
@@ -153,8 +156,9 @@ export const outlookCalendarUpdateEventTool: ToolConfig<
             'Converting an event to all-day requires startDateTime (and preferably endDateTime): Microsoft Graph requires all-day events to have midnight start and end bounds, which cannot be derived from a partial update.'
           )
         }
-        // Normalize both bounds together — falling back to the supplied one when only a
-        // single bound was given, which `buildAllDayRange` then advances to the next day.
+        // Normalize both bounds together. The single-bound fallback only applies when the
+        // caller set isAllDay explicitly — implicit promotion requires both bounds — so
+        // deriving the missing side follows stated intent rather than guessing at it.
         const start = params.startDateTime || params.endDateTime!
         const end = params.endDateTime || params.startDateTime!
         const range = buildAllDayRange(start, end, params.timeZone)