@agent-native/core 0.92.12 → 0.93.0

package/corpus/core/src/client/integrations/api.ts

@@ -0,0 +1,295 @@
+import { agentNativePath } from "../api-path.js";
+
+export interface IntegrationEnvStatus {
+  key: string;
+  label: string;
+  required: boolean;
+  configured: boolean;
+  helpText?: string;
+}
+
+export interface ClientIntegrationStatus {
+  platform: string;
+  label: string;
+  enabled: boolean;
+  configured: boolean;
+  details?: Record<string, unknown>;
+  error?: string;
+  webhookUrl?: string;
+  requiredEnvKeys?: IntegrationEnvStatus[];
+}
+
+export interface SavedEnvVarsResult {
+  saved: string[];
+  storage?: string;
+}
+
+export interface ClientIntegrationInstallation {
+  id: string;
+  platform: string;
+  installationKey: string;
+  teamId: string | null;
+  teamName: string | null;
+  enterpriseId: string | null;
+  enterpriseName: string | null;
+  scopes: string[];
+  ownerEmail: string;
+  orgId: string | null;
+  status: "connected" | "disconnected" | "revoked" | "error";
+  health: "unknown" | "healthy" | "degraded" | "revoked";
+  lastError: string | null;
+  healthCheckedAt: number | null;
+  tokenExpiresAt: number | null;
+  updatedAt: number;
+}
+
+export interface ClientIntegrationScope {
+  id: string;
+  platform: string;
+  tenantId: string;
+  conversationId: string;
+  conversationType: "channel" | "direct_message" | "group_direct_message";
+  trust: "trusted" | "guest" | "external_shared" | "unknown";
+  orgId: string | null;
+  serviceOwnerEmail: string;
+  defaultModel: string | null;
+  policy: {
+    requireMention: boolean;
+    allowDirectMessages: boolean;
+    allowGuests: boolean;
+    allowExternalShared: boolean;
+    allowUnknownTrust: boolean;
+  };
+  updatedAt: number;
+}
+
+export interface ClientIntegrationUsageBudget {
+  id: string;
+  subjectType: "org" | "user" | "scope";
+  subjectId: string;
+  period: "day" | "month";
+  limitMicros: number;
+  thresholdBps: number;
+  updatedAt: number;
+}
+
+export interface ClientIntegrationMemory {
+  name: string;
+  path: string;
+  updatedAt: number;
+  size: number;
+}
+
+export class IntegrationClientError extends Error {
+  constructor(
+    message: string,
+    readonly status: number,
+  ) {
+    super(message);
+    this.name = "IntegrationClientError";
+  }
+}
+
+async function readResponse<T>(response: Response): Promise<T> {
+  let payload: unknown;
+  try {
+    payload = await response.json();
+  } catch {
+    if (response.ok) {
+      throw new IntegrationClientError(
+        "Integration response was not valid JSON.",
+        response.status,
+      );
+    }
+    payload = null;
+  }
+  if (response.ok) return payload as T;
+
+  const error =
+    payload &&
+    typeof payload === "object" &&
+    typeof (payload as { error?: unknown }).error === "string"
+      ? (payload as { error: string }).error
+      : response.statusText || `Request failed (HTTP ${response.status})`;
+  throw new IntegrationClientError(error, response.status);
+}
+
+async function integrationRequest<T>(
+  path: string,
+  init?: RequestInit,
+): Promise<T> {
+  return readResponse<T>(await fetch(agentNativePath(path), init));
+}
+
+export async function listIntegrationStatuses(): Promise<
+  ClientIntegrationStatus[]
+> {
+  const result = await integrationRequest<unknown>(
+    "/_agent-native/integrations/status",
+  );
+  return Array.isArray(result) ? (result as ClientIntegrationStatus[]) : [];
+}
+
+export async function setIntegrationEnabled(
+  platform: string,
+  enabled: boolean,
+): Promise<unknown> {
+  return integrationRequest(
+    `/_agent-native/integrations/${encodeURIComponent(platform)}/${enabled ? "enable" : "disable"}`,
+    { method: "POST" },
+  );
+}
+
+export async function setupIntegration(platform: string): Promise<unknown> {
+  return integrationRequest(
+    `/_agent-native/integrations/${encodeURIComponent(platform)}/setup`,
+    { method: "POST" },
+  );
+}
+
+export function managedIntegrationOAuthUrl(
+  platform: string,
+  returnPath = "/messaging",
+): string {
+  const query = new URLSearchParams({ return: returnPath });
+  return agentNativePath(
+    `/_agent-native/integrations/${encodeURIComponent(platform)}/oauth/install?${query}`,
+  );
+}
+
+export function managedSlackAgentManifestUrl(): string {
+  return agentNativePath("/_agent-native/integrations/slack/manifest");
+}
+
+export async function listManagedIntegrationInstallations(
+  platform?: string,
+): Promise<ClientIntegrationInstallation[]> {
+  const query = platform
+    ? `?${new URLSearchParams({ platform }).toString()}`
+    : "";
+  const result = await integrationRequest<{
+    installations?: ClientIntegrationInstallation[];
+  }>(`/_agent-native/integrations/installations${query}`);
+  return Array.isArray(result.installations) ? result.installations : [];
+}
+
+export async function testManagedIntegrationInstallation(
+  id: string,
+): Promise<ClientIntegrationInstallation | null> {
+  const result = await integrationRequest<{
+    installation?: ClientIntegrationInstallation | null;
+  }>("/_agent-native/integrations/installations", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ id, action: "test" }),
+  });
+  return result.installation ?? null;
+}
+
+export async function disconnectManagedIntegrationInstallation(
+  id: string,
+): Promise<ClientIntegrationInstallation | null> {
+  const result = await integrationRequest<{
+    installation?: ClientIntegrationInstallation | null;
+  }>("/_agent-native/integrations/installations", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ id, action: "disconnect" }),
+  });
+  return result.installation ?? null;
+}
+
+export async function listManagedIntegrationScopes(
+  platform?: string,
+): Promise<ClientIntegrationScope[]> {
+  const query = platform
+    ? `?${new URLSearchParams({ platform }).toString()}`
+    : "";
+  const result = await integrationRequest<{
+    scopes?: ClientIntegrationScope[];
+  }>(`/_agent-native/integrations/scopes${query}`);
+  return Array.isArray(result.scopes) ? result.scopes : [];
+}
+
+export async function saveManagedIntegrationScope(
+  scope: Omit<ClientIntegrationScope, "id" | "updatedAt">,
+): Promise<ClientIntegrationScope> {
+  const result = await integrationRequest<{ scope: ClientIntegrationScope }>(
+    "/_agent-native/integrations/scopes",
+    {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(scope),
+    },
+  );
+  return result.scope;
+}
+
+export async function listManagedIntegrationBudgets(): Promise<
+  ClientIntegrationUsageBudget[]
+> {
+  const result = await integrationRequest<{
+    budgets?: ClientIntegrationUsageBudget[];
+  }>("/_agent-native/integrations/budgets");
+  return Array.isArray(result.budgets) ? result.budgets : [];
+}
+
+export async function saveManagedIntegrationBudget(input: {
+  subject:
+    | { type: "org"; orgId: string }
+    | { type: "user"; userEmail: string }
+    | {
+        type: "scope";
+        scope: { platform: string; tenantId: string; conversationId: string };
+      };
+  period: "day" | "month";
+  limitMicros: number;
+  thresholdBps?: number;
+}): Promise<ClientIntegrationUsageBudget> {
+  const result = await integrationRequest<{
+    budget: ClientIntegrationUsageBudget;
+  }>("/_agent-native/integrations/budgets", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(input),
+  });
+  return result.budget;
+}
+
+export async function listManagedIntegrationMemory(
+  scopeId: string,
+): Promise<ClientIntegrationMemory[]> {
+  const query = new URLSearchParams({ scopeId });
+  const result = await integrationRequest<{
+    memories?: ClientIntegrationMemory[];
+  }>(`/_agent-native/integrations/memory?${query}`);
+  return Array.isArray(result.memories) ? result.memories : [];
+}
+
+export async function forgetManagedIntegrationMemory(
+  scopeId: string,
+  name: string,
+): Promise<void> {
+  await integrationRequest("/_agent-native/integrations/memory", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ action: "forget", scopeId, name }),
+  });
+}
+
+export async function listIntegrationEnvStatuses(): Promise<
+  IntegrationEnvStatus[]
+> {
+  const result = await integrationRequest<unknown>("/_agent-native/env-status");
+  return Array.isArray(result) ? (result as IntegrationEnvStatus[]) : [];
+}
+
+export async function saveIntegrationEnvVars(
+  vars: Array<{ key: string; value: string }>,
+): Promise<SavedEnvVarsResult> {
+  return integrationRequest<SavedEnvVarsResult>("/_agent-native/env-vars", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ vars }),
+  });
+}

package/corpus/core/src/client/integrations/index.ts

@@ -1,3 +1,29 @@
 export { IntegrationsPanel } from "./IntegrationsPanel.js";
 export { useIntegrationStatus } from "./useIntegrationStatus.js";
 export type { IntegrationStatus } from "./useIntegrationStatus.js";
+export {
+  listIntegrationEnvStatuses,
+  listIntegrationStatuses,
+  saveIntegrationEnvVars,
+  setIntegrationEnabled,
+  setupIntegration,
+  disconnectManagedIntegrationInstallation,
+  listManagedIntegrationInstallations,
+  managedIntegrationOAuthUrl,
+  managedSlackAgentManifestUrl,
+  listManagedIntegrationScopes,
+  saveManagedIntegrationScope,
+  listManagedIntegrationBudgets,
+  listManagedIntegrationMemory,
+  forgetManagedIntegrationMemory,
+  saveManagedIntegrationBudget,
+  testManagedIntegrationInstallation,
+  IntegrationClientError,
+  type ClientIntegrationInstallation,
+  type ClientIntegrationScope,
+  type ClientIntegrationUsageBudget,
+  type ClientIntegrationMemory,
+  type ClientIntegrationStatus,
+  type IntegrationEnvStatus,
+  type SavedEnvVarsResult,
+} from "./api.js";

package/corpus/core/src/client/transcription/use-live-transcription.ts

@@ -13,6 +13,9 @@
 
 import { useCallback, useEffect, useRef, useState } from "react";
 
+const NETWORK_RESTART_BASE_MS = 1_000;
+const NETWORK_RESTART_MAX_MS = 30_000;
+
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 function getSpeechRecognitionCtor(): any {
   if (typeof window === "undefined") return null;
@@ -57,6 +60,9 @@ export function useLiveTranscription(
   const transcriptRef = useRef("");
   const stoppedManuallyRef = useRef(false);
   const stopWaiterRef = useRef<((text: string) => void) | null>(null);
+  const restartTimerRef = useRef<number | null>(null);
+  const networkErrorCountRef = useRef(0);
+  const restartDelayRef = useRef(0);
 
   const supported = !!getSpeechRecognitionCtor();
 
@@ -65,6 +71,10 @@ export function useLiveTranscription(
     if (!Ctor) return;
 
     // Clean up any prior session.
+    if (restartTimerRef.current !== null) {
+      window.clearTimeout(restartTimerRef.current);
+      restartTimerRef.current = null;
+    }
     if (recognitionRef.current) {
       try {
         recognitionRef.current.abort();
@@ -80,6 +90,8 @@ export function useLiveTranscription(
     recognitionRef.current = recognition;
     transcriptRef.current = "";
     stoppedManuallyRef.current = false;
+    networkErrorCountRef.current = 0;
+    restartDelayRef.current = 0;
     setTranscript("");
     setInterimText("");
 
@@ -96,21 +108,60 @@ export function useLiveTranscription(
         }
       }
       setInterimText(interim);
+      if (event.results.length > 0) {
+        networkErrorCountRef.current = 0;
+        restartDelayRef.current = 0;
+      }
     };
 
     recognition.onerror = (event: any) => {
       if (event.error === "no-speech" || event.error === "aborted") return;
+      if (
+        event.error === "not-allowed" ||
+        event.error === "service-not-allowed" ||
+        event.error === "audio-capture"
+      ) {
+        stoppedManuallyRef.current = true;
+        setIsActive(false);
+        return;
+      }
+      if (event.error === "network") {
+        const retryIndex = networkErrorCountRef.current++;
+        restartDelayRef.current = Math.min(
+          NETWORK_RESTART_BASE_MS * 2 ** retryIndex,
+          NETWORK_RESTART_MAX_MS,
+        );
+      }
       console.warn("[live-transcription] error:", event.error);
     };
 
     recognition.onend = () => {
       // Web Speech sometimes stops on its own (silence timeout, network
       // hiccup). Restart automatically unless we stopped intentionally.
-      if (!stoppedManuallyRef.current && recognitionRef.current) {
-        try {
-          recognition.start();
-        } catch {
-          setIsActive(false);
+      if (
+        !stoppedManuallyRef.current &&
+        recognitionRef.current === recognition
+      ) {
+        const restart = () => {
+          restartTimerRef.current = null;
+          if (
+            stoppedManuallyRef.current ||
+            recognitionRef.current !== recognition
+          ) {
+            return;
+          }
+          try {
+            recognition.start();
+          } catch {
+            setIsActive(false);
+          }
+        };
+        const delayMs = restartDelayRef.current;
+        restartDelayRef.current = 0;
+        if (delayMs > 0) {
+          restartTimerRef.current = window.setTimeout(restart, delayMs);
+        } else {
+          restart();
         }
         return;
       }
@@ -130,6 +181,10 @@ export function useLiveTranscription(
 
   const stop = useCallback((): string => {
     stoppedManuallyRef.current = true;
+    if (restartTimerRef.current !== null) {
+      window.clearTimeout(restartTimerRef.current);
+      restartTimerRef.current = null;
+    }
     setInterimText("");
     if (recognitionRef.current) {
       try {
@@ -145,6 +200,10 @@ export function useLiveTranscription(
 
   const stopAndWait = useCallback((timeoutMs = 1200): Promise<string> => {
     stoppedManuallyRef.current = true;
+    if (restartTimerRef.current !== null) {
+      window.clearTimeout(restartTimerRef.current);
+      restartTimerRef.current = null;
+    }
     setInterimText("");
 
     const recognition = recognitionRef.current;
@@ -185,6 +244,10 @@ export function useLiveTranscription(
   const pause = useCallback(() => {
     if (!recognitionRef.current) return;
     stoppedManuallyRef.current = true;
+    if (restartTimerRef.current !== null) {
+      window.clearTimeout(restartTimerRef.current);
+      restartTimerRef.current = null;
+    }
     try {
       recognitionRef.current.stop();
     } catch {

package/corpus/core/src/client/use-run-stuck-detection.ts

@@ -28,6 +28,13 @@ export interface RunStuckState {
   heartbeatSinceMs: number | null;
   /** How the run was dispatched/continued, e.g. foreground-self-chain or background-processing. */
   dispatchMode: string | null;
+  /**
+   * Server-authoritative: true when the run holds an open tool call or A2A
+   * `agent_call` delegation (`in_flight_since` marker set). Preferred over the
+   * client-side proxy for deciding whether Retry (which aborts the run) is
+   * safe to offer. Null when the server bundle predates this field.
+   */
+  hasInFlightWork: boolean | null;
 }
 
 export interface UseRunStuckDetectionOptions {
@@ -55,6 +62,13 @@ export interface UseRunStuckDetectionOptions {
    * from the same poll response that computes the elapsed time.
    */
   backgroundStuckThresholdMs?: number;
+  /**
+   * Threshold for a claimed durable background worker that is still sending
+   * fresh process heartbeats. These workers can legitimately spend up to the
+   * 12-minute tool/no-progress window on large Design, Plan, or Assets work.
+   * Default 13 minutes, matching the durable chunk handoff boundary.
+   */
+  liveBackgroundStuckThresholdMs?: number;
   /** Poll interval. Default 5_000ms. */
   pollIntervalMs?: number;
   /** API base path. Default `/_agent-native/agent-chat`. */
@@ -63,8 +77,10 @@ export interface UseRunStuckDetectionOptions {
 
 const DEFAULT_STUCK_THRESHOLD_MS = 90_000;
 export const DEFAULT_BACKGROUND_STUCK_THRESHOLD_MS = 180_000;
+export const DEFAULT_LIVE_BACKGROUND_STUCK_THRESHOLD_MS = 13 * 60_000;
 const DEFAULT_POLL_INTERVAL_MS = 5_000;
 const IDLE_BACKOFF_INTERVAL_MS = 15_000;
+const FRESH_BACKGROUND_HEARTBEAT_MS = 30_000;
 
 interface ActiveRunResponse {
   active: boolean;
@@ -75,6 +91,8 @@ interface ActiveRunResponse {
   dispatchMode?: string | null;
   /** Server clock at response time, used to compute elapsed server-relative. */
   serverNow?: number;
+  /** True when the run holds an open tool/A2A call (in_flight_since marker). */
+  hasInFlightWork?: boolean;
 }
 
 const EMPTY_STATE: RunStuckState = {
@@ -86,6 +104,7 @@ const EMPTY_STATE: RunStuckState = {
   heartbeatAt: null,
   heartbeatSinceMs: null,
   dispatchMode: null,
+  hasInFlightWork: null,
 };
 
 export function useRunStuckDetection({
@@ -93,6 +112,7 @@ export function useRunStuckDetection({
   enabled = true,
   stuckThresholdMs = DEFAULT_STUCK_THRESHOLD_MS,
   backgroundStuckThresholdMs = DEFAULT_BACKGROUND_STUCK_THRESHOLD_MS,
+  liveBackgroundStuckThresholdMs = DEFAULT_LIVE_BACKGROUND_STUCK_THRESHOLD_MS,
   pollIntervalMs = DEFAULT_POLL_INTERVAL_MS,
   apiUrl,
 }: UseRunStuckDetectionOptions): RunStuckState {
@@ -139,9 +159,22 @@ export function useRunStuckDetection({
           const serverContinued =
             dispatchMode === "foreground-self-chain" ||
             dispatchMode?.startsWith("background") === true;
-          const effectiveThresholdMs = serverContinued
-            ? backgroundStuckThresholdMs
-            : stuckThresholdMs;
+          // A claimed durable worker with a fresh heartbeat can legitimately
+          // be waiting on a bounded long-running tool/sub-agent call. Showing
+          // Retry at the generic 3-minute continuation threshold aborts healthy
+          // work and starts the same call again. Let the worker's own 12-minute
+          // watchdog act first; a dead/stale heartbeat still gets the earlier
+          // background fallback below.
+          const liveBackgroundWorker =
+            dispatchMode === "background-processing" &&
+            heartbeatSinceMs != null &&
+            heartbeatSinceMs >= 0 &&
+            heartbeatSinceMs < FRESH_BACKGROUND_HEARTBEAT_MS;
+          const effectiveThresholdMs = liveBackgroundWorker
+            ? liveBackgroundStuckThresholdMs
+            : serverContinued
+              ? backgroundStuckThresholdMs
+              : stuckThresholdMs;
           const isStuck = Boolean(
             data.active &&
             data.status === "running" &&
@@ -157,6 +190,10 @@ export function useRunStuckDetection({
             heartbeatAt,
             heartbeatSinceMs,
             dispatchMode,
+            hasInFlightWork:
+              typeof data.hasInFlightWork === "boolean"
+                ? data.hasInFlightWork
+                : null,
           });
           // Back off polling when nothing is in flight — there's no point
           // hammering the endpoint while the chat is idle. We still poll
@@ -187,6 +224,7 @@ export function useRunStuckDetection({
     enabled,
     stuckThresholdMs,
     backgroundStuckThresholdMs,
+    liveBackgroundStuckThresholdMs,
     pollIntervalMs,
     apiUrl,
   ]);

package/corpus/core/src/deploy/build.ts

@@ -22,6 +22,10 @@ import { fileURLToPath } from "url";
 
 import {
   AGENT_BACKGROUND_FUNCTION_NAME,
+  AGENT_BACKGROUND_PROCESSOR_A2A,
+  AGENT_BACKGROUND_PROCESSOR_FIELD,
+  AGENT_BACKGROUND_PROCESSOR_ROUTE,
+  AGENT_BACKGROUND_PROCESSOR_ROUTE_FIELD,
   AGENT_CHAT_PROCESS_RUN_PATH,
 } from "../agent/durable-background.js";
 import { normalizeAppBasePath } from "../server/app-base-path.js";
@@ -2344,6 +2348,17 @@ export function emitSingleTemplateNetlifyBackgroundFunction(
   fs.rmSync(path.join(dest, "server.mjs"), { force: true });
 
   const processRunPath = JSON.stringify(AGENT_CHAT_PROCESS_RUN_PATH);
+  const a2aProcessTaskPath = JSON.stringify("/_agent-native/a2a/_process-task");
+  const backgroundProcessorField = JSON.stringify(
+    AGENT_BACKGROUND_PROCESSOR_FIELD,
+  );
+  const backgroundProcessorA2A = JSON.stringify(AGENT_BACKGROUND_PROCESSOR_A2A);
+  const backgroundProcessorRoute = JSON.stringify(
+    AGENT_BACKGROUND_PROCESSOR_ROUTE,
+  );
+  const backgroundProcessorRouteField = JSON.stringify(
+    AGENT_BACKGROUND_PROCESSOR_ROUTE_FIELD,
+  );
   const entry = `// Mark this isolate as the durable background runtime BEFORE the handler
 // bundle is imported, so isInBackgroundFunctionRuntime() reliably returns true
 // in this function. The deployed Lambda name is NOT guaranteed to end in
@@ -2355,6 +2370,35 @@ globalThis.__AGENT_NATIVE_BACKGROUND_RUNTIME__ = true;
 
 // The framework route the Nitro router dispatches to (the _process-run plugin).
 const PROCESS_RUN_PATH = ${processRunPath};
+const A2A_PROCESS_TASK_PATH = ${a2aProcessTaskPath};
+const BACKGROUND_PROCESSOR_FIELD = ${backgroundProcessorField};
+const BACKGROUND_PROCESSOR_A2A = ${backgroundProcessorA2A};
+const BACKGROUND_PROCESSOR_ROUTE = ${backgroundProcessorRoute};
+const BACKGROUND_PROCESSOR_ROUTE_FIELD = ${backgroundProcessorRouteField};
+
+function processorPathFromBody(body) {
+  if (!body) return null;
+  try {
+    const parsed = JSON.parse(body);
+    if (parsed?.[BACKGROUND_PROCESSOR_FIELD] === BACKGROUND_PROCESSOR_A2A) {
+      return A2A_PROCESS_TASK_PATH;
+    }
+    const route = parsed?.[BACKGROUND_PROCESSOR_ROUTE_FIELD];
+    if (
+      parsed?.[BACKGROUND_PROCESSOR_FIELD] === BACKGROUND_PROCESSOR_ROUTE &&
+      typeof route === "string" &&
+      route.startsWith("/") &&
+      route.includes("/api/_agent-native-background/") &&
+      !route.includes("?") &&
+      !route.includes("#")
+    ) {
+      return route;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
 
 let cachedHandler;
 
@@ -2370,11 +2414,11 @@ export default async function handler(request, context) {
   try {
     cachedHandler ??= (await import("./main.mjs")).default;
     const url = new URL(request.url);
-    url.pathname = PROCESS_RUN_PATH;
     // Read the body once and pass it through. GET/HEAD have no body.
     const method = request.method || "POST";
     const hasBody = method !== "GET" && method !== "HEAD";
     const body = hasBody ? await request.text() : undefined;
+    url.pathname = processorPathFromBody(body) || PROCESS_RUN_PATH;
     const rewritten = new Request(url.toString(), {
       method,
       headers: request.headers,
@@ -2526,6 +2570,18 @@ export function assertSingleTemplateNetlifyBuildOutput(
 ): void {
   const failures: string[] = [];
   const publishDir = path.join(projectCwd, "dist");
+  const workspaceAppBasePath =
+    process.env.AGENT_NATIVE_WORKSPACE === "1" ||
+    process.env.VITE_AGENT_NATIVE_WORKSPACE === "1"
+      ? normalizeConfiguredAppBasePath()
+      : "";
+  const assetsRelativeDir = workspaceAppBasePath
+    ? path.join(workspaceAppBasePath.slice(1), "assets")
+    : "assets";
+  const assetsDisplayPath = path
+    .join("dist", assetsRelativeDir)
+    .split(path.sep)
+    .join("/");
   const redirectsPath = path.join(publishDir, "_redirects");
   const internalDir = path.join(projectCwd, ".netlify", "functions-internal");
   const serverDir = path.join(internalDir, "server");
@@ -2535,13 +2591,13 @@ export function assertSingleTemplateNetlifyBuildOutput(
   if (!fs.existsSync(publishDir)) {
     failures.push("missing publish directory: dist");
   } else {
-    const assetsDir = path.join(publishDir, "assets");
+    const assetsDir = path.join(publishDir, assetsRelativeDir);
     if (
       !fs.existsSync(assetsDir) ||
       fs.readdirSync(assetsDir).every((name) => name.startsWith("."))
     ) {
       failures.push(
-        "dist/assets is missing hashed client assets — the publish dir would load an infinite spinner",
+        `${assetsDisplayPath} is missing hashed client assets — the publish dir would load an infinite spinner`,
       );
     }
   }