Open-source Grok Bot alternative for named AI teammates. Local-first desktop, web, and mobile clients with per-bot tools, instructions, and memory. Independent fork of T3 Code.
Add WebSocket disconnect recovery and slow RPC toast UX (#1730)
Julius Marmingef2cd53f23219
diff --git a/apps/web/src/components/ChatView.tsx b/apps/web/src/components/ChatView.tsxindex 9d51fa506..f995bb4ce 100644--- a/apps/web/src/components/ChatView.tsx+++ b/apps/web/src/components/ChatView.tsx@@ -197,6 +197,7 @@ import {useServerConfig,useServerKeybindings,} from "~/rpc/serverState";+import { sanitizeThreadErrorMessage } from "~/rpc/transportError";const ATTACHMENT_PREVIEW_HANDOFF_TTL_MS = 5000;const IMAGE_SIZE_LIMIT_LABEL = `${Math.round(PROVIDER_SEND_TURN_MAX_IMAGE_BYTES / (1024 * 1024))}MB`;@@ -1599,17 +1600,18 @@ export default function ChatView({ threadId }: ChatViewProps) {const setThreadError = useCallback((targetThreadId: ThreadId | null, error: string | null) => {if (!targetThreadId) return;+ const nextError = sanitizeThreadErrorMessage(error);if (useStore.getState().threads.some((thread) => thread.id === targetThreadId)) {- setStoreThreadError(targetThreadId, error);+ setStoreThreadError(targetThreadId, nextError);return;}setLocalDraftErrorsByThreadId((existing) => {- if ((existing[targetThreadId] ?? null) === error) {+ if ((existing[targetThreadId] ?? null) === nextError) {return existing;}return {...existing,- [targetThreadId]: error,+ [targetThreadId]: nextError,};});},@@ -3153,14 +3155,14 @@ export default function ChatView({ threadId }: ChatViewProps) {createdAt: new Date().toISOString(),}).catch((err: unknown) => {- setStoreThreadError(+ setThreadError(activeThreadId,err instanceof Error ? err.message : "Failed to submit approval decision.",);});setRespondingRequestIds((existing) => existing.filter((id) => id !== requestId));},- [activeThreadId, setStoreThreadError],+ [activeThreadId, setThreadError],);const onRespondToUserInput = useCallback(@@ -3181,14 +3183,14 @@ export default function ChatView({ threadId }: ChatViewProps) {createdAt: new Date().toISOString(),}).catch((err: unknown) => {- setStoreThreadError(+ setThreadError(activeThreadId,err instanceof Error ? err.message : "Failed to submit user input.",);});setRespondingUserInputRequestIds((existing) => existing.filter((id) => id !== requestId));},- [activeThreadId, setStoreThreadError],+ [activeThreadId, setThreadError],);const setActivePendingUserInputQuestionIndex = useCallback(diff --git a/apps/web/src/components/WebSocketConnectionSurface.logic.test.ts b/apps/web/src/components/WebSocketConnectionSurface.logic.test.tsnew file mode 100644index 000000000..2e371b7d7--- /dev/null+++ b/apps/web/src/components/WebSocketConnectionSurface.logic.test.ts@@ -0,0 +1,83 @@+import { describe, expect, it } from "vitest";++import type { WsConnectionStatus } from "../rpc/wsConnectionState";+import { shouldAutoReconnect } from "./WebSocketConnectionSurface";++function makeStatus(overrides: Partial<WsConnectionStatus> = {}): WsConnectionStatus {+ return {+ attemptCount: 0,+ closeCode: null,+ closeReason: null,+ connectedAt: null,+ disconnectedAt: null,+ hasConnected: false,+ lastError: null,+ lastErrorAt: null,+ nextRetryAt: null,+ online: true,+ phase: "idle",+ reconnectAttemptCount: 0,+ reconnectMaxAttempts: 8,+ reconnectPhase: "idle",+ socketUrl: null,+ ...overrides,+ };+}++describe("WebSocketConnectionSurface.logic", () => {+ it("forces reconnect on online when the app was offline", () => {+ expect(+ shouldAutoReconnect(+ makeStatus({+ disconnectedAt: "2026-04-03T20:00:00.000Z",+ online: false,+ phase: "disconnected",+ }),+ "online",+ ),+ ).toBe(true);+ });++ it("forces reconnect on focus only for previously connected disconnected states", () => {+ expect(+ shouldAutoReconnect(+ makeStatus({+ hasConnected: true,+ online: true,+ phase: "disconnected",+ reconnectAttemptCount: 3,+ reconnectPhase: "waiting",+ }),+ "focus",+ ),+ ).toBe(true);++ expect(+ shouldAutoReconnect(+ makeStatus({+ hasConnected: false,+ online: true,+ phase: "disconnected",+ reconnectAttemptCount: 1,+ reconnectPhase: "waiting",+ }),+ "focus",+ ),+ ).toBe(false);+ });++ it("forces reconnect on focus for exhausted reconnect loops", () => {+ expect(+ shouldAutoReconnect(+ makeStatus({+ hasConnected: true,+ online: true,+ phase: "disconnected",+ reconnectAttemptCount: 8,+ reconnectPhase: "exhausted",+ }),+ "focus",+ ),+ ).toBe(true);+ });+});diff --git a/apps/web/src/components/WebSocketConnectionSurface.tsx b/apps/web/src/components/WebSocketConnectionSurface.tsxnew file mode 100644index 000000000..1855046a6--- /dev/null+++ b/apps/web/src/components/WebSocketConnectionSurface.tsx@@ -0,0 +1,544 @@+import { AlertTriangle, CloudOff, LoaderCircle, RotateCw } from "lucide-react";+import { type ReactNode, useEffect, useEffectEvent, useRef, useState } from "react";++import { APP_DISPLAY_NAME } from "../branding";+import { type SlowRpcAckRequest, useSlowRpcAckRequests } from "../rpc/requestLatencyState";+import { useServerConfig } from "../rpc/serverState";+import {+ exhaustWsReconnectIfStillWaiting,+ getWsConnectionStatus,+ getWsConnectionUiState,+ setBrowserOnlineStatus,+ type WsConnectionStatus,+ type WsConnectionUiState,+ useWsConnectionStatus,+ WS_RECONNECT_MAX_ATTEMPTS,+} from "../rpc/wsConnectionState";+import { Button } from "./ui/button";+import { toastManager } from "./ui/toast";+import { getWsRpcClient } from "~/wsRpcClient";++const FORCED_WS_RECONNECT_DEBOUNCE_MS = 5_000;+type WsAutoReconnectTrigger = "focus" | "online";++const connectionTimeFormatter = new Intl.DateTimeFormat(undefined, {+ day: "numeric",+ hour: "numeric",+ minute: "2-digit",+ month: "short",+ second: "2-digit",+});++function formatConnectionMoment(isoDate: string | null): string | null {+ if (!isoDate) {+ return null;+ }++ return connectionTimeFormatter.format(new Date(isoDate));+}++function formatRetryCountdown(nextRetryAt: string, nowMs: number): string {+ const remainingMs = Math.max(0, new Date(nextRetryAt).getTime() - nowMs);+ return `${Math.max(1, Math.ceil(remainingMs / 1000))}s`;+}++function describeOfflineToast(): string {+ return "WebSocket disconnected. Waiting for network.";+}++function formatReconnectAttemptLabel(status: WsConnectionStatus): string {+ const reconnectAttempt = Math.max(+ 1,+ Math.min(status.reconnectAttemptCount, WS_RECONNECT_MAX_ATTEMPTS),+ );+ return `Attempt ${reconnectAttempt}/${status.reconnectMaxAttempts}`;+}++function describeExhaustedToast(): string {+ return "Retries exhausted trying to reconnect";+}++function buildReconnectTitle(status: WsConnectionStatus): string {+ if (status.nextRetryAt === null) {+ return "Disconnected from T3 Server";+ }++ return "Disconnected from T3 Server";+}++function describeRecoveredToast(+ previousDisconnectedAt: string | null,+ connectedAt: string | null,+): string {+ const reconnectedAtLabel = formatConnectionMoment(connectedAt);+ const disconnectedAtLabel = formatConnectionMoment(previousDisconnectedAt);++ if (disconnectedAtLabel && reconnectedAtLabel) {+ return `Disconnected at ${disconnectedAtLabel} and reconnected at ${reconnectedAtLabel}.`;+ }++ if (reconnectedAtLabel) {+ return `Connection restored at ${reconnectedAtLabel}.`;+ }++ return "Connection restored.";+}++function describeSlowRpcAckToast(requests: ReadonlyArray<SlowRpcAckRequest>): ReactNode {+ const count = requests.length;+ const thresholdSeconds = Math.round((requests[0]?.thresholdMs ?? 0) / 1000);++ return `${count} request${count === 1 ? "" : "s"} waiting longer than ${thresholdSeconds}s.`;+}++export function shouldAutoReconnect(+ status: WsConnectionStatus,+ trigger: WsAutoReconnectTrigger,+): boolean {+ const uiState = getWsConnectionUiState(status);++ if (trigger === "online") {+ return (+ uiState === "offline" ||+ uiState === "reconnecting" ||+ uiState === "error" ||+ status.reconnectPhase === "exhausted"+ );+ }++ return (+ status.online &&+ status.hasConnected &&+ (uiState === "reconnecting" || status.reconnectPhase === "exhausted")+ );+}++function buildBlockingCopy(+ uiState: WsConnectionUiState,+ status: WsConnectionStatus,+): {+ readonly description: string;+ readonly eyebrow: string;+ readonly title: string;+} {+ if (uiState === "connecting") {+ return {+ description: `Opening the WebSocket connection to the ${APP_DISPLAY_NAME} server and waiting for the initial config snapshot.`,+ eyebrow: "Starting Session",+ title: `Connecting to ${APP_DISPLAY_NAME}`,+ };+ }++ if (uiState === "offline") {+ return {+ description:+ "Your browser is offline, so the web client cannot reach the T3 server. Reconnect to the network and the app will retry automatically.",+ eyebrow: "Offline",+ title: "WebSocket connection unavailable",+ };+ }++ if (status.lastError?.trim()) {+ return {+ description: `${status.lastError} Verify that the T3 server is running and reachable, then reload the app if needed.`,+ eyebrow: "Connection Error",+ title: "Cannot reach the T3 server",+ };+ }++ return {+ description:+ "The web client could not complete its initial WebSocket connection to the T3 server. It will keep retrying in the background.",+ eyebrow: "Connection Error",+ title: "Cannot reach the T3 server",+ };+}++function buildConnectionDetails(status: WsConnectionStatus, uiState: WsConnectionUiState): string {+ const details = [+ `state: ${uiState}`,+ `online: ${status.online ? "yes" : "no"}`,+ `attempts: ${status.attemptCount}`,+ ];++ if (status.socketUrl) {+ details.push(`socket: ${status.socketUrl}`);+ }+ if (status.connectedAt) {+ details.push(`connectedAt: ${status.connectedAt}`);+ }+ if (status.disconnectedAt) {+ details.push(`disconnectedAt: ${status.disconnectedAt}`);+ }+ if (status.lastErrorAt) {+ details.push(`lastErrorAt: ${status.lastErrorAt}`);+ }+ if (status.lastError) {+ details.push(`lastError: ${status.lastError}`);+ }+ if (status.closeCode !== null) {+ details.push(`closeCode: ${status.closeCode}`);+ }+ if (status.closeReason) {+ details.push(`closeReason: ${status.closeReason}`);+ }++ return details.join("\n");+}++function WebSocketBlockingState({+ status,+ uiState,+}: {+ readonly status: WsConnectionStatus;+ readonly uiState: WsConnectionUiState;+}) {+ const copy = buildBlockingCopy(uiState, status);+ const disconnectedAt = formatConnectionMoment(status.disconnectedAt ?? status.lastErrorAt);+ const Icon =+ uiState === "connecting" ? LoaderCircle : uiState === "offline" ? CloudOff : AlertTriangle;++ return (+ <div className="relative flex min-h-screen items-center justify-center overflow-hidden bg-background px-4 py-10 text-foreground sm:px-6">+ <div className="pointer-events-none absolute inset-0 opacity-90">+ <div className="absolute inset-x-0 top-0 h-56 bg-[radial-gradient(48rem_18rem_at_top,color-mix(in_srgb,var(--color-amber-500)_16%,transparent),transparent)]" />+ <div className="absolute inset-0 bg-[linear-gradient(145deg,color-mix(in_srgb,var(--background)_92%,var(--color-black))_0%,var(--background)_56%)]" />+ </div>++ <section className="relative w-full max-w-xl rounded-[1.75rem] border border-border/80 bg-card/92 p-6 shadow-2xl shadow-black/20 backdrop-blur-md sm:p-8">+ <div className="flex items-start justify-between gap-4">+ <div>+ <p className="text-[11px] font-semibold tracking-[0.18em] text-muted-foreground uppercase">+ {copy.eyebrow}+ </p>+ <h1 className="mt-3 text-2xl font-semibold tracking-tight sm:text-3xl">{copy.title}</h1>+ </div>+ <div className="rounded-2xl border border-border/70 bg-background/80 p-3 text-foreground shadow-sm">+ <Icon className={uiState === "connecting" ? "size-5 animate-spin" : "size-5"} />+ </div>+ </div>++ <p className="mt-3 text-sm leading-relaxed text-muted-foreground">{copy.description}</p>++ <div className="mt-5 grid gap-3 rounded-2xl border border-border/70 bg-background/60 p-4 text-sm sm:grid-cols-2">+ <div>+ <p className="text-[11px] font-semibold tracking-[0.16em] text-muted-foreground uppercase">+ Connection+ </p>+ <p className="mt-1 font-medium text-foreground">+ {uiState === "connecting"+ ? "Opening WebSocket"+ : uiState === "offline"+ ? "Waiting for network"+ : "Retrying server connection"}+ </p>+ </div>+ <div>+ <p className="text-[11px] font-semibold tracking-[0.16em] text-muted-foreground uppercase">+ Latest Event+ </p>+ <p className="mt-1 font-medium text-foreground">{disconnectedAt ?? "Pending"}</p>+ </div>+ </div>++ <div className="mt-5 flex flex-wrap gap-2">+ <Button size="sm" onClick={() => window.location.reload()}>+ <RotateCw />+ Reload app+ </Button>+ </div>++ <details className="group mt-5 overflow-hidden rounded-lg border border-border/70 bg-background/55">+ <summary className="cursor-pointer list-none px-3 py-2 text-xs font-medium text-muted-foreground">+ <span className="group-open:hidden">Show connection details</span>+ <span className="hidden group-open:inline">Hide connection details</span>+ </summary>+ <pre className="max-h-56 overflow-auto border-t border-border/70 bg-background/80 px-3 py-2 text-xs text-foreground/85">+ {buildConnectionDetails(status, uiState)}+ </pre>+ </details>+ </section>+ </div>+ );+}++export function WebSocketConnectionCoordinator() {+ const status = useWsConnectionStatus();+ const [nowMs, setNowMs] = useState(() => Date.now());+ const lastForcedReconnectAtRef = useRef(0);+ const toastIdRef = useRef<ReturnType<typeof toastManager.add> | null>(null);+ const toastResetTimerRef = useRef<number | null>(null);+ const previousUiStateRef = useRef<WsConnectionUiState>(getWsConnectionUiState(status));+ const previousDisconnectedAtRef = useRef<string | null>(status.disconnectedAt);++ const runReconnect = useEffectEvent((showFailureToast: boolean) => {+ if (toastResetTimerRef.current !== null) {+ window.clearTimeout(toastResetTimerRef.current);+ toastResetTimerRef.current = null;+ }+ lastForcedReconnectAtRef.current = Date.now();+ void getWsRpcClient()+ .reconnect()+ .catch((error) => {+ if (!showFailureToast) {+ console.warn("Automatic WebSocket reconnect failed", { error });+ return;+ }+ toastManager.add({+ type: "error",+ title: "Reconnect failed",+ description: error instanceof Error ? error.message : "Unable to restart the WebSocket.",+ data: {+ dismissAfterVisibleMs: 8_000,+ hideCopyButton: true,+ },+ });+ });+ });+ const syncBrowserOnlineStatus = useEffectEvent(() => {+ setBrowserOnlineStatus(navigator.onLine !== false);+ });+ const triggerManualReconnect = useEffectEvent(() => {+ runReconnect(true);+ });+ const triggerAutoReconnect = useEffectEvent((trigger: WsAutoReconnectTrigger) => {+ const currentStatus =+ trigger === "online" ? setBrowserOnlineStatus(true) : getWsConnectionStatus();++ if (!shouldAutoReconnect(currentStatus, trigger)) {+ return;+ }+ if (Date.now() - lastForcedReconnectAtRef.current < FORCED_WS_RECONNECT_DEBOUNCE_MS) {+ return;+ }++ runReconnect(false);+ });++ useEffect(() => {+ const handleOnline = () => {+ triggerAutoReconnect("online");+ };+ const handleFocus = () => {+ triggerAutoReconnect("focus");+ };++ syncBrowserOnlineStatus();+ window.addEventListener("online", handleOnline);+ window.addEventListener("offline", syncBrowserOnlineStatus);+ window.addEventListener("focus", handleFocus);+ return () => {+ window.removeEventListener("online", handleOnline);+ window.removeEventListener("offline", syncBrowserOnlineStatus);+ window.removeEventListener("focus", handleFocus);+ };+ }, []);++ useEffect(() => {+ if (status.reconnectPhase !== "waiting" || status.nextRetryAt === null) {+ return;+ }++ setNowMs(Date.now());+ const intervalId = window.setInterval(() => {+ setNowMs(Date.now());+ }, 1_000);++ return () => {+ window.clearInterval(intervalId);+ };+ }, [status.nextRetryAt, status.reconnectPhase]);++ useEffect(() => {+ if (+ status.reconnectPhase !== "waiting" ||+ status.nextRetryAt === null ||+ !status.online ||+ !status.hasConnected+ ) {+ return;+ }++ const nextRetryAt = status.nextRetryAt;+ const timeoutMs = Math.max(0, new Date(nextRetryAt).getTime() - Date.now()) + 1_500;+ const timeoutId = window.setTimeout(() => {+ exhaustWsReconnectIfStillWaiting(nextRetryAt);+ }, timeoutMs);++ return () => {+ window.clearTimeout(timeoutId);+ };+ }, [+ status.hasConnected,+ status.nextRetryAt,+ status.online,+ status.reconnectAttemptCount,+ status.reconnectPhase,+ ]);++ useEffect(() => {+ const uiState = getWsConnectionUiState(status);+ const previousUiState = previousUiStateRef.current;+ const previousDisconnectedAt = previousDisconnectedAtRef.current;+ const shouldShowReconnectToast = status.hasConnected && uiState === "reconnecting";+ const shouldShowOfflineToast = uiState === "offline" && status.disconnectedAt !== null;+ const shouldShowExhaustedToast = status.hasConnected && status.reconnectPhase === "exhausted";++ if (+ toastResetTimerRef.current !== null &&+ (shouldShowReconnectToast || shouldShowOfflineToast || shouldShowExhaustedToast)+ ) {+ window.clearTimeout(toastResetTimerRef.current);+ toastResetTimerRef.current = null;+ }++ if (shouldShowReconnectToast || shouldShowOfflineToast || shouldShowExhaustedToast) {+ const toastPayload = shouldShowOfflineToast+ ? {+ description: describeOfflineToast(),+ timeout: 0,+ title: "Offline",+ type: "warning" as const,+ data: {+ hideCopyButton: true,+ },+ }+ : shouldShowExhaustedToast+ ? {+ actionProps: {+ children: "Retry",+ onClick: triggerManualReconnect,+ },+ description: describeExhaustedToast(),+ timeout: 0,+ title: "Disconnected from T3 Server",+ type: "error" as const,+ data: {+ hideCopyButton: true,+ },+ }+ : {+ actionProps: {+ children: "Retry now",+ onClick: triggerManualReconnect,+ },+ description:+ status.nextRetryAt === null+ ? `Reconnecting... ${formatReconnectAttemptLabel(status)}`+ : `Reconnecting in ${formatRetryCountdown(status.nextRetryAt, nowMs)}... ${formatReconnectAttemptLabel(status)}`,+ timeout: 0,+ title: buildReconnectTitle(status),+ type: "loading" as const,+ data: {+ hideCopyButton: true,+ },+ };++ if (toastIdRef.current) {+ toastManager.update(toastIdRef.current, toastPayload);+ } else {+ toastIdRef.current = toastManager.add(toastPayload);+ }+ } else if (toastIdRef.current) {+ toastManager.close(toastIdRef.current);+ toastIdRef.current = null;+ }++ if (+ uiState === "connected" &&+ (previousUiState === "offline" || previousUiState === "reconnecting") &&+ previousDisconnectedAt !== null+ ) {+ const successToast = {+ description: describeRecoveredToast(previousDisconnectedAt, status.connectedAt),+ title: "Reconnected to T3 Server",+ type: "success" as const,+ timeout: 0,+ data: {+ dismissAfterVisibleMs: 8_000,+ hideCopyButton: true,+ },+ };++ if (toastIdRef.current) {+ toastManager.update(toastIdRef.current, successToast);+ } else {+ toastIdRef.current = toastManager.add(successToast);+ }++ toastResetTimerRef.current = window.setTimeout(() => {+ toastIdRef.current = null;+ toastResetTimerRef.current = null;+ }, 8_250);+ }++ previousUiStateRef.current = uiState;+ previousDisconnectedAtRef.current = status.disconnectedAt;+ }, [nowMs, status]);++ useEffect(() => {+ return () => {+ if (toastResetTimerRef.current !== null) {+ window.clearTimeout(toastResetTimerRef.current);+ }+ };+ }, []);++ return null;+}++export function SlowRpcAckToastCoordinator() {+ const slowRequests = useSlowRpcAckRequests();+ const status = useWsConnectionStatus();+ const toastIdRef = useRef<ReturnType<typeof toastManager.add> | null>(null);++ useEffect(() => {+ if (getWsConnectionUiState(status) !== "connected") {+ if (toastIdRef.current) {+ toastManager.close(toastIdRef.current);+ toastIdRef.current = null;+ }+ return;+ }++ if (slowRequests.length === 0) {+ if (toastIdRef.current) {+ toastManager.close(toastIdRef.current);+ toastIdRef.current = null;+ }+ return;+ }++ const nextToast = {+ description: describeSlowRpcAckToast(slowRequests),+ timeout: 0,+ title: "Some requests are slow",+ type: "warning" as const,+ };++ if (toastIdRef.current) {+ toastManager.update(toastIdRef.current, nextToast);+ } else {+ toastIdRef.current = toastManager.add(nextToast);+ }+ }, [slowRequests, status]);++ return null;+}++export function WebSocketConnectionSurface({ children }: { readonly children: ReactNode }) {+ const serverConfig = useServerConfig();+ const status = useWsConnectionStatus();++ if (serverConfig === null) {+ const uiState = getWsConnectionUiState(status);+ return (+ <WebSocketBlockingState+ status={status}+ uiState={uiState === "connected" ? "connecting" : uiState}+ />+ );+ }++ return children;+}diff --git a/apps/web/src/components/ui/toast.tsx b/apps/web/src/components/ui/toast.tsxindex 123bb388c..dbe546cc8 100644--- a/apps/web/src/components/ui/toast.tsx+++ b/apps/web/src/components/ui/toast.tsx@@ -23,6 +23,7 @@ export type ThreadToastData = {threadId?: ThreadId | null;tooltipStyle?: boolean;dismissAfterVisibleMs?: number;+ hideCopyButton?: boolean;};const toastManager = Toast.createToastManager<ThreadToastData>();@@ -308,15 +309,15 @@ function Toasts({ position = "top-right" }: { position: ToastPosition }) {<div className="flex min-w-0 flex-1 flex-col gap-0.5"><div className="flex items-center justify-between gap-1"><Toast.Title- className="min-w-0 break-words font-medium"+ className="min-w-0 wrap-break-word font-medium"data-slot="toast-title"/>- {toast.type === "error" && typeof toast.description === "string" && (- <CopyErrorButton text={toast.description} />- )}+ {toast.type === "error" &&+ typeof toast.description === "string" &&+ !toast.data?.hideCopyButton && <CopyErrorButton text={toast.description} />}</div><Toast.Description- className="min-w-0 select-text break-words text-muted-foreground"+ className="min-w-0 select-text wrap-break-word text-muted-foreground"data-slot="toast-description"/></div>@@ -402,15 +403,17 @@ function AnchoredToasts() {<div className="flex min-w-0 flex-1 flex-col gap-0.5"><div className="flex items-center gap-1"><Toast.Title- className="min-w-0 break-words font-medium"+ className="min-w-0 wrap-break-word font-medium"data-slot="toast-title"/>- {toast.type === "error" && typeof toast.description === "string" && (- <CopyErrorButton text={toast.description} />- )}+ {toast.type === "error" &&+ typeof toast.description === "string" &&+ !toast.data?.hideCopyButton && (+ <CopyErrorButton text={toast.description} />+ )}</div><Toast.Description- className="min-w-0 select-text break-words text-muted-foreground"+ className="min-w-0 select-text wrap-break-word text-muted-foreground"data-slot="toast-description"/></div>diff --git a/apps/web/src/orchestrationRecovery.ts b/apps/web/src/orchestrationRecovery.tsindex 270461bd2..c9ccf3a39 100644--- a/apps/web/src/orchestrationRecovery.ts+++ b/apps/web/src/orchestrationRecovery.ts@@ -1,4 +1,8 @@-export type OrchestrationRecoveryReason = "bootstrap" | "sequence-gap" | "replay-failed";+export type OrchestrationRecoveryReason =+ | "bootstrap"+ | "sequence-gap"+ | "resubscribe"+ | "replay-failed";export interface OrchestrationRecoveryPhase {kind: "snapshot" | "replay";diff --git a/apps/web/src/routes/__root.tsx b/apps/web/src/routes/__root.tsxindex a750f6fd2..8f3667d93 100644--- a/apps/web/src/routes/__root.tsx+++ b/apps/web/src/routes/__root.tsx@@ -16,6 +16,11 @@ import { Throttler } from "@tanstack/react-pacer";import { APP_DISPLAY_NAME } from "../branding";import { AppSidebarLayout } from "../components/AppSidebarLayout";+import {+ SlowRpcAckToastCoordinator,+ WebSocketConnectionCoordinator,+ WebSocketConnectionSurface,+} from "../components/WebSocketConnectionSurface";import { Button } from "../components/ui/button";import { AnchoredToastProvider, ToastProvider, toastManager } from "../components/ui/toast";import { resolveAndPersistPreferredEditor } from "../editorPreferences";@@ -73,9 +78,13 @@ function RootRouteView() {<AnchoredToastProvider><ServerStateBootstrap /><EventRouter />- <AppSidebarLayout>- <Outlet />- </AppSidebarLayout>+ <WebSocketConnectionCoordinator />+ <SlowRpcAckToastCoordinator />+ <WebSocketConnectionSurface>+ <AppSidebarLayout>+ <Outlet />+ </AppSidebarLayout>+ </WebSocketConnectionSurface></AnchoredToastProvider></ToastProvider>);@@ -428,8 +437,8 @@ function EventRouter() {queueMicrotask(flushPendingDomainEvents);};- const recoverFromSequenceGap = async (): Promise<void> => {- if (!recovery.beginReplayRecovery("sequence-gap")) {+ const runReplayRecovery = async (reason: "sequence-gap" | "resubscribe"): Promise<void> => {+ if (!recovery.beginReplayRecovery(reason)) {return;}@@ -466,7 +475,7 @@ function EventRouter() {return;}}- void recoverFromSequenceGap();+ void runReplayRecovery(reason);} else if (replayCompletion.shouldReplay && import.meta.env.MODE !== "test") {console.warn("[orchestration-recovery]",@@ -505,7 +514,7 @@ function EventRouter() {syncServerReadModel(snapshot);reconcileSnapshotDerivedState();if (recovery.completeSnapshotRecovery(snapshot.snapshotSequence)) {- void recoverFromSequenceGap();+ void runReplayRecovery("sequence-gap");}}} catch {@@ -522,18 +531,29 @@ function EventRouter() {const fallbackToSnapshotRecovery = async (): Promise<void> => {await runSnapshotRecovery("replay-failed");};- const unsubDomainEvent = api.orchestration.onDomainEvent((event) => {- const action = recovery.classifyDomainEvent(event.sequence);- if (action === "apply") {- pendingDomainEvents.push(event);- schedulePendingDomainEventFlush();- return;- }- if (action === "recover") {- flushPendingDomainEvents();- void recoverFromSequenceGap();- }- });+ const unsubDomainEvent = api.orchestration.onDomainEvent(+ (event) => {+ const action = recovery.classifyDomainEvent(event.sequence);+ if (action === "apply") {+ pendingDomainEvents.push(event);+ schedulePendingDomainEventFlush();+ return;+ }+ if (action === "recover") {+ flushPendingDomainEvents();+ void runReplayRecovery("sequence-gap");+ }+ },+ {+ onResubscribe: () => {+ if (disposed) {+ return;+ }+ flushPendingDomainEvents();+ void runReplayRecovery("resubscribe");+ },+ },+ );const unsubTerminalEvent = api.terminal.onEvent((event) => {const thread = useStore.getState().threads.find((entry) => entry.id === event.threadId);if (thread && thread.archivedAt !== null) {diff --git a/apps/web/src/rpc/protocol.ts b/apps/web/src/rpc/protocol.tsindex 38012e507..fc5ab9097 100644--- a/apps/web/src/rpc/protocol.ts+++ b/apps/web/src/rpc/protocol.ts@@ -1,9 +1,22 @@import { WsRpcGroup } from "@t3tools/contracts";-import { Effect, Layer } from "effect";+import { Duration, Effect, Layer, Schedule } from "effect";import { RpcClient, RpcSerialization } from "effect/unstable/rpc";import * as Socket from "effect/unstable/socket/Socket";import { resolveServerUrl } from "../lib/utils";+import {+ acknowledgeRpcRequest,+ clearAllTrackedRpcRequests,+ trackRpcRequestSent,+} from "./requestLatencyState";+import {+ getWsReconnectDelayMsForRetry,+ recordWsConnectionAttempt,+ recordWsConnectionClosed,+ recordWsConnectionErrored,+ recordWsConnectionOpened,+ WS_RECONNECT_MAX_RETRIES,+} from "./wsConnectionState";export const makeWsRpcProtocolClient = RpcClient.make(WsRpcGroup);@@ -17,11 +30,75 @@ export function createWsRpcProtocolLayer(url?: string) {protocol: window.location.protocol === "https:" ? "wss" : "ws",pathname: "/ws",});+ const trackingWebSocketConstructorLayer = Layer.succeed(+ Socket.WebSocketConstructor,+ (socketUrl, protocols) => {+ recordWsConnectionAttempt(socketUrl);+ const socket = new globalThis.WebSocket(socketUrl, protocols);++ socket.addEventListener(+ "open",+ () => {+ recordWsConnectionOpened();+ },+ { once: true },+ );+ socket.addEventListener(+ "error",+ () => {+ clearAllTrackedRpcRequests();+ recordWsConnectionErrored("Unable to connect to the T3 server WebSocket.");+ },+ { once: true },+ );+ socket.addEventListener(+ "close",+ (event) => {+ clearAllTrackedRpcRequests();+ recordWsConnectionClosed({+ code: event.code,+ reason: event.reason,+ });+ },+ { once: true },+ );++ return socket;+ },+ );const socketLayer = Socket.layerWebSocket(resolvedUrl).pipe(- Layer.provide(Socket.layerWebSocketConstructorGlobal),+ Layer.provide(trackingWebSocketConstructorLayer),);-- return RpcClient.layerProtocolSocket({ retryTransientErrors: true }).pipe(- Layer.provide(Layer.mergeAll(socketLayer, RpcSerialization.layerJson)),+ const retryPolicy = Schedule.addDelay(Schedule.recurs(WS_RECONNECT_MAX_RETRIES), (retryCount) =>+ Effect.succeed(Duration.millis(getWsReconnectDelayMsForRetry(retryCount) ?? 0)),+ );+ const protocolLayer = Layer.effect(+ RpcClient.Protocol,+ Effect.map(+ RpcClient.makeProtocolSocket({+ retryPolicy,+ retryTransientErrors: true,+ }),+ (protocol) => ({+ ...protocol,+ run: (writeResponse) =>+ protocol.run((response) => {+ if (response._tag === "Chunk" || response._tag === "Exit") {+ acknowledgeRpcRequest(response.requestId);+ } else if (response._tag === "ClientProtocolError" || response._tag === "Defect") {+ clearAllTrackedRpcRequests();+ }+ return writeResponse(response);+ }),+ send: (request, transferables) => {+ if (request._tag === "Request") {+ trackRpcRequestSent(request.id, request.tag);+ }+ return protocol.send(request, transferables);+ },+ }),+ ),);++ return protocolLayer.pipe(Layer.provide(Layer.mergeAll(socketLayer, RpcSerialization.layerJson)));}diff --git a/apps/web/src/rpc/requestLatencyState.test.ts b/apps/web/src/rpc/requestLatencyState.test.tsnew file mode 100644index 000000000..ac83c3b26--- /dev/null+++ b/apps/web/src/rpc/requestLatencyState.test.ts@@ -0,0 +1,65 @@+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";++import {+ acknowledgeRpcRequest,+ getSlowRpcAckRequests,+ resetRequestLatencyStateForTests,+ trackRpcRequestSent,+ SLOW_RPC_ACK_THRESHOLD_MS,+ MAX_TRACKED_RPC_ACK_REQUESTS,+} from "./requestLatencyState";++describe("requestLatencyState", () => {+ beforeEach(() => {+ vi.useFakeTimers();+ resetRequestLatencyStateForTests();+ });++ afterEach(() => {+ vi.useRealTimers();+ });++ it("marks unary requests as slow when the ack threshold is exceeded", () => {+ trackRpcRequestSent("1", "server.getConfig");+ vi.advanceTimersByTime(SLOW_RPC_ACK_THRESHOLD_MS - 1);+ expect(getSlowRpcAckRequests()).toEqual([]);++ vi.advanceTimersByTime(1);+ expect(getSlowRpcAckRequests()).toMatchObject([+ {+ requestId: "1",+ tag: "server.getConfig",+ thresholdMs: SLOW_RPC_ACK_THRESHOLD_MS,+ },+ ]);+ });++ it("clears the slow request once the server acknowledges it", () => {+ trackRpcRequestSent("1", "git.status");+ vi.advanceTimersByTime(SLOW_RPC_ACK_THRESHOLD_MS);+ expect(getSlowRpcAckRequests()).toHaveLength(1);++ acknowledgeRpcRequest("1");+ expect(getSlowRpcAckRequests()).toEqual([]);+ });++ it("ignores long-lived subscribe requests", () => {+ trackRpcRequestSent("1", "subscribeServerConfig");+ vi.advanceTimersByTime(SLOW_RPC_ACK_THRESHOLD_MS * 2);++ expect(getSlowRpcAckRequests()).toEqual([]);+ });++ it("evicts the oldest pending requests once the tracker reaches capacity", () => {+ for (let index = 0; index < MAX_TRACKED_RPC_ACK_REQUESTS + 1; index += 1) {+ trackRpcRequestSent(String(index), "server.getConfig");+ }++ vi.advanceTimersByTime(SLOW_RPC_ACK_THRESHOLD_MS);++ const slowRequests = getSlowRpcAckRequests();+ expect(slowRequests).toHaveLength(MAX_TRACKED_RPC_ACK_REQUESTS);+ expect(slowRequests[0]?.requestId).toBe("1");+ expect(slowRequests.at(-1)?.requestId).toBe(String(MAX_TRACKED_RPC_ACK_REQUESTS));+ });+});diff --git a/apps/web/src/rpc/requestLatencyState.ts b/apps/web/src/rpc/requestLatencyState.tsnew file mode 100644index 000000000..01c59ea0d--- /dev/null+++ b/apps/web/src/rpc/requestLatencyState.ts@@ -0,0 +1,127 @@+import { useAtomValue } from "@effect/atom-react";+import { Atom } from "effect/unstable/reactivity";++import { appAtomRegistry } from "./atomRegistry";++export const SLOW_RPC_ACK_THRESHOLD_MS = 2_500;+export const MAX_TRACKED_RPC_ACK_REQUESTS = 256;++export interface SlowRpcAckRequest {+ readonly requestId: string;+ readonly startedAt: string;+ readonly startedAtMs: number;+ readonly tag: string;+ readonly thresholdMs: number;+}++interface PendingRpcAckRequest {+ readonly request: SlowRpcAckRequest;+ readonly timeoutId: ReturnType<typeof setTimeout>;+}++const pendingRpcAckRequests = new Map<string, PendingRpcAckRequest>();++const slowRpcAckRequestsAtom = Atom.make<ReadonlyArray<SlowRpcAckRequest>>([]).pipe(+ Atom.keepAlive,+ Atom.withLabel("slow-rpc-ack-requests"),+);++function setSlowRpcAckRequests(requests: ReadonlyArray<SlowRpcAckRequest>) {+ appAtomRegistry.set(slowRpcAckRequestsAtom, [...requests]);+}++function getSlowRpcAckRequestsValue(): ReadonlyArray<SlowRpcAckRequest> {+ return appAtomRegistry.get(slowRpcAckRequestsAtom);+}++function shouldTrackRpcAck(tag: string): boolean {+ return !tag.startsWith("subscribe");+}++export function getSlowRpcAckRequests(): ReadonlyArray<SlowRpcAckRequest> {+ return getSlowRpcAckRequestsValue();+}++export function trackRpcRequestSent(requestId: string, tag: string): void {+ if (!shouldTrackRpcAck(tag)) {+ return;+ }++ clearTrackedRpcRequest(requestId);+ evictOldestPendingRpcRequestIfNeeded();++ const startedAtMs = Date.now();+ const request: SlowRpcAckRequest = {+ requestId,+ startedAt: new Date(startedAtMs).toISOString(),+ startedAtMs,+ tag,+ thresholdMs: SLOW_RPC_ACK_THRESHOLD_MS,+ };+ const timeoutId = setTimeout(() => {+ pendingRpcAckRequests.delete(requestId);+ appendSlowRpcAckRequest(request);+ }, SLOW_RPC_ACK_THRESHOLD_MS);++ pendingRpcAckRequests.set(requestId, {+ request,+ timeoutId,+ });+}++export function acknowledgeRpcRequest(requestId: string): void {+ clearTrackedRpcRequest(requestId);+ const slowRequests = getSlowRpcAckRequestsValue();+ if (!slowRequests.some((request) => request.requestId === requestId)) {+ return;+ }++ setSlowRpcAckRequests(slowRequests.filter((request) => request.requestId !== requestId));+}++export function clearAllTrackedRpcRequests(): void {+ for (const pending of pendingRpcAckRequests.values()) {+ clearTimeout(pending.timeoutId);+ }+ pendingRpcAckRequests.clear();+ setSlowRpcAckRequests([]);+}++function clearTrackedRpcRequest(requestId: string): void {+ const pending = pendingRpcAckRequests.get(requestId);+ if (!pending) {+ return;+ }++ clearTimeout(pending.timeoutId);+ pendingRpcAckRequests.delete(requestId);+}++function appendSlowRpcAckRequest(request: SlowRpcAckRequest): void {+ const requests = [...getSlowRpcAckRequestsValue(), request];+ if (requests.length <= MAX_TRACKED_RPC_ACK_REQUESTS) {+ setSlowRpcAckRequests(requests);+ return;+ }++ setSlowRpcAckRequests(requests.slice(-MAX_TRACKED_RPC_ACK_REQUESTS));+}++function evictOldestPendingRpcRequestIfNeeded(): void {+ while (pendingRpcAckRequests.size >= MAX_TRACKED_RPC_ACK_REQUESTS) {+ const oldestRequestId = pendingRpcAckRequests.keys().next().value;+ if (oldestRequestId === undefined) {+ return;+ }++ clearTrackedRpcRequest(oldestRequestId);+ }+}++export function resetRequestLatencyStateForTests(): void {+ clearAllTrackedRpcRequests();+}++export function useSlowRpcAckRequests(): ReadonlyArray<SlowRpcAckRequest> {+ return useAtomValue(slowRpcAckRequestsAtom);+}diff --git a/apps/web/src/rpc/transportError.test.ts b/apps/web/src/rpc/transportError.test.tsnew file mode 100644index 000000000..f9da05abb--- /dev/null+++ b/apps/web/src/rpc/transportError.test.ts@@ -0,0 +1,24 @@+import { describe, expect, it } from "vitest";++import { isTransportConnectionErrorMessage, sanitizeThreadErrorMessage } from "./transportError";++describe("transportError", () => {+ it("detects websocket transport failures", () => {+ expect(isTransportConnectionErrorMessage("SocketCloseError: 1006")).toBe(true);+ expect(isTransportConnectionErrorMessage("Unable to connect to the T3 server WebSocket.")).toBe(+ true,+ );+ expect(isTransportConnectionErrorMessage("SocketOpenError: Timeout")).toBe(true);+ });++ it("preserves non-transport thread errors", () => {+ expect(sanitizeThreadErrorMessage("Turn failed")).toBe("Turn failed");+ expect(sanitizeThreadErrorMessage("Select a base branch before sending.")).toBe(+ "Select a base branch before sending.",+ );+ });++ it("drops transport failures from thread surfaces", () => {+ expect(sanitizeThreadErrorMessage("SocketCloseError: 1006")).toBeNull();+ });+});diff --git a/apps/web/src/rpc/transportError.ts b/apps/web/src/rpc/transportError.tsnew file mode 100644index 000000000..edc90a5a3--- /dev/null+++ b/apps/web/src/rpc/transportError.ts@@ -0,0 +1,23 @@+const TRANSPORT_ERROR_PATTERNS = [+ /\bSocketCloseError\b/i,+ /\bSocketOpenError\b/i,+ /Unable to connect to the T3 server WebSocket\./i,+ /\bping timeout\b/i,+] as const;++export function isTransportConnectionErrorMessage(message: string | null | undefined): boolean {+ if (typeof message !== "string") {+ return false;+ }++ const normalizedMessage = message.trim();+ if (normalizedMessage.length === 0) {+ return false;+ }++ return TRANSPORT_ERROR_PATTERNS.some((pattern) => pattern.test(normalizedMessage));+}++export function sanitizeThreadErrorMessage(message: string | null | undefined): string | null {+ return isTransportConnectionErrorMessage(message) ? null : (message ?? null);+}diff --git a/apps/web/src/rpc/wsConnectionState.test.ts b/apps/web/src/rpc/wsConnectionState.test.tsnew file mode 100644index 000000000..f4e8689a5--- /dev/null+++ b/apps/web/src/rpc/wsConnectionState.test.ts@@ -0,0 +1,112 @@+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";++import {+ exhaustWsReconnectIfStillWaiting,+ getWsConnectionStatus,+ getWsReconnectDelayMsForRetry,+ getWsConnectionUiState,+ recordWsConnectionAttempt,+ recordWsConnectionClosed,+ recordWsConnectionErrored,+ recordWsConnectionOpened,+ resetWsConnectionStateForTests,+ setBrowserOnlineStatus,+ WS_RECONNECT_MAX_ATTEMPTS,+} from "./wsConnectionState";++describe("wsConnectionState", () => {+ beforeEach(() => {+ vi.useFakeTimers();+ vi.setSystemTime(new Date("2026-04-03T20:30:00.000Z"));+ resetWsConnectionStateForTests();+ });++ afterEach(() => {+ vi.useRealTimers();+ });++ it("treats a disconnected browser as offline once the websocket drops", () => {+ recordWsConnectionAttempt("ws://localhost:3020/ws");+ recordWsConnectionOpened();+ recordWsConnectionClosed({ code: 1006, reason: "offline" });+ setBrowserOnlineStatus(false);++ expect(getWsConnectionUiState(getWsConnectionStatus())).toBe("offline");+ });++ it("stays in the initial connecting state until the first disconnect", () => {+ recordWsConnectionAttempt("ws://localhost:3020/ws");++ expect(getWsConnectionStatus()).toMatchObject({+ attemptCount: 1,+ hasConnected: false,+ phase: "connecting",+ });+ expect(getWsConnectionUiState(getWsConnectionStatus())).toBe("connecting");+ });++ it("schedules the next retry after a failed websocket attempt", () => {+ recordWsConnectionAttempt("ws://localhost:3020/ws");+ recordWsConnectionErrored("Unable to connect to the T3 server WebSocket.");++ const firstRetryDelayMs = getWsReconnectDelayMsForRetry(0);+ if (firstRetryDelayMs === null) {+ throw new Error("Expected an initial retry delay.");+ }++ expect(getWsConnectionStatus()).toMatchObject({+ nextRetryAt: new Date(Date.now() + firstRetryDelayMs).toISOString(),+ reconnectAttemptCount: 1,+ reconnectPhase: "waiting",+ });+ });++ it("marks the reconnect cycle as exhausted after the final attempt fails", () => {+ for (let attempt = 0; attempt < WS_RECONNECT_MAX_ATTEMPTS; attempt += 1) {+ recordWsConnectionAttempt("ws://localhost:3020/ws");+ recordWsConnectionErrored("Unable to connect to the T3 server WebSocket.");+ }++ expect(getWsConnectionStatus()).toMatchObject({+ nextRetryAt: null,+ reconnectAttemptCount: WS_RECONNECT_MAX_ATTEMPTS,+ reconnectPhase: "exhausted",+ });+ });++ it("can exhaust a stalled final retry window when no new attempt starts", () => {+ recordWsConnectionAttempt("ws://localhost:3020/ws");+ recordWsConnectionOpened();++ for (let attempt = 0; attempt < WS_RECONNECT_MAX_ATTEMPTS - 1; attempt += 1) {+ recordWsConnectionAttempt("ws://localhost:3020/ws");+ recordWsConnectionErrored("Unable to connect to the T3 server WebSocket.");+ }++ const finalRetryDelayMs = getWsReconnectDelayMsForRetry(WS_RECONNECT_MAX_ATTEMPTS - 2);+ if (finalRetryDelayMs === null) {+ throw new Error("Expected a final retry delay.");+ }++ const statusBeforeExhaust = getWsConnectionStatus();+ expect(statusBeforeExhaust).toMatchObject({+ nextRetryAt: new Date(Date.now() + finalRetryDelayMs).toISOString(),+ reconnectAttemptCount: 7,+ reconnectPhase: "waiting",+ });++ const nextRetryAt = statusBeforeExhaust.nextRetryAt;+ if (!nextRetryAt) {+ throw new Error("Expected a scheduled retry.");+ }++ vi.setSystemTime(new Date(Date.now() + finalRetryDelayMs + 1_000));+ exhaustWsReconnectIfStillWaiting(nextRetryAt);++ expect(getWsConnectionStatus()).toMatchObject({+ nextRetryAt: null,+ reconnectAttemptCount: WS_RECONNECT_MAX_ATTEMPTS,+ reconnectPhase: "exhausted",+ });+ });+});diff --git a/apps/web/src/rpc/wsConnectionState.ts b/apps/web/src/rpc/wsConnectionState.tsnew file mode 100644index 000000000..5020a1c45--- /dev/null+++ b/apps/web/src/rpc/wsConnectionState.ts@@ -0,0 +1,219 @@+import { useAtomValue } from "@effect/atom-react";+import { Atom } from "effect/unstable/reactivity";++import { appAtomRegistry } from "./atomRegistry";++export type WsConnectionUiState = "connected" | "connecting" | "error" | "offline" | "reconnecting";+export type WsReconnectPhase = "attempting" | "exhausted" | "idle" | "waiting";++export const WS_RECONNECT_INITIAL_DELAY_MS = 1_000;+export const WS_RECONNECT_BACKOFF_FACTOR = 2;+export const WS_RECONNECT_MAX_DELAY_MS = 64_000;+export const WS_RECONNECT_MAX_RETRIES = 7;+export const WS_RECONNECT_MAX_ATTEMPTS = WS_RECONNECT_MAX_RETRIES + 1;++export interface WsConnectionStatus {+ readonly attemptCount: number;+ readonly closeCode: number | null;+ readonly closeReason: string | null;+ readonly connectedAt: string | null;+ readonly disconnectedAt: string | null;+ readonly hasConnected: boolean;+ readonly lastError: string | null;+ readonly lastErrorAt: string | null;+ readonly nextRetryAt: string | null;+ readonly online: boolean;+ readonly phase: "idle" | "connecting" | "connected" | "disconnected";+ readonly reconnectAttemptCount: number;+ readonly reconnectMaxAttempts: number;+ readonly reconnectPhase: WsReconnectPhase;+ readonly socketUrl: string | null;+}++const INITIAL_WS_CONNECTION_STATUS = Object.freeze<WsConnectionStatus>({+ attemptCount: 0,+ closeCode: null,+ closeReason: null,+ connectedAt: null,+ disconnectedAt: null,+ hasConnected: false,+ lastError: null,+ lastErrorAt: null,+ nextRetryAt: null,+ online: typeof navigator === "undefined" ? true : navigator.onLine !== false,+ phase: "idle",+ reconnectAttemptCount: 0,+ reconnectMaxAttempts: WS_RECONNECT_MAX_ATTEMPTS,+ reconnectPhase: "idle",+ socketUrl: null,+});++export const wsConnectionStatusAtom = Atom.make(INITIAL_WS_CONNECTION_STATUS).pipe(+ Atom.keepAlive,+ Atom.withLabel("ws-connection-status"),+);++function isoNow() {+ return new Date().toISOString();+}++function updateWsConnectionStatus(+ updater: (current: WsConnectionStatus) => WsConnectionStatus,+): WsConnectionStatus {+ const nextStatus = updater(getWsConnectionStatus());+ appAtomRegistry.set(wsConnectionStatusAtom, nextStatus);+ return nextStatus;+}++export function getWsConnectionStatus(): WsConnectionStatus {+ return appAtomRegistry.get(wsConnectionStatusAtom);+}++export function getWsConnectionUiState(status: WsConnectionStatus): WsConnectionUiState {+ if (status.phase === "connected") {+ return "connected";+ }++ if (!status.online && (status.disconnectedAt !== null || status.phase === "disconnected")) {+ return "offline";+ }++ if (!status.hasConnected) {+ return status.phase === "disconnected" ? "error" : "connecting";+ }++ return "reconnecting";+}++export function recordWsConnectionAttempt(socketUrl: string): WsConnectionStatus {+ return updateWsConnectionStatus((current) => ({+ ...current,+ attemptCount: current.attemptCount + 1,+ nextRetryAt: null,+ phase: "connecting",+ reconnectAttemptCount: current.phase === "connected" ? 1 : current.reconnectAttemptCount + 1,+ reconnectPhase: "attempting",+ socketUrl,+ }));+}++export function recordWsConnectionOpened(): WsConnectionStatus {+ return updateWsConnectionStatus((current) => ({+ ...current,+ closeCode: null,+ closeReason: null,+ connectedAt: isoNow(),+ disconnectedAt: null,+ hasConnected: true,+ nextRetryAt: null,+ phase: "connected",+ reconnectAttemptCount: 0,+ reconnectPhase: "idle",+ }));+}++export function recordWsConnectionErrored(message?: string | null): WsConnectionStatus {+ return updateWsConnectionStatus((current) =>+ applyDisconnectState(current, {+ lastError: message?.trim() ? message : current.lastError,+ lastErrorAt: isoNow(),+ }),+ );+}++export function recordWsConnectionClosed(details?: {+ readonly code?: number;+ readonly reason?: string;+}): WsConnectionStatus {+ return updateWsConnectionStatus((current) =>+ applyDisconnectState(current, {+ closeCode: details?.code ?? current.closeCode,+ closeReason: details?.reason?.trim() ? details.reason : current.closeReason,+ }),+ );+}++export function setBrowserOnlineStatus(online: boolean): WsConnectionStatus {+ return updateWsConnectionStatus((current) => ({+ ...current,+ online,+ }));+}++export function resetWsReconnectBackoff(): WsConnectionStatus {+ return updateWsConnectionStatus((current) => ({+ ...current,+ nextRetryAt: null,+ reconnectAttemptCount: 0,+ reconnectPhase: "idle",+ }));+}++export function exhaustWsReconnectIfStillWaiting(expectedNextRetryAt: string): WsConnectionStatus {+ return updateWsConnectionStatus((current) => {+ if (+ current.reconnectPhase !== "waiting" ||+ current.nextRetryAt !== expectedNextRetryAt ||+ !current.online ||+ !current.hasConnected+ ) {+ return current;+ }++ return {+ ...current,+ nextRetryAt: null,+ reconnectAttemptCount: current.reconnectMaxAttempts,+ reconnectPhase: "exhausted",+ };+ });+}++export function resetWsConnectionStateForTests(): void {+ appAtomRegistry.set(wsConnectionStatusAtom, INITIAL_WS_CONNECTION_STATUS);+}++export function useWsConnectionStatus(): WsConnectionStatus {+ return useAtomValue(wsConnectionStatusAtom);+}++export function getWsReconnectDelayMsForRetry(retryIndex: number): number | null {+ if (!Number.isInteger(retryIndex) || retryIndex < 0 || retryIndex >= WS_RECONNECT_MAX_RETRIES) {+ return null;+ }++ return Math.min(+ Math.round(WS_RECONNECT_INITIAL_DELAY_MS * WS_RECONNECT_BACKOFF_FACTOR ** retryIndex),+ WS_RECONNECT_MAX_DELAY_MS,+ );+}++function applyDisconnectState(+ current: WsConnectionStatus,+ updates: Partial<+ Pick<WsConnectionStatus, "closeCode" | "closeReason" | "lastError" | "lastErrorAt">+ >,+): WsConnectionStatus {+ const disconnectedAt = current.disconnectedAt ?? isoNow();+ const nextRetryDelayMs =+ current.nextRetryAt !== null || current.reconnectPhase === "exhausted"+ ? null+ : getWsReconnectDelayMsForRetry(Math.max(0, current.reconnectAttemptCount - 1));++ return {+ ...current,+ ...updates,+ disconnectedAt,+ nextRetryAt:+ nextRetryDelayMs === null+ ? current.nextRetryAt+ : new Date(Date.now() + nextRetryDelayMs).toISOString(),+ phase: "disconnected",+ reconnectPhase:+ current.reconnectPhase === "waiting" || current.reconnectPhase === "exhausted"+ ? current.reconnectPhase+ : nextRetryDelayMs === null+ ? "exhausted"+ : "waiting",+ };+}diff --git a/apps/web/src/store.ts b/apps/web/src/store.tsindex 12c709b79..6e768c4ef 100644--- a/apps/web/src/store.ts+++ b/apps/web/src/store.ts@@ -19,6 +19,7 @@ import {derivePendingApprovals,derivePendingUserInputs,} from "./session-logic";+import { sanitizeThreadErrorMessage } from "./rpc/transportError";import { type ChatMessage, type Project, type SidebarThreadSummary, type Thread } from "./types";// ── State ────────────────────────────────────────────────────────────@@ -165,7 +166,7 @@ function mapThread(thread: OrchestrationThread): Thread {session: thread.session ? mapSession(thread.session) : null,messages: thread.messages.map(mapMessage),proposedPlans: thread.proposedPlans.map(mapProposedPlan),- error: thread.session?.lastError ?? null,+ error: sanitizeThreadErrorMessage(thread.session?.lastError),createdAt: thread.createdAt,archivedAt: thread.archivedAt,updatedAt: thread.updatedAt,@@ -894,7 +895,7 @@ export function applyOrchestrationEvent(state: AppState, event: OrchestrationEvereturn updateThreadState(state, event.payload.threadId, (thread) => ({...thread,session: mapSession(event.payload.session),- error: event.payload.session.lastError ?? null,+ error: sanitizeThreadErrorMessage(event.payload.session.lastError),latestTurn:event.payload.session.status === "running" && event.payload.session.activeTurnId !== null? buildLatestTurn({diff --git a/apps/web/src/wsNativeApi.test.ts b/apps/web/src/wsNativeApi.test.tsindex 47f78f967..cfa6ca694 100644--- a/apps/web/src/wsNativeApi.test.ts+++ b/apps/web/src/wsNativeApi.test.ts@@ -243,6 +243,20 @@ describe("wsNativeApi", () => {expect(onDomainEvent).toHaveBeenCalledWith(orchestrationEvent);});+ it("forwards orchestration stream subscription options to the RPC client", async () => {+ const { createWsNativeApi } = await import("./wsNativeApi");++ const api = createWsNativeApi();+ const onDomainEvent = vi.fn();+ const onResubscribe = vi.fn();++ api.orchestration.onDomainEvent(onDomainEvent, { onResubscribe });++ expect(rpcClientMock.orchestration.onDomainEvent).toHaveBeenCalledWith(onDomainEvent, {+ onResubscribe,+ });+ });+it("sends orchestration dispatch commands as the direct RPC payload", async () => {rpcClientMock.orchestration.dispatchCommand.mockResolvedValue({ sequence: 1 });const { createWsNativeApi } = await import("./wsNativeApi");diff --git a/apps/web/src/wsNativeApi.ts b/apps/web/src/wsNativeApi.tsindex 31160dfa1..99045dbf0 100644--- a/apps/web/src/wsNativeApi.ts+++ b/apps/web/src/wsNativeApi.ts@@ -1,7 +1,9 @@import { type ContextMenuItem, type NativeApi } from "@t3tools/contracts";import { showContextMenuFallback } from "./contextMenuFallback";+import { resetRequestLatencyStateForTests } from "./rpc/requestLatencyState";import { resetServerStateForTests } from "./rpc/serverState";+import { resetWsConnectionStateForTests } from "./rpc/wsConnectionState";import { __resetWsRpcClientForTests, getWsRpcClient } from "./wsRpcClient";let instance: { api: NativeApi } | null = null;@@ -9,7 +11,9 @@ let instance: { api: NativeApi } | null = null;export function __resetWsNativeApiForTests() {instance = null;__resetWsRpcClientForTests();+ resetRequestLatencyStateForTests();resetServerStateForTests();+ resetWsConnectionStateForTests();}export function createWsNativeApi(): NativeApi {@@ -98,7 +102,8 @@ export function createWsNativeApi(): NativeApi {rpcClient.orchestration.replayEvents({ fromSequenceExclusive }).then((events) => [...events]),- onDomainEvent: (callback) => rpcClient.orchestration.onDomainEvent(callback),+ onDomainEvent: (callback, options) =>+ rpcClient.orchestration.onDomainEvent(callback, options),},};diff --git a/apps/web/src/wsRpcClient.ts b/apps/web/src/wsRpcClient.tsindex 60f51ba70..1d411aa1b 100644--- a/apps/web/src/wsRpcClient.ts+++ b/apps/web/src/wsRpcClient.ts@@ -10,12 +10,17 @@ import {import { Effect, Stream } from "effect";import { type WsRpcProtocolClient } from "./rpc/protocol";+import { resetWsReconnectBackoff } from "./rpc/wsConnectionState";import { WsTransport } from "./wsTransport";type RpcTag = keyof WsRpcProtocolClient & string;type RpcMethod<TTag extends RpcTag> = WsRpcProtocolClient[TTag];type RpcInput<TTag extends RpcTag> = Parameters<RpcMethod<TTag>>[0];+interface StreamSubscriptionOptions {+ readonly onResubscribe?: () => void;+}+type RpcUnaryMethod<TTag extends RpcTag> =RpcMethod<TTag> extends (input: any, options?: any) => Effect.Effect<infer TSuccess, any, any>? (input: RpcInput<TTag>) => Promise<TSuccess>@@ -28,7 +33,7 @@ type RpcUnaryNoArgMethod<TTag extends RpcTag> =type RpcStreamMethod<TTag extends RpcTag> =RpcMethod<TTag> extends (input: any, options?: any) => Stream.Stream<infer TEvent, any, any>- ? (listener: (event: TEvent) => void) => () => void+ ? (listener: (event: TEvent) => void, options?: StreamSubscriptionOptions) => () => void: never;interface GitRunStackedActionOptions {@@ -37,6 +42,7 @@ interface GitRunStackedActionOptions {export interface WsRpcClient {readonly dispose: () => Promise<void>;+ readonly reconnect: () => Promise<void>;readonly terminal: {readonly open: RpcUnaryMethod<typeof WS_METHODS.terminalOpen>;readonly write: RpcUnaryMethod<typeof WS_METHODS.terminalWrite>;@@ -113,6 +119,10 @@ export async function __resetWsRpcClientForTests() {export function createWsRpcClient(transport = new WsTransport()): WsRpcClient {return {dispose: () => transport.dispose(),+ reconnect: async () => {+ resetWsReconnectBackoff();+ await transport.reconnect();+ },terminal: {open: (input) => transport.request((client) => client[WS_METHODS.terminalOpen](input)),write: (input) => transport.request((client) => client[WS_METHODS.terminalWrite](input)),@@ -120,8 +130,12 @@ export function createWsRpcClient(transport = new WsTransport()): WsRpcClient {clear: (input) => transport.request((client) => client[WS_METHODS.terminalClear](input)),restart: (input) => transport.request((client) => client[WS_METHODS.terminalRestart](input)),close: (input) => transport.request((client) => client[WS_METHODS.terminalClose](input)),- onEvent: (listener) =>- transport.subscribe((client) => client[WS_METHODS.subscribeTerminalEvents]({}), listener),+ onEvent: (listener, options) =>+ transport.subscribe(+ (client) => client[WS_METHODS.subscribeTerminalEvents]({}),+ listener,+ options,+ ),},projects: {searchEntries: (input) =>@@ -179,10 +193,18 @@ export function createWsRpcClient(transport = new WsTransport()): WsRpcClient {getSettings: () => transport.request((client) => client[WS_METHODS.serverGetSettings]({})),updateSettings: (patch) =>transport.request((client) => client[WS_METHODS.serverUpdateSettings]({ patch })),- subscribeConfig: (listener) =>- transport.subscribe((client) => client[WS_METHODS.subscribeServerConfig]({}), listener),- subscribeLifecycle: (listener) =>- transport.subscribe((client) => client[WS_METHODS.subscribeServerLifecycle]({}), listener),+ subscribeConfig: (listener, options) =>+ transport.subscribe(+ (client) => client[WS_METHODS.subscribeServerConfig]({}),+ listener,+ options,+ ),+ subscribeLifecycle: (listener, options) =>+ transport.subscribe(+ (client) => client[WS_METHODS.subscribeServerLifecycle]({}),+ listener,+ options,+ ),},orchestration: {getSnapshot: () =>@@ -197,10 +219,11 @@ export function createWsRpcClient(transport = new WsTransport()): WsRpcClient {transport.request((client) => client[ORCHESTRATION_WS_METHODS.replayEvents](input)).then((events) => [...events]),- onDomainEvent: (listener) =>+ onDomainEvent: (listener, options) =>transport.subscribe((client) => client[WS_METHODS.subscribeOrchestrationDomainEvents]({}),listener,+ options,),},};diff --git a/apps/web/src/wsTransport.test.ts b/apps/web/src/wsTransport.test.tsindex 6f4a5d194..af02a5288 100644--- a/apps/web/src/wsTransport.test.ts+++ b/apps/web/src/wsTransport.test.ts@@ -5,6 +5,12 @@ import {__resetClientTracingForTests,configureClientTracing,} from "./observability/clientTracing";+import { getSlowRpcAckRequests, resetRequestLatencyStateForTests } from "./rpc/requestLatencyState";+import {+ getWsConnectionStatus,+ getWsConnectionUiState,+ resetWsConnectionStateForTests,+} from "./rpc/wsConnectionState";import { WsTransport } from "./wsTransport";type WsEventType = "open" | "message" | "close" | "error";@@ -57,6 +63,10 @@ class MockWebSocket {this.emit("message", { data, type: "message" });}+ error() {+ this.emit("error", { type: "error" });+ }+private emit(type: WsEventType, event?: WsEvent) {const listeners = this.listeners.get(type);if (!listeners) return;@@ -93,7 +103,10 @@ async function waitFor(assertion: () => void, timeoutMs = 1_000): Promise<void>}beforeEach(() => {+ vi.useRealTimers();sockets.length = 0;+ resetRequestLatencyStateForTests();+ resetWsConnectionStateForTests();Object.defineProperty(globalThis, "window", {configurable: true,@@ -107,14 +120,20 @@ beforeEach(() => {desktopBridge: undefined,},});+ Object.defineProperty(globalThis, "navigator", {+ configurable: true,+ value: { onLine: true },+ });globalThis.WebSocket = MockWebSocket as unknown as typeof WebSocket;});-afterEach(() => {+afterEach(async () => {globalThis.WebSocket = originalWebSocket;globalThis.fetch = originalFetch;- void __resetClientTracingForTests();+ resetRequestLatencyStateForTests();+ resetWsConnectionStateForTests();+ await __resetClientTracingForTests();vi.restoreAllMocks();});@@ -148,6 +167,184 @@ describe("WsTransport", () => {await transport.dispose();});+ it("tracks initial connection failures for the app error state", async () => {+ const transport = new WsTransport("ws://localhost:3020");++ await waitFor(() => {+ expect(sockets).toHaveLength(1);+ });++ const socket = getSocket();+ expect(getWsConnectionStatus()).toMatchObject({+ attemptCount: 1,+ phase: "connecting",+ socketUrl: "ws://localhost:3020/ws",+ });++ socket.error();+ socket.close(1006, "server unavailable");++ await waitFor(() => {+ expect(getWsConnectionStatus()).toMatchObject({+ closeCode: 1006,+ closeReason: "server unavailable",+ hasConnected: false,+ lastError: "Unable to connect to the T3 server WebSocket.",+ phase: "disconnected",+ });+ });+ expect(getWsConnectionUiState(getWsConnectionStatus())).toBe("error");++ await transport.dispose();+ });++ it("surfaces reconnecting state after a live socket disconnects", async () => {+ const transport = new WsTransport("ws://localhost:3020");++ await waitFor(() => {+ expect(sockets).toHaveLength(1);+ });++ const socket = getSocket();+ socket.open();++ await waitFor(() => {+ expect(getWsConnectionStatus()).toMatchObject({+ hasConnected: true,+ phase: "connected",+ });+ });++ socket.close(1013, "try again later");++ await waitFor(() => {+ expect(getWsConnectionStatus()).toMatchObject({+ closeReason: "try again later",+ hasConnected: true,+ });+ });+ expect(getWsConnectionUiState(getWsConnectionStatus())).toBe("reconnecting");++ await transport.dispose();+ });++ it("reconnects the websocket session without disposing the transport", async () => {+ const transport = new WsTransport("ws://localhost:3020");++ await waitFor(() => {+ expect(sockets).toHaveLength(1);+ });++ const firstSocket = getSocket();+ firstSocket.open();++ await waitFor(() => {+ expect(getWsConnectionStatus()).toMatchObject({+ hasConnected: true,+ phase: "connected",+ });+ });++ await transport.reconnect();++ await waitFor(() => {+ expect(sockets).toHaveLength(2);+ });++ const secondSocket = getSocket();+ expect(secondSocket).not.toBe(firstSocket);+ expect(firstSocket.readyState).toBe(MockWebSocket.CLOSED);++ const requestPromise = transport.request((client) =>+ client[WS_METHODS.serverUpsertKeybinding]({+ command: "terminal.toggle",+ key: "ctrl+k",+ }),+ );++ secondSocket.open();++ await waitFor(() => {+ expect(secondSocket.sent).toHaveLength(1);+ });++ const requestMessage = JSON.parse(secondSocket.sent[0] ?? "{}") as { id: string };+ secondSocket.serverMessage(+ JSON.stringify({+ _tag: "Exit",+ requestId: requestMessage.id,+ exit: {+ _tag: "Success",+ value: {+ keybindings: [],+ issues: [],+ },+ },+ }),+ );++ await expect(requestPromise).resolves.toEqual({+ keybindings: [],+ issues: [],+ });++ await transport.dispose();+ });++ it("marks unary requests as slow until the first server ack arrives", async () => {+ const transport = new WsTransport("ws://localhost:3020");++ const requestPromise = transport.request((client) =>+ client[WS_METHODS.serverUpsertKeybinding]({+ command: "terminal.toggle",+ key: "ctrl+k",+ }),+ );++ await waitFor(() => {+ expect(sockets).toHaveLength(1);+ });++ const socket = getSocket();+ socket.open();++ await waitFor(() => {+ expect(socket.sent).toHaveLength(1);+ });++ const requestMessage = JSON.parse(socket.sent[0] ?? "{}") as { id: string };+ await waitFor(() => {+ expect(getSlowRpcAckRequests()).toMatchObject([+ {+ requestId: requestMessage.id,+ tag: WS_METHODS.serverUpsertKeybinding,+ },+ ]);+ }, 5_000);++ socket.serverMessage(+ JSON.stringify({+ _tag: "Exit",+ requestId: requestMessage.id,+ exit: {+ _tag: "Success",+ value: {+ keybindings: [],+ issues: [],+ },+ },+ }),+ );++ await expect(requestPromise).resolves.toEqual({+ keybindings: [],+ issues: [],+ });+ expect(getSlowRpcAckRequests()).toEqual([]);++ await transport.dispose();+ }, 10_000);+it("sends unary RPC requests and resolves successful exits", async () => {const transport = new WsTransport("ws://localhost:3020");@@ -257,10 +454,12 @@ describe("WsTransport", () => {it("re-subscribes stream listeners after the stream exits", async () => {const transport = new WsTransport("ws://localhost:3020");const listener = vi.fn();+ const onResubscribe = vi.fn();const unsubscribe = transport.subscribe((client) => client[WS_METHODS.subscribeServerLifecycle]({}),listener,+ { onResubscribe },);await waitFor(() => {expect(sockets).toHaveLength(1);@@ -308,6 +507,7 @@ describe("WsTransport", () => {.find((message) => message._tag === "Request" && message.id !== firstRequest.id);expect(nextRequest).toBeDefined();});+ expect(onResubscribe).toHaveBeenCalledOnce();const secondRequest = socket.sent.map((message) => JSON.parse(message) as { _tag?: string; id?: string; tag?: string })@@ -346,6 +546,52 @@ describe("WsTransport", () => {await transport.dispose();});+ it("does not fire onResubscribe when the first stream attempt exits before any value", async () => {+ const transport = new WsTransport("ws://localhost:3020");+ const listener = vi.fn();+ const onResubscribe = vi.fn();++ const unsubscribe = transport.subscribe(+ (client) => client[WS_METHODS.subscribeServerLifecycle]({}),+ listener,+ { onResubscribe },+ );+ await waitFor(() => {+ expect(sockets).toHaveLength(1);+ });++ const socket = getSocket();+ socket.open();++ await waitFor(() => {+ expect(socket.sent).toHaveLength(1);+ });++ const firstRequest = JSON.parse(socket.sent[0] ?? "{}") as { id: string };+ socket.serverMessage(+ JSON.stringify({+ _tag: "Exit",+ requestId: firstRequest.id,+ exit: {+ _tag: "Success",+ value: null,+ },+ }),+ );++ await waitFor(() => {+ const nextRequest = socket.sent+ .map((message) => JSON.parse(message) as { _tag?: string; id?: string })+ .find((message) => message._tag === "Request" && message.id !== firstRequest.id);+ expect(nextRequest).toBeDefined();+ });+ expect(onResubscribe).not.toHaveBeenCalled();+ expect(listener).not.toHaveBeenCalled();++ unsubscribe();+ await transport.dispose();+ });+it("streams finite request events without re-subscribing", async () => {const transport = new WsTransport("ws://localhost:3020");const listener = vi.fn();@@ -429,11 +675,21 @@ describe("WsTransport", () => {};const transport = {disposed: false,- clientScope: {} as never,- runtime,+ session: {+ clientScope: {} as never,+ runtime,+ },+ closeSession: (+ WsTransport.prototype as unknown as {+ closeSession: (session: {+ clientScope: unknown;+ runtime: { dispose: () => Promise<void>; runPromise: () => Promise<void> };+ }) => Promise<void>;+ }+ ).closeSession,} as unknown as WsTransport;- WsTransport.prototype.dispose.call(transport);+ void WsTransport.prototype.dispose.call(transport);expect(runtime.runPromise).toHaveBeenCalledTimes(1);expect(runtime.dispose).not.toHaveBeenCalled();diff --git a/apps/web/src/wsTransport.ts b/apps/web/src/wsTransport.tsindex ee33c5134..3e435ee16 100644--- a/apps/web/src/wsTransport.ts+++ b/apps/web/src/wsTransport.ts@@ -1,15 +1,26 @@-import { Duration, Effect, Exit, Layer, ManagedRuntime, Option, Scope, Stream } from "effect";+import {+ Cause,+ Duration,+ Effect,+ Exit,+ Layer,+ ManagedRuntime,+ Option,+ Scope,+ Stream,+} from "effect";+import { RpcClient } from "effect/unstable/rpc";+import { ClientTracingLive, configureClientTracing } from "./observability/clientTracing";import {createWsRpcProtocolLayer,makeWsRpcProtocolClient,type WsRpcProtocolClient,} from "./rpc/protocol";-import { RpcClient } from "effect/unstable/rpc";-import { ClientTracingLive, configureClientTracing } from "./observability/clientTracing";interface SubscribeOptions {readonly retryDelay?: Duration.Input;+ readonly onResubscribe?: () => void;}interface RequestOptions {@@ -17,6 +28,13 @@ interface RequestOptions {}const DEFAULT_SUBSCRIPTION_RETRY_DELAY_MS = Duration.millis(250);+const NOOP: () => void = () => undefined;++interface TransportSession {+ readonly clientPromise: Promise<WsRpcProtocolClient>;+ readonly clientScope: Scope.Closeable;+ readonly runtime: ManagedRuntime.ManagedRuntime<RpcClient.Protocol, never>;+}function formatErrorMessage(error: unknown): string {if (error instanceof Error && error.message.trim().length > 0) {@@ -26,21 +44,16 @@ function formatErrorMessage(error: unknown): string {}export class WsTransport {- private readonly runtime: ManagedRuntime.ManagedRuntime<RpcClient.Protocol, never>;- private readonly clientScope: Scope.Closeable;- private readonly clientPromise: Promise<WsRpcProtocolClient>;private readonly tracingReady: Promise<void>;+ private readonly url: string | undefined;private disposed = false;+ private reconnectChain: Promise<void> = Promise.resolve();+ private session: TransportSession;constructor(url?: string) {+ this.url = url;this.tracingReady = configureClientTracing();- this.runtime = ManagedRuntime.make(- Layer.mergeAll(createWsRpcProtocolLayer(url), ClientTracingLive),- );- this.clientScope = this.runtime.runSync(Scope.make());- this.clientPromise = this.runtime.runPromise(- Scope.provide(this.clientScope)(makeWsRpcProtocolClient),- );+ this.session = this.createSession();}async request<TSuccess>(@@ -52,8 +65,9 @@ export class WsTransport {}await this.tracingReady;- const client = await this.clientPromise;- return await this.runtime.runPromise(Effect.suspend(() => execute(client)));+ const session = this.session;+ const client = await session.clientPromise;+ return await session.runtime.runPromise(Effect.suspend(() => execute(client)));}async requestStream<TValue>(@@ -65,8 +79,9 @@ export class WsTransport {}await this.tracingReady;- const client = await this.clientPromise;- await this.runtime.runPromise(+ const session = this.session;+ const client = await session.clientPromise;+ await session.runtime.runPromise(Stream.runForEach(connect(client), (value) =>Effect.sync(() => {try {@@ -89,16 +104,132 @@ export class WsTransport {}let active = true;- const retryDelayMs = options?.retryDelay ?? DEFAULT_SUBSCRIPTION_RETRY_DELAY_MS;- const cancel = this.runtime.runCallback(+ let hasReceivedValue = false;+ const retryDelayMs = Duration.toMillis(+ Duration.fromInputUnsafe(options?.retryDelay ?? DEFAULT_SUBSCRIPTION_RETRY_DELAY_MS),+ );+ let cancelCurrentStream: () => void = NOOP;++ void (async () => {+ for (;;) {+ if (!active || this.disposed) {+ return;+ }++ try {+ if (hasReceivedValue) {+ try {+ options?.onResubscribe?.();+ } catch {+ // Swallow reconnect hook errors so the stream can recover.+ }+ }++ const session = this.session;+ const runningStream = this.runStreamOnSession(+ session,+ connect,+ listener,+ () => active,+ () => {+ hasReceivedValue = true;+ },+ );+ cancelCurrentStream = runningStream.cancel;+ await runningStream.completed;+ cancelCurrentStream = NOOP;+ } catch (error) {+ cancelCurrentStream = NOOP;+ if (!active || this.disposed) {+ return;+ }++ console.warn("WebSocket RPC subscription disconnected", {+ error: formatErrorMessage(error),+ });+ await sleep(retryDelayMs);+ }+ }+ })();++ return () => {+ active = false;+ cancelCurrentStream();+ };+ }++ async reconnect() {+ if (this.disposed) {+ throw new Error("Transport disposed");+ }++ const reconnectOperation = this.reconnectChain.then(async () => {+ if (this.disposed) {+ throw new Error("Transport disposed");+ }++ const previousSession = this.session;+ this.session = this.createSession();+ await this.closeSession(previousSession);+ });++ this.reconnectChain = reconnectOperation.catch(() => undefined);+ await reconnectOperation;+ }++ async dispose() {+ if (this.disposed) {+ return;+ }+ this.disposed = true;+ await this.closeSession(this.session);+ }++ private closeSession(session: TransportSession) {+ return session.runtime.runPromise(Scope.close(session.clientScope, Exit.void)).finally(() => {+ session.runtime.dispose();+ });+ }++ private createSession(): TransportSession {+ const runtime = ManagedRuntime.make(+ Layer.mergeAll(createWsRpcProtocolLayer(this.url), ClientTracingLive),+ );+ const clientScope = runtime.runSync(Scope.make());+ return {+ runtime,+ clientScope,+ clientPromise: runtime.runPromise(Scope.provide(clientScope)(makeWsRpcProtocolClient)),+ };+ }++ private runStreamOnSession<TValue>(+ session: TransportSession,+ connect: (client: WsRpcProtocolClient) => Stream.Stream<TValue, Error, never>,+ listener: (value: TValue) => void,+ isActive: () => boolean,+ markValueReceived: () => void,+ ): {+ readonly cancel: () => void;+ readonly completed: Promise<void>;+ } {+ let resolveCompleted!: () => void;+ let rejectCompleted!: (error: unknown) => void;+ const completed = new Promise<void>((resolve, reject) => {+ resolveCompleted = resolve;+ rejectCompleted = reject;+ });+ const cancel = session.runtime.runCallback(Effect.promise(() => this.tracingReady).pipe(- Effect.flatMap(() => Effect.promise(() => this.clientPromise)),+ Effect.flatMap(() => Effect.promise(() => session.clientPromise)),Effect.flatMap((client) =>Stream.runForEach(connect(client), (value) =>Effect.sync(() => {- if (!active) {+ if (!isActive()) {return;}++ markValueReceived();try {listener(value);} catch {@@ -107,33 +238,28 @@ export class WsTransport {}),),),- Effect.catch((error) => {- if (!active || this.disposed) {- return Effect.interrupt;- }- return Effect.sync(() => {- console.warn("WebSocket RPC subscription disconnected", {- error: formatErrorMessage(error),- });- }).pipe(Effect.andThen(Effect.sleep(retryDelayMs)));- }),- Effect.forever,),+ {+ onExit: (exit) => {+ if (Exit.isSuccess(exit)) {+ resolveCompleted();+ return;+ }++ rejectCompleted(Cause.squash(exit.cause));+ },+ },);- return () => {- active = false;- cancel();+ return {+ cancel,+ completed,};}+}- async dispose() {- if (this.disposed) {- return;- }- this.disposed = true;- await this.runtime.runPromise(Scope.close(this.clientScope, Exit.void)).finally(() => {- this.runtime.dispose();- });- }+function sleep(ms: number): Promise<void> {+ return new Promise((resolve) => {+ setTimeout(resolve, ms);+ });}diff --git a/packages/contracts/src/ipc.ts b/packages/contracts/src/ipc.tsindex 3114f6f5b..57a1c4c3d 100644--- a/packages/contracts/src/ipc.ts+++ b/packages/contracts/src/ipc.ts@@ -180,6 +180,11 @@ export interface NativeApi {input: OrchestrationGetFullThreadDiffInput,) => Promise<OrchestrationGetFullThreadDiffResult>;replayEvents: (fromSequenceExclusive: number) => Promise<OrchestrationEvent[]>;- onDomainEvent: (callback: (event: OrchestrationEvent) => void) => () => void;+ onDomainEvent: (+ callback: (event: OrchestrationEvent) => void,+ options?: {+ onResubscribe?: () => void;+ },+ ) => () => void;};}