@opengeni/react 4.3.3-canary.39786771332001 → 4.5.0

package/src/app/routes/artifacts.tsx

@@ -1,7 +1,6 @@
 import { t } from "../lib/console-text";
 import { ArtifactSessionPage } from "../components/session/artifact-session-page";
 import type {
-  SiteViewer,
   ToolGatewayIdentity,
   WorkspaceArtifactContentResponse,
   WorkspaceArtifactDetailResponse,
@@ -12,7 +11,6 @@ import {
   artifactLoadErrorMessage,
   artifactLoadErrorView,
   type PublishedHtmlArtifactToolBridge,
-  type SiteToolBridgeFactory,
 } from "../../artifacts";
 import { loadSiteSnapshot } from "../../sites";
 import { SiteConversations } from "../components/artifacts/site-conversations";
@@ -62,6 +60,7 @@ import { useAppContext } from "../app-context";
 import { ARTIFACT_ACCESS_REQUIRED, isArtifactReadDenied } from "../lib/artifact-access";
 import { useAppApi } from "../lib/app-api";
 import { createSiteToolBridge } from "../lib/site-tool-bridge";
+import { useConsoleSiteToolBridge, useConsoleSiteViewer } from "../lib/console-site";
 import { readyNewChat } from "../lib/ready-new-chat";
 import { userErrorText } from "../../ui/api-error";
 import { newArtifactPrompt, siteEditPrompt } from "../lib/site-edit-prompt";
@@ -78,18 +77,6 @@ import type { ArtifactReturnSearch, SiteDetailTab } from "../lib/routes";
 
 const NO_SITE_TOOLS: readonly ToolGatewayIdentity[] = [];
 
-/** The signed-in member as Site code sees them (`site.viewer`) in the console. */
-function useConsoleSiteViewer(): SiteViewer {
-  const { accessContext, authSession } = useAppContext();
-  const subjectId = accessContext.subjectId;
-  const name = authSession?.user?.name ?? null;
-  const email = authSession?.user?.email ?? null;
-  return useMemo(
-    () => ({ kind: "member", id: `user:${subjectId}`, name, email, signedIn: true }),
-    [email, name, subjectId],
-  );
-}
-
 function formatSize(bytes: number): string {
   if (bytes < 1024) return `${bytes} B`;
   if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
@@ -420,22 +407,8 @@ function EmbeddedSiteDetail({
   controls?: EmbeddedSiteControls | undefined;
 }) {
   const { client } = useAppContext();
-  const api = useAppApi();
   const viewer = useConsoleSiteViewer();
-  const toolBridge = useCallback<SiteToolBridgeFactory>(
-    (site) => {
-      const scope = { workspaceTools: client.tools.forWorkspace(workspaceId), workspaceId };
-      return site
-        ? createSiteToolBridge(api, {
-            ...scope,
-            artifactId: site.artifactId,
-            siteVersionId: site.siteVersionId,
-            requestedTools: site.requestedTools,
-          })
-        : createSiteToolBridge(api, scope);
-    },
-    [api, client, workspaceId],
-  );
+  const toolBridge = useConsoleSiteToolBridge(workspaceId);
   return (
     <SiteView
       client={client}

package/src/app/routes/session-transient-failures.test.tsx

@@ -0,0 +1,343 @@
+/* ----------------------------------------------------------------------------
+   The session page during an API rolling deploy or a network blip: no
+   "Failed to load session" / "Event stream disconnected" toast and no failure
+   panel while transient failures are retried quietly; one toast and a
+   "Try again" panel only when the failure persists; recovery on its own.
+   Definitive errors stay exactly as visible as before.
+   -------------------------------------------------------------------------- */
+import { describe, expect, mock, test } from "bun:test";
+import { OpenGeniApiError, type AccessContext, type Session } from "@opengeni/sdk";
+import { act, type ReactNode } from "react";
+import * as SonnerPackage from "sonner";
+
+import { flush, registerDom, renderComponent } from "../../../test/render-hook";
+import { fakeClient, SESSION_ID, WORKSPACE_ID } from "../../../test/fake-client";
+import { DEFAULT_TRANSIENT_READ_RETRY } from "../../hooks/internal";
+import { useSession } from "../../hooks/use-session";
+import { useSessionEvents } from "../../hooks/use-session-events";
+import { AppContext, type AppContextValue } from "../app-context";
+import { AppHostProvider, type AppHost } from "../lib/app-host";
+import type { PageHost } from "../lib/navigation";
+
+const toastError = mock((_message: string, _data?: unknown) => undefined);
+mock.module("sonner", () => ({
+  ...SonnerPackage,
+  toast: Object.assign(
+    mock((_message: string) => undefined),
+    { ...SonnerPackage.toast, error: toastError },
+  ),
+}));
+
+const { useSessionFailureToasts } = await import("../lib/session-failure-toasts");
+const { SessionUnavailableRoute } = await import("./session-unavailable");
+const { default: SessionRouteAuxiliary } =
+  await import("../components/session/session-tenancy-control");
+
+registerDom({ clock: "virtual" });
+
+const session = {
+  id: SESSION_ID,
+  workspaceId: WORKSPACE_ID,
+  lastSequence: 0,
+  title: "Deploy-safe",
+  titleSource: "user",
+} as Session;
+
+const unavailable = () => new OpenGeniApiError(503, "", { mutation: false });
+
+function toastTitles(): string[] {
+  return toastError.mock.calls.map(([message]) => message);
+}
+
+/** The session page's read hooks plus its failure toasts. */
+function SessionPageReads(props: { client: ReturnType<typeof fakeClient> }) {
+  const events = useSessionEvents(SESSION_ID, { client: props.client, workspaceId: WORKSPACE_ID });
+  const detail = useSession(SESSION_ID, {
+    client: props.client,
+    workspaceId: WORKSPACE_ID,
+    events: events.events,
+  });
+  useSessionFailureToasts(detail.error, events.error);
+  return <p>{detail.session?.title ?? (detail.error ? "failed" : "loading")}</p>;
+}
+
+function RouteProviders(props: { host: AppHost; value: AppContextValue; children: ReactNode }) {
+  return (
+    <AppHostProvider host={props.host}>
+      <AppContext.Provider value={props.value}>{props.children}</AppContext.Provider>
+    </AppHostProvider>
+  );
+}
+
+function liveStream(): ReturnType<typeof fakeClient>["streamEvents"] {
+  return (_workspaceId, _sessionId, options = {}) =>
+    (async function* () {
+      options.onOpen?.();
+      await new Promise<void>((resolve) =>
+        options.signal?.addEventListener("abort", () => resolve(), { once: true }),
+      );
+      yield* [];
+    })();
+}
+
+describe("session page failure toasts", () => {
+  test("a transient outage that recovers raises no toast", async () => {
+    toastError.mockClear();
+    let failing = true;
+    const client = fakeClient({
+      getSession: async () => {
+        if (failing) throw new TypeError("Failed to fetch");
+        return session;
+      },
+      listEvents: async () => {
+        if (failing) throw unavailable();
+        return [];
+      },
+      streamEvents: liveStream(),
+    });
+    const rendered = await renderComponent(<SessionPageReads client={client} />);
+    try {
+      await flush(8_000);
+      expect(rendered.container.textContent).toBe("loading");
+      failing = false;
+      await flush(8_000);
+      expect(rendered.container.textContent).toBe("Deploy-safe");
+      expect(toastTitles()).toEqual([]);
+    } finally {
+      await rendered.unmount();
+    }
+  });
+
+  test("a persistent transient outage toasts each failure once, despite background retries", async () => {
+    toastError.mockClear();
+    const client = fakeClient({
+      getSession: async () => {
+        throw unavailable();
+      },
+      listEvents: async () => {
+        throw new TypeError("Failed to fetch");
+      },
+      streamEvents: liveStream(),
+    });
+    const rendered = await renderComponent(<SessionPageReads client={client} />);
+    try {
+      await flush(DEFAULT_TRANSIENT_READ_RETRY.quietWindowMs - 3_000);
+      expect(toastTitles()).toEqual([]);
+      await flush(DEFAULT_TRANSIENT_READ_RETRY.backgroundDelayMs * 4);
+      expect(toastTitles().sort()).toEqual(["Event stream disconnected", "Failed to load session"]);
+    } finally {
+      await rendered.unmount();
+    }
+  });
+
+  test("a definitive error toasts at once, and a 404 does not toast", async () => {
+    toastError.mockClear();
+    const forbidden = fakeClient({
+      getSession: async () => {
+        throw new OpenGeniApiError(403, "", { mutation: false });
+      },
+      listEvents: async () => [],
+      streamEvents: liveStream(),
+    });
+    const first = await renderComponent(<SessionPageReads client={forbidden} />);
+    await flush(10);
+    expect(toastTitles()).toEqual(["Failed to load session"]);
+    await first.unmount();
+
+    toastError.mockClear();
+    const missing = fakeClient({
+      getSession: async () => {
+        throw new OpenGeniApiError(404, "", { mutation: false });
+      },
+      listEvents: async () => [],
+      streamEvents: liveStream(),
+    });
+    const second = await renderComponent(<SessionPageReads client={missing} />);
+    await flush(10);
+    expect(toastTitles()).toEqual([]);
+    await second.unmount();
+  });
+});
+
+describe("session load failure panel", () => {
+  test("a persistent transient failure offers Try again instead of a dead end", async () => {
+    const onRetry = mock(() => undefined);
+    const rendered = await renderComponent(
+      <SessionRouteAuxiliary
+        workspaceId={WORKSPACE_ID}
+        sessionId={SESSION_ID}
+        loadError={unavailable()}
+        onRetry={onRetry}
+      />,
+    );
+    try {
+      expect(rendered.container.textContent).toContain("Temporarily unavailable");
+      expect(rendered.container.textContent).toContain("Retrying automatically.");
+      expect(rendered.container.textContent).not.toContain("Unable to open session");
+      const button = [...rendered.container.querySelectorAll("button")].find(
+        (candidate) => candidate.textContent === "Try again",
+      );
+      await act(async () => button?.click());
+      expect(onRetry).toHaveBeenCalledTimes(1);
+    } finally {
+      await rendered.unmount();
+    }
+  });
+
+  test("a definitive failure keeps the existing panel", async () => {
+    const rendered = await renderComponent(
+      <SessionRouteAuxiliary
+        workspaceId={WORKSPACE_ID}
+        sessionId={SESSION_ID}
+        loadError={new OpenGeniApiError(403, "", { mutation: false })}
+        onRetry={() => undefined}
+      />,
+    );
+    try {
+      expect(rendered.container.textContent).toContain("Unable to open session");
+      expect(rendered.container.querySelector("a")?.textContent).toBe("Back to sessions");
+      expect(rendered.container.textContent).not.toContain("Try again");
+    } finally {
+      await rendered.unmount();
+    }
+  });
+});
+
+describe("SessionUnavailableRoute", () => {
+  const otherWorkspaceId = "33333333-3333-4333-8333-333333333333";
+  const accessContext = {
+    subjectId: "subject-a",
+    defaultWorkspaceId: WORKSPACE_ID,
+    accountGrants: [],
+    workspaceGrants: [WORKSPACE_ID, otherWorkspaceId].map((workspaceId) => ({
+      workspaceId,
+      accountId: "account-a",
+      subjectId: "subject-a",
+      permissions: ["sessions:read"],
+    })),
+  } as unknown as AccessContext;
+  const workspaces = [
+    { id: WORKSPACE_ID, accountId: "account-a" },
+    { id: otherWorkspaceId, accountId: "account-a" },
+  ];
+
+  function renderRoute(getSession: () => Promise<Session>) {
+    const assigned: string[] = [];
+    const page = {
+      href: () => `https://app.example.test/workspaces/${WORKSPACE_ID}/sessions/${SESSION_ID}`,
+      origin: () => "https://app.example.test",
+      readQuery: () => new URLSearchParams(),
+      replaceQuery: () => undefined,
+      assign: (url: string) => void assigned.push(url),
+      opensBeside: false,
+    } as unknown as PageHost;
+    const value = {
+      accessContext,
+      workspaces,
+      client: { getSession },
+    } as unknown as AppContextValue;
+    const host = { navigation: { page } } as unknown as AppHost;
+    const tree = (node: ReactNode) => (
+      <RouteProviders host={host} value={value}>
+        {node}
+      </RouteProviders>
+    );
+    return { assigned, tree };
+  }
+
+  test("keeps looking through a transient failure, then shows Try again, then recovers", async () => {
+    let failing = true;
+    let reads = 0;
+    const route = renderRoute(async () => {
+      reads += 1;
+      if (failing) throw unavailable();
+      return session;
+    });
+    const rendered = await renderComponent(
+      route.tree(<SessionUnavailableRoute workspaceId={WORKSPACE_ID} sessionId={SESSION_ID} />),
+    );
+    try {
+      await flush(DEFAULT_TRANSIENT_READ_RETRY.quietWindowMs - 3_000);
+      expect(reads).toBeGreaterThan(2);
+      expect(rendered.container.textContent).toContain("Looking for this session");
+      expect(rendered.container.textContent).not.toContain("Session unavailable");
+
+      await flush(8_000);
+      expect(rendered.container.textContent).toContain("Temporarily unavailable");
+      const tryAgain = [...rendered.container.querySelectorAll("button")].find(
+        (candidate) => candidate.textContent === "Try again",
+      );
+      expect(tryAgain).toBeDefined();
+
+      failing = false;
+      await act(async () => tryAgain?.click());
+      await flush(10);
+      expect(route.assigned).toEqual([`/workspaces/${otherWorkspaceId}/sessions/${SESSION_ID}`]);
+    } finally {
+      await rendered.unmount();
+    }
+  });
+
+  test("a definitive server error keeps the existing Session unavailable panel", async () => {
+    let reads = 0;
+    const route = renderRoute(async () => {
+      reads += 1;
+      throw new OpenGeniApiError(500, "", { mutation: false });
+    });
+    const rendered = await renderComponent(
+      route.tree(<SessionUnavailableRoute workspaceId={WORKSPACE_ID} sessionId={SESSION_ID} />),
+    );
+    try {
+      await flush(10);
+      expect(rendered.container.textContent).toContain("Session unavailable");
+      await flush(60_000);
+      expect(reads).toBe(1);
+    } finally {
+      await rendered.unmount();
+    }
+  });
+
+  test("a hidden page defers its retries and looks again when it returns", async () => {
+    const originalVisibility = Object.getOwnPropertyDescriptor(document, "visibilityState");
+    let visibility: DocumentVisibilityState = "visible";
+    Object.defineProperty(document, "visibilityState", {
+      configurable: true,
+      get: () => visibility,
+    });
+    const setVisibility = async (next: DocumentVisibilityState) => {
+      visibility = next;
+      await act(async () => document.dispatchEvent(new Event("visibilitychange")));
+    };
+    let failing = true;
+    let reads = 0;
+    const route = renderRoute(async () => {
+      reads += 1;
+      if (failing) throw unavailable();
+      return session;
+    });
+    const rendered = await renderComponent(
+      route.tree(<SessionUnavailableRoute workspaceId={WORKSPACE_ID} sessionId={SESSION_ID} />),
+    );
+    try {
+      await flush(5_000);
+      await setVisibility("hidden");
+      await flush(10_000);
+      const hiddenReads = reads;
+      await flush(120_000);
+      expect(reads).toBe(hiddenReads);
+
+      failing = false;
+      await setVisibility("visible");
+      await flush(10);
+      expect(reads).toBe(hiddenReads + 1);
+      expect(route.assigned).toEqual([`/workspaces/${otherWorkspaceId}/sessions/${SESSION_ID}`]);
+    } finally {
+      await rendered.unmount();
+      if (originalVisibility) {
+        Object.defineProperty(document, "visibilityState", originalVisibility);
+      } else {
+        Reflect.deleteProperty(document, "visibilityState");
+      }
+    }
+  });
+});

package/src/app/routes/session-unavailable.tsx

@@ -1,9 +1,15 @@
-import { useEffect, useMemo, useState } from "react";
+import { isTransientRequestError } from "@opengeni/sdk";
+import { useEffect, useMemo, useRef, useState } from "react";
 
 import { LoadingPanel, ProblemPanel } from "../components/common";
 import { Button } from "../../ui/button";
 import { CrossSlotDeepLinkRecovery } from "../components/cross-slot-deep-link-recovery";
 import { useAppContext } from "../app-context";
+import {
+  DEFAULT_TRANSIENT_READ_RETRY,
+  transientReadRetryStep,
+  usePageLiveActivity,
+} from "../../hooks/internal";
 import {
   authorizedSessionReadWorkspaceIds,
   canonicalSessionDeepLinkTarget,
@@ -15,7 +21,29 @@ import { usePage } from "../lib/navigation";
 export function SessionUnavailableRoute(props: { workspaceId: string; sessionId: string }) {
   const page = usePage();
   const context = useAppContext();
-  const [state, setState] = useState<"resolving" | "not-found" | "error">("resolving");
+  const [state, setState] = useState<"resolving" | "not-found" | "error" | "transient">(
+    "resolving",
+  );
+  // Each attempt re-runs the lookup; transient failures schedule the next one.
+  const [attempt, setAttempt] = useState(0);
+  const transientStreakRef = useRef<{
+    key: string;
+    since: number;
+    attempts: number;
+    surfaced: boolean;
+  } | null>(null);
+  // A hidden page defers its next retry until it is visible again, and then
+  // looks with a fresh quiet window.
+  const pageLive = usePageLiveActivity();
+  const pageLiveRef = useRef(pageLive);
+  pageLiveRef.current = pageLive;
+  const deferredRetryRef = useRef(false);
+  useEffect(() => {
+    if (!pageLive || !deferredRetryRef.current) return;
+    deferredRetryRef.current = false;
+    transientStreakRef.current = null;
+    setAttempt((value) => value + 1);
+  }, [pageLive]);
   const sessionWorkspaceIds = useMemo(
     () => authorizedSessionReadWorkspaceIds(context.accessContext, context.workspaces),
     [context.accessContext, context.workspaces],
@@ -30,7 +58,14 @@ export function SessionUnavailableRoute(props: { workspaceId: string; sessionId:
 
   useEffect(() => {
     let cancelled = false;
-    setState("resolving");
+    let retryTimer: ReturnType<typeof setTimeout> | null = null;
+    deferredRetryRef.current = false;
+    const key = `${props.workspaceId}\u0000${props.sessionId}`;
+    if (transientStreakRef.current?.key !== key) transientStreakRef.current = null;
+    // While a transient failure is already shown, background retries keep it.
+    setState((current) =>
+      current === "transient" && transientStreakRef.current ? current : "resolving",
+    );
     void resolveAuthorizedSessionWorkspace(
       context.client,
       context.accessContext.workspaceGrants,
@@ -42,6 +77,7 @@ export function SessionUnavailableRoute(props: { workspaceId: string; sessionId:
     ).then((resolution) => {
       if (cancelled) return;
       if (resolution.status === "resolved") {
+        transientStreakRef.current = null;
         page.assign(
           canonicalSessionDeepLinkTarget(
             resolution.workspaceId,
@@ -52,10 +88,31 @@ export function SessionUnavailableRoute(props: { workspaceId: string; sessionId:
         );
         return;
       }
+      if (resolution.status === "error" && isTransientRequestError(resolution.error)) {
+        // A deploy or network blip: keep looking quietly, and show the problem
+        // only if it outlasts the quiet window. Keep retrying afterwards.
+        const now = Date.now();
+        const streak = (transientStreakRef.current ??= {
+          key,
+          since: now,
+          attempts: 0,
+          surfaced: false,
+        });
+        const step = transientReadRetryStep(streak, now, DEFAULT_TRANSIENT_READ_RETRY);
+        if (!step.quiet) setState("transient");
+        retryTimer = setTimeout(() => {
+          retryTimer = null;
+          if (pageLiveRef.current) setAttempt((value) => value + 1);
+          else deferredRetryRef.current = true;
+        }, step.delayMs);
+        return;
+      }
+      transientStreakRef.current = null;
       setState(resolution.status === "error" ? "error" : "not-found");
     });
     return () => {
       cancelled = true;
+      if (retryTimer !== null) clearTimeout(retryTimer);
     };
   }, [
     page,
@@ -64,9 +121,23 @@ export function SessionUnavailableRoute(props: { workspaceId: string; sessionId:
     sessionWorkspaceIds,
     props.sessionId,
     props.workspaceId,
+    attempt,
   ]);
 
   if (state === "resolving") return <LoadingPanel label="Looking for this session" />;
+  if (state === "transient") {
+    return (
+      <ProblemPanel
+        title="Temporarily unavailable"
+        description="Retrying automatically."
+        action={
+          <Button type="button" variant="outline" onClick={() => setAttempt((value) => value + 1)}>
+            Try again
+          </Button>
+        }
+      />
+    );
+  }
   const unavailable = (
     <ProblemPanel
       title={state === "error" ? "Session unavailable" : "Session not found"}

package/src/app/routes/session.tsx

@@ -134,7 +134,8 @@ import {
 } from "react";
 import { toast } from "../lib/toast";
 
-import { isApiErrorStatus, useAppApi } from "../lib/app-api";
+import { useAppApi } from "../lib/app-api";
+import { useSessionFailureToasts } from "../lib/session-failure-toasts";
 import { apiErrorFacts, userErrorText } from "../../ui/api-error";
 import { ConsoleComposer } from "../components/Composer";
 import { CONSOLE_TIMELINE_ALLOWANCE_LABELS } from "../lib/allowance-labels";
@@ -858,18 +859,7 @@ export function SessionRoute({
     },
     [sessionId, sessionEventFeedStore, setContextConnectionState, setContextSession],
   );
-  useEffect(() => {
-    if (streamError && !isApiErrorStatus(streamError, 404)) {
-      toast.error("Event stream disconnected", {
-        description: streamError.message,
-      });
-    }
-  }, [streamError]);
-  useEffect(() => {
-    if (loadError && !isApiErrorStatus(loadError, 404)) {
-      toast.error("Failed to load session", { description: String(loadError) });
-    }
-  }, [loadError]);
+  useSessionFailureToasts(loadError, streamError);
   // A reconnect OAuth round-trip lands back here (the reconnect card set
   // returnPath to this session). The connection is refreshed server-side, but
   // the original tool call was settled as an error and is never replayed. Strip
@@ -1277,6 +1267,7 @@ export function SessionRoute({
             workspaceId={workspaceId}
             sessionId={sessionId}
             loadError={loadError}
+            onRetry={() => void refreshSession()}
           />
         </Suspense>
       );

package/src/app/routes/sessions-index.tsx

@@ -1,4 +1,5 @@
 import { useAppApi } from "../lib/app-api";
+import { useSessionUiFeature } from "../lib/session-ui-features";
 import { initialWorkspaceMachineCompute } from "../lib/workspace-default-machine";
 import { t } from "../lib/console-text";
 import { ANALYTICS_COLLECTION_ENABLED_EVENT } from "../lib/analytics-consent";
@@ -259,6 +260,7 @@ function SessionsIndexRouteContent({
   const context = useAppContext();
   const api = useAppApi();
   const page = usePage();
+  const starters = useSessionUiFeature("starters");
   const connectionAccounts = useConnectionAccounts(
     context.client,
     {
@@ -2020,15 +2022,17 @@ function SessionsIndexRouteContent({
         </div>
 
         <RecentSessions workspaceId={workspaceId} />
-        <NewSessionStarters
-          workspaceId={workspaceId}
-          set={signupStarterSet(context.authSession?.user.email, workspace?.accountId)}
-          disabled={busy || newSessionDraft.loading}
-          onSelect={(prompt) => {
-            setMessage(prompt);
-            composerRegionRef.current?.querySelector("textarea")?.focus({ preventScroll: true });
-          }}
-        />
+        {starters ? (
+          <NewSessionStarters
+            workspaceId={workspaceId}
+            set={signupStarterSet(context.authSession?.user.email, workspace?.accountId)}
+            disabled={busy || newSessionDraft.loading}
+            onSelect={(prompt) => {
+              setMessage(prompt);
+              composerRegionRef.current?.querySelector("textarea")?.focus({ preventScroll: true });
+            }}
+          />
+        ) : null}
       </div>
       <ChannelCreateDialog
         open={projectDialogOpen}