@agent-native/core 0.98.7 → 0.98.9

package/corpus/core/src/integrations/plugin.ts

@@ -80,6 +80,7 @@ import {
   claimPendingTask,
   getNextPendingTaskIdForThread,
   insertPendingTask,
+  isDuplicateEventError,
   MAX_PENDING_TASK_ATTEMPTS,
   markTaskCompleted,
   markTaskFailed,
@@ -140,6 +141,7 @@ import type {
   IntegrationsPluginOptions,
   IntegrationStatus,
   IntegrationExecutionContext,
+  IncomingMessage,
 } from "./types.js";
 import {
   listIntegrationUsageBudgets,
@@ -259,6 +261,23 @@ const REMOTE_DEVICE_ONLINE_MS = 90_000;
 // API outage every message would otherwise get another identical "try again"
 // reply. Short enough that a persistent condition still reminds the sender.
 const DECLINE_NOTICE_DEDUPE_TTL_MS = 5 * 60 * 1_000;
+const SYSTEM_NOTICE_DEDUPE_TTL_MS = 24 * 60 * 60 * 1_000;
+
+type IntegrationSystemNoticeTaskPayload = {
+  kind: "system-notice";
+  incoming: IncomingMessage;
+  text: string;
+  dedupeKey?: string;
+  dedupeTtlMs?: number;
+};
+
+function systemNoticeEventKey(
+  dedupeKey: string,
+  ttlMs: number,
+  now = Date.now(),
+): string {
+  return `system-notice:${dedupeKey}:${Math.floor(now / ttlMs)}`;
+}
 
 export async function enqueueRemoteCommand(
   envelope: RemoteCodeCommandEnvelope,
@@ -637,6 +656,66 @@ export function createIntegrationsPlugin(
     const h3 = getH3App(nitroApp);
     const P = `${FRAMEWORK_ROUTE_PREFIX}/integrations`;
 
+    async function enqueueSystemNotice(
+      event: any,
+      incoming: IncomingMessage,
+      text: string,
+      opts?: { dedupeKey?: string; dedupeTtlMs?: number },
+    ): Promise<void> {
+      if (!text.trim()) return;
+      const taskId = `notice-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+      const dedupeTtlMs = Math.max(
+        1,
+        opts?.dedupeTtlMs ?? SYSTEM_NOTICE_DEDUPE_TTL_MS,
+      );
+      const noticeThreadId = `system-notice:${taskId}`;
+      const payload: IntegrationSystemNoticeTaskPayload = {
+        kind: "system-notice",
+        incoming,
+        text,
+        ...(opts?.dedupeKey ? { dedupeKey: opts.dedupeKey } : {}),
+        ...(opts?.dedupeTtlMs ? { dedupeTtlMs: opts.dedupeTtlMs } : {}),
+      };
+      try {
+        await insertPendingTask({
+          id: taskId,
+          platform: incoming.platform,
+          // System notices are auxiliary delivery work, not the user's agent
+          // run. Give each notice its own queue lane so a retrying notice cannot
+          // block the real message task for this Slack/Telegram thread.
+          externalThreadId: noticeThreadId,
+          payload: JSON.stringify(payload),
+          ownerEmail: `integration@${incoming.platform}`,
+          externalEventKey: opts?.dedupeKey
+            ? systemNoticeEventKey(opts.dedupeKey, dedupeTtlMs)
+            : undefined,
+        });
+      } catch (err) {
+        if (isDuplicateEventError(err)) return;
+        throw err;
+      }
+
+      // The SQL row is the durable source of truth. This best-effort self-call
+      // only reduces latency; the recurring pending-task sweep retries a row
+      // if the serverless host freezes this webhook execution immediately.
+      let token: string | undefined;
+      try {
+        token = signInternalToken(taskId);
+      } catch (err) {
+        if (process.env.NODE_ENV === "production") throw err;
+      }
+      void fetch(`${getBaseUrl(event)}${P}/process-task`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          ...(token ? { Authorization: `Bearer ${token}` } : {}),
+        },
+        body: JSON.stringify({ taskId }),
+      }).catch((err) => {
+        console.warn("[integrations] System notice dispatch failed:", err);
+      });
+    }
+
     async function requireSession(event: any): Promise<boolean> {
       const session = await getSession(event).catch(() => null);
       if (session?.email) return true;
@@ -1550,6 +1629,34 @@ export function createIntegrationsPlugin(
               isIntegrationCaller: true,
             },
             async () => {
+              const taskPayload = JSON.parse(task.payload) as
+                | IntegrationSystemNoticeTaskPayload
+                | { kind?: undefined };
+              if (taskPayload.kind === "system-notice") {
+                if (!adapter.sendSystemNotice) {
+                  throw new Error(
+                    `Platform ${task.platform} cannot deliver system notices`,
+                  );
+                }
+                const config = await getIntegrationConfig(task.platform);
+                const credentialContext =
+                  await credentialContextForIntegrationConfig(config);
+                await withCredentialContext(credentialContext, () =>
+                  adapter.sendSystemNotice!(
+                    taskPayload.incoming,
+                    taskPayload.text,
+                    {
+                      ...(taskPayload.dedupeKey
+                        ? { dedupeKey: taskPayload.dedupeKey }
+                        : {}),
+                      ...(taskPayload.dedupeTtlMs
+                        ? { dedupeTtlMs: taskPayload.dedupeTtlMs }
+                        : {}),
+                    },
+                  ),
+                );
+                return;
+              }
               const resources = await loadResourcesForPrompt(
                 task.ownerEmail,
                 true,
@@ -2378,7 +2485,8 @@ export function createIntegrationsPlugin(
             null;
           if (
             incoming.platform === "slack" &&
-            incoming.conversationType === "dm"
+            incoming.conversationType === "dm" &&
+            !options?.resolveExecutionContext
           ) {
             try {
               defaultExecutionContext = await withCredentialContext(
@@ -2386,51 +2494,48 @@ export function createIntegrationsPlugin(
                 () => resolveDefaultIntegrationExecutionContext(incoming!),
               );
             } catch (err) {
-              // Only an explicit execution-context resolver may override the
-              // default Slack identity ladder. The legacy owner-only resolver
-              // predates org-bound identities and must not turn a rejected DM
-              // into an authenticated owner run.
-              if (!options?.resolveExecutionContext) {
-                const declined =
-                  err instanceof IntegrationIdentityDeclinedError ? err : null;
-                if (declined) {
-                  console.warn(
-                    `[integrations] default Slack DM identity declined message:`,
-                    declined.message,
-                  );
-                  // Best-effort polite reply back to the DM, deduped per
-                  // sender + reason so an outage doesn't produce an identical
-                  // reply for every message. Do not await Slack's API: webhook
-                  // acknowledgement has a stricter deadline than notice
-                  // delivery and must not be delayed by a slow postMessage.
-                  void withCredentialContext(credentialContext, () =>
-                    adapter.sendSystemNotice
-                      ? adapter.sendSystemNotice(
-                          incoming!,
-                          declined.userFacingMessage,
-                          {
-                            dedupeKey: `decline:${incoming!.tenantId ?? "unknown"}:${incoming!.senderId ?? "unknown"}:${declined.reason}`,
-                            dedupeTtlMs: DECLINE_NOTICE_DEDUPE_TTL_MS,
-                          },
-                        )
-                      : Promise.resolve(),
-                  ).catch((noticeErr) => {
+              // The legacy owner-only resolver predates org-bound identities
+              // and must not turn a rejected Slack DM into an authenticated
+              // owner run. Custom resolveExecutionContext is checked above and
+              // skips this default ladder entirely so apps can fully own auth
+              // without framework membership checks or identity side effects.
+              const declined =
+                err instanceof IntegrationIdentityDeclinedError ? err : null;
+              if (declined) {
+                console.warn(
+                  `[integrations] default Slack DM identity declined message:`,
+                  declined.message,
+                );
+                if (adapter.sendSystemNotice) {
+                  try {
+                    await enqueueSystemNotice(
+                      event,
+                      incoming!,
+                      declined.userFacingMessage,
+                      {
+                        dedupeKey: `decline:${incoming!.tenantId ?? "unknown"}:${incoming!.senderId ?? "unknown"}:${declined.reason}`,
+                        dedupeTtlMs: DECLINE_NOTICE_DEDUPE_TTL_MS,
+                      },
+                    );
+                  } catch (noticeErr) {
                     console.warn(
-                      `[integrations] decline notice failed:`,
+                      `[integrations] could not persist decline notice:`,
                       noticeErr instanceof Error
                         ? noticeErr.message
                         : noticeErr,
                     );
-                  });
-                } else {
-                  console.error(
-                    `[integrations] default Slack DM identity denied message:`,
-                    err,
-                  );
+                    setResponseStatus(event, 500);
+                    return { error: "notice enqueue failed" };
+                  }
                 }
-                setResponseStatus(event, 200);
-                return "ok";
+              } else {
+                console.error(
+                  `[integrations] default Slack DM identity denied message:`,
+                  err,
+                );
               }
+              setResponseStatus(event, 200);
+              return "ok";
             }
           }
           let executionContext: IntegrationExecutionContext = {
@@ -2456,14 +2561,42 @@ export function createIntegrationsPlugin(
           } else if (defaultExecutionContext) {
             executionContext = defaultExecutionContext;
             if (defaultExecutionContext.anonymousMember) {
+              if (!options?.allowAnonymousOrgScopedSlackDm) {
+                const senderEmail =
+                  typeof incoming.senderEmail === "string" &&
+                  incoming.senderEmail.trim()
+                    ? incoming.senderEmail.trim()
+                    : null;
+                const noticeText = senderEmail
+                  ? `I couldn't match your Slack account to an organization member, so I can't run this request. Ask an organization admin to add ${senderEmail}, then try again.`
+                  : "I couldn't verify your Slack account email, so I can't run this request. Ask an organization admin to reconnect Slack with the users:read.email scope, then try again.";
+                if (adapter.sendSystemNotice) {
+                  try {
+                    await enqueueSystemNotice(event, incoming, noticeText, {
+                      dedupeKey: `anonymous-tier-disabled:${incoming.tenantId ?? "unknown"}:${incoming.senderId ?? "unknown"}`,
+                    });
+                  } catch (noticeErr) {
+                    console.warn(
+                      `[integrations] could not persist unlinked-member notice:`,
+                      noticeErr instanceof Error
+                        ? noticeErr.message
+                        : noticeErr,
+                    );
+                    setResponseStatus(event, 500);
+                    return { error: "notice enqueue failed" };
+                  }
+                }
+                setResponseStatus(event, 200);
+                return "ok";
+              }
               // The anonymous tier must never be silent. (1) The agent run
               // can tell: the note rides the serialized `incoming` into the
               // queued task and surfaces via <integration-context>.
               incoming.identityNote =
                 "Caller is an unlinked Slack workspace member running with organization-wide visibility only; personal or privately-shared data is not accessible. They can get personal access by having an admin add their Slack email to the organization (or by reconnecting Slack with the users:read.email scope).";
-              // (2) The sender gets a one-time heads-up (adapter-throttled per
-              // sender). Fire-and-forget so it never delays or replaces the
-              // normal agent run.
+              // (2) The sender gets a one-time heads-up through the same
+              // durable SQL queue as agent work. The self-dispatch is only a
+              // latency optimization; the retry sweep guarantees delivery.
               if (adapter.sendSystemNotice) {
                 const senderEmail =
                   typeof incoming.senderEmail === "string" &&
@@ -2473,16 +2606,18 @@ export function createIntegrationsPlugin(
                 const noticeText = senderEmail
                   ? `Heads up: I couldn't match your Slack account to an organization member, so I can only use org-wide data. Ask an admin to add ${senderEmail} to the organization for personal access.`
                   : "Heads up: I couldn't verify your Slack account's email, so I can only use org-wide data. Ask an admin to update the Slack connection with the users:read.email scope for personal access.";
-                void withCredentialContext(credentialContext, () =>
-                  adapter.sendSystemNotice!(incoming!, noticeText, {
+                try {
+                  await enqueueSystemNotice(event, incoming, noticeText, {
                     dedupeKey: `anonymous-tier:${incoming.tenantId ?? "unknown"}:${incoming.senderId ?? "unknown"}`,
-                  }),
-                ).catch((noticeErr) => {
+                  });
+                } catch (noticeErr) {
                   console.warn(
-                    `[integrations] anonymous-tier notice failed:`,
+                    `[integrations] could not persist anonymous-tier notice:`,
                     noticeErr instanceof Error ? noticeErr.message : noticeErr,
                   );
-                });
+                  setResponseStatus(event, 500);
+                  return { error: "notice enqueue failed" };
+                }
               }
             }
           } else if (options?.resolveOwner) {

package/corpus/core/src/integrations/types.ts

@@ -438,6 +438,13 @@ export interface IntegrationsPluginOptions {
   resolveExecutionContext?: (
     incoming: IncomingMessage,
   ) => IntegrationExecutionContext | Promise<IntegrationExecutionContext>;
+  /**
+   * Explicitly allow an unlinked, verified Slack workspace member to run a DM
+   * with the installation organization's shared/service visibility. Disabled
+   * by default: DM identity resolution fails closed unless an app deliberately
+   * accepts this wider access tier.
+   */
+  allowAnonymousOrgScopedSlackDm?: boolean;
   /**
    * Optional preprocessor for inbound platform messages. Can intercept special
    * commands (such as `/link`) before the agent loop runs.

package/corpus/core/src/mcp/build-server.ts

@@ -512,28 +512,91 @@ function routePathFromOpenUrl(value: string): string | null {
  * `mcpApp.resource` (the resource path already strips them via
  * `mcpAppStructuredContent`).
  *
- * Depth-capped to avoid pathological / circular structures. Strings that
- * embed an `isEmbedStartUrl` substring (e.g. a longer message that includes
- * the URL) are replaced with `[hidden embed URL]`.
+ * Circular structures are replaced with a marker. Strings that embed an
+ * `isEmbedStartUrl` substring (e.g. a longer message that includes the URL)
+ * are replaced with `[hidden embed URL]`. Credential-like `ticket` fields are
+ * removed only inside an embed-signaled object/branch, so ordinary business
+ * fields from unrelated read actions remain faithful.
  */
-function purgeEmbedStartUrls(value: unknown, depth = 0): unknown {
-  if (depth > 5) return value;
+const EMBED_RESULT_SENSITIVE_KEYS = new Set([
+  "embedTargetPath",
+  "embedExpiresAt",
+  "embedTicket",
+]);
+
+function isEmbedCredentialKey(key: string): boolean {
+  return key === "ticket" || /Ticket$/.test(key);
+}
+
+function containsEmbedRoutingSignal(
+  value: unknown,
+  seen = new WeakSet<object>(),
+): boolean {
+  if (typeof value === "string") return isEmbedStartUrl(value);
+  if (!value || typeof value !== "object") return false;
+  if (seen.has(value)) return false;
+  seen.add(value);
+  if (Array.isArray(value)) {
+    const result = value.some((item) => containsEmbedRoutingSignal(item, seen));
+    seen.delete(value);
+    return result;
+  }
+  for (const [key, val] of Object.entries(value)) {
+    if (EMBED_RESULT_SENSITIVE_KEYS.has(key)) {
+      seen.delete(value);
+      return true;
+    }
+    if (containsEmbedRoutingSignal(val, seen)) {
+      seen.delete(value);
+      return true;
+    }
+  }
+  seen.delete(value);
+  return false;
+}
+
+function purgeEmbedStartUrls(
+  value: unknown,
+  seen = new WeakSet<object>(),
+  embedContext = false,
+): unknown {
   if (typeof value === "string") {
     return isEmbedStartUrl(value) ? "[hidden embed URL]" : value;
   }
   if (Array.isArray(value)) {
-    return value.map((item) => purgeEmbedStartUrls(item, depth + 1));
+    if (seen.has(value)) return "[circular result]";
+    seen.add(value);
+    const out = value.map((item) =>
+      purgeEmbedStartUrls(
+        item,
+        seen,
+        embedContext || containsEmbedRoutingSignal(item),
+      ),
+    );
+    seen.delete(value);
+    return out;
   }
   if (value && typeof value === "object") {
+    if (seen.has(value)) return "[circular result]";
+    seen.add(value);
+    const entries = Object.entries(value as Record<string, unknown>);
+    const localEmbedContext = embedContext || containsEmbedRoutingSignal(value);
     const out: Record<string, unknown> = {};
-    for (const [key, val] of Object.entries(value as Record<string, unknown>)) {
+    for (const [key, val] of entries) {
+      if (
+        EMBED_RESULT_SENSITIVE_KEYS.has(key) ||
+        (localEmbedContext && isEmbedCredentialKey(key))
+      ) {
+        continue;
+      }
       if (typeof val === "string" && isEmbedStartUrl(val)) {
         // Drop the key entirely for object-typed inputs so a tool result like
         // `{ embedStartUrl: "..." }` does not appear at all in the LLM text.
         continue;
       }
-      out[key] = purgeEmbedStartUrls(val, depth + 1);
+      out[key] = purgeEmbedStartUrls(val, seen, localEmbedContext);
     }
+    seen.delete(value);
     return out;
   }
   return value;
@@ -1195,11 +1258,12 @@ function mcpAppStructuredContent(
   result: unknown,
   meta: Record<string, unknown> | undefined,
 ): Record<string, unknown> {
+  const purged = purgeEmbedStartUrls(result);
   const out: Record<string, unknown> =
-    result && typeof result === "object" && !Array.isArray(result)
-      ? { ...(result as Record<string, unknown>) }
-      : primitiveValue(result)
-        ? { result }
+    purged && typeof purged === "object" && !Array.isArray(purged)
+      ? { ...(purged as Record<string, unknown>) }
+      : primitiveValue(purged)
+        ? { result: purged }
         : {};
   for (const key of ["embedStartUrl", "startUrl"]) {
     const value = out[key];
@@ -1213,17 +1277,6 @@ function mcpAppStructuredContent(
   // LLM). `embedTargetPath` reveals the exact route + thread/draft id the user
   // is looking at; `embedExpiresAt` is an unintended timestamp; ticket-bearing
   // fields are single-use credentials. Drop all of them unconditionally.
-  for (const key of [
-    "embedTargetPath",
-    "embedExpiresAt",
-    "ticket",
-    "embedTicket",
-  ]) {
-    delete out[key];
-  }
-  for (const key of Object.keys(out)) {
-    if (/Ticket$/.test(key)) delete out[key];
-  }
   const openLink = meta?.["agent-native/openLink"];
   if (openLink && typeof openLink === "object" && !Array.isArray(openLink)) {
     const webUrl = (openLink as Record<string, unknown>).webUrl;
@@ -1275,12 +1328,25 @@ function isSuccessOnlyResult(value: Record<string, unknown>): boolean {
   });
 }
 
-function conciseToolResultText(name: string, result: unknown): string {
+function conciseToolResultText(
+  name: string,
+  result: unknown,
+  options?: { preserveObjectResult?: boolean },
+): string {
   const purged = purgeEmbedStartUrls(result);
   if (typeof purged === "string") return truncateToolText(purged);
   if (purged === true || purged == null) return `${name} completed.`;
   if (purged && typeof purged === "object" && !Array.isArray(purged)) {
     const record = purged as Record<string, unknown>;
+    // Read-only actions are data reads, not mutations. Keep their object
+    // payload available to MCP clients in the text fallback too; the
+    // structuredContent branch below is the lossless path for clients that
+    // support it. Mutating/action-style results retain the concise status
+    // text so we do not unexpectedly dump write results into conversations.
+    if (options?.preserveObjectResult) {
+      const text = JSON.stringify(purged);
+      return text === undefined ? `${name} completed.` : truncateToolText(text);
+    }
     const message = record.message ?? record.summary;
     if (typeof message === "string" && message.trim()) {
       return truncateToolText(message.trim());
@@ -1711,10 +1777,17 @@ export async function createMCPServerForRequest(
               typeof rawResult === "object" &&
               !Array.isArray(rawResult)
             ? (rawResult as Record<string, unknown>)
-            : undefined;
+            : entry.readOnly === true &&
+                rawResult &&
+                typeof rawResult === "object" &&
+                !Array.isArray(rawResult)
+              ? mcpAppStructuredContent(rawResultForClient, responseMeta)
+              : undefined;
         const text = mcpAppResource
           ? conciseMcpAppToolText(name, resultForClient, structuredContent!)
-          : conciseToolResultText(name, resultForClient);
+          : conciseToolResultText(name, resultForClient, {
+              preserveObjectResult: entry.readOnly === true,
+            });
         const content: any[] = [{ type: "text", text }];
         if (block) content.push(block);
         return {

package/corpus/templates/calendar/.agents/skills/event-management/SKILL.md

@@ -128,12 +128,26 @@ pnpm action create-event \
 # Working location
 pnpm action create-event \
   --title "Working from home" \
-  --start 2026-04-03T09:00:00 \
-  --end 2026-04-03T17:00:00 \
+  --start 2026-04-03 \
+  --end 2026-04-04 \
+  --allDay true \
   --eventType workingLocation \
   --workingLocationType homeOffice
 ```
 
+Working-location events sync from Google with `workingLocationProperties` and
+render as native working locations in the UI instead of generic all-day events.
+They are transparent/non-blocking for availability. Google allows timed working
+locations or single-day all-day working locations; multi-day all-day ranges must
+be represented as separate daily working-location events.
+
+For a visible occurrence in a recurring working-location series, default to
+`scope: "single"` and pass the occurrence's event `id`, not its
+`recurringEventId`. Use `scope: "all"` only when the user explicitly asks to
+change every day in the series. Keep office building/floor/desk metadata when
+editing an office label, and clear incompatible location labels when changing
+between Home, Office, and Other.
+
 Do not use `eventType` for Tasks or appointment schedules. Google Calendar
 Tasks are a separate product/API surface, and appointment schedules should use
 booking links or availability workflows instead.
@@ -225,6 +239,12 @@ pnpm action update-event --id google-event-id --attendees "alice@example.com" --
 pnpm action update-event --id google-event-id --addGoogleMeet=true
 pnpm action update-event --id google-event-id --addZoom=true
 
+# Update an existing working-location event's native metadata
+pnpm action update-event \
+  --id google-working-location-id \
+  --workingLocationType officeLocation \
+  --workingLocationLabel "Pier 57"
+
 # Add multiple alerts, a Google event color, and an attachment
 pnpm action update-event \
   --id google-event-id \
@@ -237,6 +257,15 @@ pnpm action update-event \
 
 For "add Zoom to this meeting", fetch or use the visible event id and call `update-event --addZoom=true`. Do not create an extension for Zoom; Zoom is a first-party calendar integration handled by the event actions and the Settings page.
 
+Google Calendar does not allow changing an existing event's `eventType`; use
+`workingLocationType` and `workingLocationLabel` only on events that already
+have `eventType: "workingLocation"`.
+
+Google Calendar API v3 currently documents working locations on Events, but the
+Settings API/discovery document does not expose working-hours settings. Treat
+working-hours overlays or Find a Time constraints as a follow-up only after a
+real provider data path exists.
+
 For recurring events, pass a Google Calendar RRULE in `--recurrence`. Example: to make a daily event weekdays only, use:
 
 ```bash

package/corpus/templates/calendar/AGENTS.md

@@ -37,6 +37,17 @@ Detailed event, availability, booking, storage, and UI rules live in
   with `stageAs` and analyze them with `query-staged-dataset`.
 - For Google Calendar, distinguish an empty calendar from missing auth,
   reauth-needed, or fetch failures.
+- Google Calendar working locations are status events (`eventType:
+"workingLocation"`). Sync and display them as working locations, keep them
+  transparent/non-blocking, and preserve `workingLocationProperties` instead of
+  treating the summary as a generic all-day event title.
+- When updating one visible occurrence in a recurring working-location series,
+  pass that occurrence's event `id` with `scope: "single"` by default. Use the
+  series scope only when the user explicitly chooses all days.
+- Google Calendar API v3 exposes working locations through Events. The current
+  Settings API and Calendar v3 discovery document do not expose working-hours
+  settings, so do not promise working-hours UI or overlays unless a real
+  provider data path has been verified first.
 - Use framework sharing actions for calendars/events/booking resources when
   applicable.
 - Booking-link sharing controls who can manage the link. Public booking access

package/corpus/templates/calendar/README.md

@@ -13,7 +13,8 @@ the agent can do through the same actions.
 ## Features
 
 - Day, week, and month views with multiple Google accounts overlayed.
-- Google Calendar sync and read-only ICS feed subscriptions.
+- Google Calendar sync, native working locations, and read-only ICS feed
+  subscriptions.
 - Weekly availability with timezone support for slot-finding.
 - Calendly-style public booking links at `/book/{slug}` with custom fields.
 - Ask the agent anything schedule-related, from "am I free Thursday?" to

package/corpus/templates/calendar/actions/create-event.ts

@@ -24,6 +24,7 @@ import {
   reminderMethodInput,
   reminderMinutesInput,
   remindersInput,
+  validateStatusEventTiming,
   visibilityInput,
   workingLocationTypeInput,
 } from "./event-action-helpers.js";
@@ -116,12 +117,12 @@ export default defineAction({
     if (args.addGoogleMeet && args.addZoom) {
       throw new Error("Choose either Google Meet or Zoom, not both.");
     }
-    if (
-      (args.eventType === "outOfOffice" || args.eventType === "focusTime") &&
-      args.allDay === true
-    ) {
-      throw new Error("Out of office and focus time events must be timed.");
-    }
+    validateStatusEventTiming({
+      eventType: args.eventType,
+      allDay: args.allDay,
+      start: args.start,
+      end: args.end,
+    });
 
     if (!(await googleCalendar.isConnected(email))) {
       throw new Error(