@agent-native/core 0.84.16 → 0.84.18

package/corpus/templates/calendar/server/handlers/bookings.ts

@@ -163,6 +163,7 @@ type ConflictItem = { start: string; end: string };
 type ConflictResult = { items: ConflictItem[]; unavailableReason?: string };
 type BookingLinkRow = typeof schema.bookingLinks.$inferSelect;
 type ConflictDb = Pick<ReturnType<typeof getDb>, "select">;
+const BOOKING_SLOT_STEP_MINUTES = 30;
 
 type LocalDateTimeParts = {
   year: number;
@@ -341,6 +342,27 @@ function dateEndIso(date: string, timezone: string): string {
   ).toISOString();
 }
 
+function formatAvailabilityUnavailableReason(email?: string): string {
+  return email
+    ? `Calendar availability unavailable for ${email}`
+    : "Calendar availability unavailable";
+}
+
+function unavailableAvailabilityResponse(event: H3Event) {
+  setResponseStatus(event, 503);
+  return {
+    error:
+      "The host's calendar availability could not be checked. Please try again later.",
+    code: "calendar_availability_unavailable",
+  };
+}
+
+function formatLocalTime(totalMinutes: number): string {
+  const hour = Math.floor(totalMinutes / 60);
+  const minute = totalMinutes % 60;
+  return `${String(hour).padStart(2, "0")}:${String(minute).padStart(2, "0")}`;
+}
+
 async function resolveAvailabilityContext({
   slug,
   db = getDb(),
@@ -397,7 +419,7 @@ async function resolveAvailabilityContext({
   };
 }
 
-async function getConflictItems({
+export async function getConflictItems({
   db = getDb(),
   ownerEmail,
   hostEmails,
@@ -424,7 +446,18 @@ async function getConflictItems({
   );
   const freeBusyResolvedHosts = new Set<string>();
 
-  if (await googleCalendar.isConnected(ownerEmail)) {
+  const ownerConnected = ownerEmail
+    ? await googleCalendar.isConnected(ownerEmail)
+    : false;
+
+  if (ownerEmail && !ownerConnected) {
+    return {
+      items: [],
+      unavailableReason: formatAvailabilityUnavailableReason(ownerEmail),
+    };
+  }
+
+  if (ownerConnected) {
     try {
       if (requiredHosts.length > 0) {
         const freeBusy = await googleCalendar.getFreeBusy(
@@ -434,6 +467,14 @@ async function getConflictItems({
           ownerEmail,
           timezone,
         );
+        if (freeBusy.errors.length > 0) {
+          return {
+            items: [],
+            unavailableReason: formatAvailabilityUnavailableReason(
+              freeBusy.errors[0]?.email || ownerEmail,
+            ),
+          };
+        }
         for (const [email, calendar] of Object.entries(freeBusy.calendars)) {
           const normalizedEmail = email.toLowerCase();
           if (!calendar.errors || calendar.errors.length === 0) {
@@ -448,11 +489,16 @@ async function getConflictItems({
         }
       }
 
-      const { events: googleEvents } = await googleCalendar.listEvents(
-        rangeStartIso,
-        rangeEndIso,
-        ownerEmail,
-      );
+      const { events: googleEvents, errors: googleEventErrors } =
+        await googleCalendar.listEvents(rangeStartIso, rangeEndIso, ownerEmail);
+      if (googleEventErrors.length > 0) {
+        return {
+          items: [],
+          unavailableReason: formatAvailabilityUnavailableReason(
+            googleEventErrors[0]?.email || ownerEmail,
+          ),
+        };
+      }
       conflictItems.push(
         ...googleEvents.filter(eventBlocksAvailability).map((event) => ({
           start: event.start,
@@ -460,7 +506,10 @@ async function getConflictItems({
         })),
       );
     } catch {
-      // Continue without Google events if API fails
+      return {
+        items: [],
+        unavailableReason: formatAvailabilityUnavailableReason(ownerEmail),
+      };
     }
   }
 
@@ -501,7 +550,7 @@ async function getConflictItems({
   return { items: conflictItems };
 }
 
-function generateAvailableSlotsForDate({
+export function generateAvailableSlotsForDate({
   date,
   duration,
   config,
@@ -571,7 +620,17 @@ function generateAvailableSlotsForDate({
     const slotEnd = zonedTimeToUtc(date, scheduleSlot.end, timezone);
     if (slotEnd <= slotStart) continue;
 
-    let current = new Date(slotStart);
+    const scheduleStartMinutes = startHour * 60 + startMin;
+    const firstSlotStartMinutes =
+      Math.ceil(scheduleStartMinutes / BOOKING_SLOT_STEP_MINUTES) *
+      BOOKING_SLOT_STEP_MINUTES;
+    if (firstSlotStartMinutes >= 24 * 60) continue;
+
+    let current = zonedTimeToUtc(
+      date,
+      formatLocalTime(firstSlotStartMinutes),
+      timezone,
+    );
 
     while (current.getTime() + slotDuration * 60 * 1000 <= slotEnd.getTime()) {
       const candidateStart = new Date(current);
@@ -598,7 +657,9 @@ function generateAvailableSlotsForDate({
         });
       }
 
-      current = new Date(current.getTime() + slotDuration * 60 * 1000);
+      current = new Date(
+        current.getTime() + BOOKING_SLOT_STEP_MINUTES * 60 * 1000,
+      );
     }
   }
 
@@ -1147,7 +1208,9 @@ export const getAvailableSlots = defineEventHandler(async (event: H3Event) => {
         rangeEndIso: dateEndIso(rangeEnd, timezone),
         timezone,
       });
-      if (conflictResult.unavailableReason) return { dates: [] };
+      if (conflictResult.unavailableReason) {
+        return unavailableAvailabilityResponse(event);
+      }
       const dates: string[] = [];
       for (
         let cursor = new Date(from!);
@@ -1177,7 +1240,9 @@ export const getAvailableSlots = defineEventHandler(async (event: H3Event) => {
       rangeEndIso: dateEndIso(date, timezone),
       timezone,
     });
-    if (conflictResult.unavailableReason) return { slots: [] };
+    if (conflictResult.unavailableReason) {
+      return unavailableAvailabilityResponse(event);
+    }
     const availableSlots = generateAvailableSlotsForDate({
       date,
       duration,

package/corpus/templates/calendar/server/handlers/google-auth.ts

@@ -5,6 +5,7 @@ import {
   isElectron,
   getAppUrl,
   resolveGoogleSignInCredentials,
+  resolveGoogleProviderCredentials,
   resolveOAuthRedirectUri,
   encodeOAuthState,
   decodeOAuthState,
@@ -74,8 +75,8 @@ async function resolveCalendarOAuthCredentials(event: H3Event) {
       clientSecret: await resolveSecret("GOOGLE_CLIENT_SECRET"),
     }),
   );
-  if (!clientId || !clientSecret) return null;
-  return { clientId, clientSecret };
+  if (clientId && clientSecret) return { clientId, clientSecret };
+  return resolveGoogleProviderCredentials();
 }
 
 function isCalendarConnectRequest(

package/corpus/templates/calendar/server/lib/google-calendar.ts

@@ -10,6 +10,8 @@ import {
   getRequestOrgId,
   resolveSecret,
   runWithRequestContext,
+  resolveGoogleProviderCredentials,
+  resolveGoogleLegacyProviderCredentials,
 } from "@agent-native/core/server";
 
 import type {
@@ -95,8 +97,20 @@ async function readCredentialPair(
     resolveSecret(clientIdKey),
     resolveSecret(clientSecretKey),
   ]);
-  if (!clientId || !clientSecret) return null;
-  return { clientId, clientSecret };
+  if (clientId && clientSecret) return { clientId, clientSecret };
+  if (
+    clientIdKey === "GOOGLE_CLIENT_ID" &&
+    clientSecretKey === "GOOGLE_CLIENT_SECRET"
+  ) {
+    return resolveGoogleProviderCredentials();
+  }
+  if (
+    clientIdKey === "GOOGLE_LEGACY_CLIENT_ID" &&
+    clientSecretKey === "GOOGLE_LEGACY_CLIENT_SECRET"
+  ) {
+    return resolveGoogleLegacyProviderCredentials();
+  }
+  return null;
 }
 
 async function resolveGoogleProviderCredentialCandidates(

package/corpus/templates/design/app/lib/design-system-preview.ts

@@ -0,0 +1,69 @@
+const DEFAULT_OBJECT_ENTRY_LIMIT = 8;
+
+export function formatDesignTokenValue(value: unknown): string | undefined {
+  return formatTokenValue(value, new Set());
+}
+
+export function getCssColorToken(value: unknown): string | undefined {
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    return trimmed || undefined;
+  }
+
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return undefined;
+  }
+
+  for (const nested of Object.values(value)) {
+    const candidate = getCssColorToken(nested);
+    if (candidate) return candidate;
+  }
+
+  return undefined;
+}
+
+function formatTokenValue(
+  value: unknown,
+  seenObjects: Set<object>,
+): string | undefined {
+  if (value === null || value === undefined) return undefined;
+
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    return trimmed || undefined;
+  }
+
+  if (typeof value === "number" || typeof value === "boolean") {
+    return String(value);
+  }
+
+  if (Array.isArray(value)) {
+    const parts = value
+      .map((item) => formatTokenValue(item, seenObjects))
+      .filter((item): item is string => Boolean(item));
+    return parts.length > 0 ? parts.join(", ") : undefined;
+  }
+
+  if (typeof value !== "object") return undefined;
+
+  if (seenObjects.has(value)) return undefined;
+  seenObjects.add(value);
+
+  const entries = Object.entries(value)
+    .map(([key, nestedValue]) => {
+      const formatted = formatTokenValue(nestedValue, seenObjects);
+      return formatted ? `${labelizeDesignTokenKey(key)}: ${formatted}` : null;
+    })
+    .filter((entry): entry is string => Boolean(entry))
+    .slice(0, DEFAULT_OBJECT_ENTRY_LIMIT);
+
+  seenObjects.delete(value);
+  return entries.length > 0 ? entries.join(", ") : undefined;
+}
+
+function labelizeDesignTokenKey(key: string) {
+  return key
+    .replace(/([A-Z])/g, " $1")
+    .replace(/[-_]/g, " ")
+    .replace(/^./, (char) => char.toUpperCase());
+}

package/corpus/templates/design/app/pages/DesignSystems.tsx

@@ -65,6 +65,10 @@ import {
   TooltipContent,
   TooltipTrigger,
 } from "@/components/ui/tooltip";
+import {
+  formatDesignTokenValue,
+  getCssColorToken,
+} from "@/lib/design-system-preview";
 
 interface DesignSystem {
   id: string;
@@ -83,25 +87,25 @@ interface DesignSystem {
 
 interface DesignSystemData {
   colors?: {
-    primary?: string;
-    secondary?: string;
-    accent?: string;
-    background?: string;
-    surface?: string;
-    text?: string;
-    textMuted?: string;
+    primary?: unknown;
+    secondary?: unknown;
+    accent?: unknown;
+    background?: unknown;
+    surface?: unknown;
+    text?: unknown;
+    textMuted?: unknown;
   };
   typography?: {
-    headingFont?: string;
-    bodyFont?: string;
-    headingWeight?: string;
-    bodyWeight?: string;
+    headingFont?: unknown;
+    bodyFont?: unknown;
+    headingWeight?: unknown;
+    bodyWeight?: unknown;
   };
-  spacing?: Record<string, string | undefined>;
-  borders?: Record<string, string | undefined>;
+  spacing?: Record<string, unknown>;
+  borders?: Record<string, unknown>;
   logos?: Array<{ url?: string; name?: string; variant?: string }>;
-  defaults?: Record<string, string | undefined>;
-  notes?: string;
+  defaults?: Record<string, unknown>;
+  notes?: unknown;
 }
 
 export default function DesignSystems() {
@@ -474,6 +478,12 @@ export default function DesignSystems() {
                 {designSystems.map((ds) => {
                   const parsed = parseData(ds.data);
                   const colors = parsed?.colors;
+                  const primaryColor = getCssColorToken(colors?.primary);
+                  const secondaryColor = getCssColorToken(colors?.secondary);
+                  const accentColor = getCssColorToken(colors?.accent);
+                  const headingFont = formatDesignTokenValue(
+                    parsed?.typography?.headingFont,
+                  );
                   const isSelected = selectedSystemIds.has(ds.id);
                   return (
                     <div
@@ -498,29 +508,27 @@ export default function DesignSystems() {
                       >
                         {/* Color preview */}
                         <div className="aspect-video bg-muted/50 flex items-center justify-center gap-2 p-4">
-                          {colors?.primary && (
+                          {primaryColor && (
                             <div
                               className="w-10 h-10 rounded-lg"
-                              style={{ backgroundColor: colors.primary }}
+                              style={{ backgroundColor: primaryColor }}
                             />
                           )}
-                          {colors?.secondary && (
+                          {secondaryColor && (
                             <div
                               className="w-10 h-10 rounded-lg"
-                              style={{ backgroundColor: colors.secondary }}
+                              style={{ backgroundColor: secondaryColor }}
                             />
                           )}
-                          {colors?.accent && (
+                          {accentColor && (
                             <div
                               className="w-10 h-10 rounded-lg"
-                              style={{ backgroundColor: colors.accent }}
+                              style={{ backgroundColor: accentColor }}
                             />
                           )}
-                          {!colors?.primary &&
-                            !colors?.secondary &&
-                            !colors?.accent && (
-                              <IconPalette className="w-8 h-8 text-muted-foreground/40" />
-                            )}
+                          {!primaryColor && !secondaryColor && !accentColor && (
+                            <IconPalette className="w-8 h-8 text-muted-foreground/40" />
+                          )}
                         </div>
                         <div className="p-4 pb-3">
                           <div className="flex items-center gap-2 mb-1">
@@ -533,9 +541,9 @@ export default function DesignSystems() {
                               </span>
                             )}
                           </div>
-                          {parsed?.typography?.headingFont && (
+                          {headingFont && (
                             <div className="text-xs text-muted-foreground/70">
-                              {parsed.typography.headingFont}
+                              {headingFont}
                             </div>
                           )}
                         </div>
@@ -885,10 +893,12 @@ function TokenPreview({
                 key={color.label}
                 className="flex min-w-0 items-center gap-3 rounded-lg border border-border bg-muted/30 p-2"
               >
-                <div
-                  className="h-9 w-9 shrink-0 rounded-md border border-border"
-                  style={{ backgroundColor: color.value }}
-                />
+                {color.swatch ? (
+                  <div
+                    className="h-9 w-9 shrink-0 rounded-md border border-border"
+                    style={{ backgroundColor: color.swatch }}
+                  />
+                ) : null}
                 <div className="min-w-0">
                   <div className="text-xs font-medium text-foreground">
                     {color.label}
@@ -1001,34 +1011,47 @@ function getColorTokens(data: DesignSystemData | null, t: DesignT) {
   return [
     {
       label: t("designSystems.tokenPreview.colorLabels.primary"),
-      value: colors.primary,
+      value: formatDesignTokenValue(colors.primary),
+      swatch: getCssColorToken(colors.primary),
     },
     {
       label: t("designSystems.tokenPreview.colorLabels.secondary"),
-      value: colors.secondary,
+      value: formatDesignTokenValue(colors.secondary),
+      swatch: getCssColorToken(colors.secondary),
     },
     {
       label: t("designSystems.tokenPreview.colorLabels.accent"),
-      value: colors.accent,
+      value: formatDesignTokenValue(colors.accent),
+      swatch: getCssColorToken(colors.accent),
     },
     {
       label: t("designSystems.tokenPreview.colorLabels.background"),
-      value: colors.background,
+      value: formatDesignTokenValue(colors.background),
+      swatch: getCssColorToken(colors.background),
     },
     {
       label: t("designSystems.tokenPreview.colorLabels.surface"),
-      value: colors.surface,
+      value: formatDesignTokenValue(colors.surface),
+      swatch: getCssColorToken(colors.surface),
     },
     {
       label: t("designSystems.tokenPreview.colorLabels.text"),
-      value: colors.text,
+      value: formatDesignTokenValue(colors.text),
+      swatch: getCssColorToken(colors.text),
     },
     {
       label: t("designSystems.tokenPreview.colorLabels.mutedText"),
-      value: colors.textMuted,
+      value: formatDesignTokenValue(colors.textMuted),
+      swatch: getCssColorToken(colors.textMuted),
     },
-  ].filter((item): item is { label: string; value: string } =>
-    Boolean(item.value),
+  ].filter(
+    (
+      item,
+    ): item is {
+      label: string;
+      value: string;
+      swatch: string | undefined;
+    } => Boolean(item.value),
   );
 }
 
@@ -1038,19 +1061,19 @@ function getTypographyTokens(data: DesignSystemData | null, t: DesignT) {
   return [
     {
       label: t("designSystems.tokenPreview.typeLabels.headingFont"),
-      value: typography.headingFont,
+      value: formatDesignTokenValue(typography.headingFont),
     },
     {
       label: t("designSystems.tokenPreview.typeLabels.bodyFont"),
-      value: typography.bodyFont,
+      value: formatDesignTokenValue(typography.bodyFont),
     },
     {
       label: t("designSystems.tokenPreview.typeLabels.headingWeight"),
-      value: typography.headingWeight,
+      value: formatDesignTokenValue(typography.headingWeight),
     },
     {
       label: t("designSystems.tokenPreview.typeLabels.bodyWeight"),
-      value: typography.bodyWeight,
+      value: formatDesignTokenValue(typography.bodyWeight),
     },
   ].filter((item): item is { label: string; value: string } =>
     Boolean(item.value),
@@ -1089,12 +1112,10 @@ function getDetailTokens(
   ].filter((item): item is { label: string; value: string } => Boolean(item));
 }
 
-function objectPreviewItems(
-  prefix: string,
-  values: Record<string, string | undefined>,
-) {
+function objectPreviewItems(prefix: string, values: Record<string, unknown>) {
   return Object.entries(values)
-    .filter((entry): entry is [string, string] => Boolean(entry[1]))
+    .map(([key, value]) => [key, formatDesignTokenValue(value)] as const)
+    .filter((entry): entry is readonly [string, string] => Boolean(entry[1]))
     .slice(0, 4)
     .map(([key, value]) => ({
       label: `${prefix}: ${labelizeKey(key)}`,

package/corpus/templates/design/changelog/2026-07-01-design-systems-no-longer-crash-on-responsive-tokens.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-01
+---
+
+Design systems no longer crash when imported tokens include responsive values.

package/dist/client/session-replay.js

@@ -516,7 +516,7 @@ async function gzipReplayBody(body) {
             .stream()
             .pipeThrough(new CompressionStream("gzip"));
         const compressed = await new Response(stream).arrayBuffer();
-        return new Blob([compressed], { type: "application/json" });
+        return new Blob([compressed], { type: "application/octet-stream" });
     }
     catch {
         return null;
@@ -529,7 +529,7 @@ async function buildReplayUploadBody(body) {
             body: compressed,
             compressed: true,
             headers: {
-                "Content-Type": "application/json",
+                "Content-Type": "application/octet-stream",
                 "Content-Encoding": "gzip",
             },
         };