@workflow/web-shared 4.0.1-beta.8 → 4.1.0-beta.46

package/dist/api/workflow-api-client.js

@@ -1,15 +1,18 @@
 'use client';
+import { VERCEL_403_ERROR_MESSAGE } from '@workflow/errors';
 import { useCallback, useEffect, useRef, useState } from 'react';
 import { getPaginationDisplay } from '../lib/utils';
-import { cancelRun as cancelRunServerAction, fetchEvents, fetchEventsByCorrelationId, fetchHook, fetchHooks, fetchRun, fetchRuns, fetchStep, fetchSteps, readStreamServerAction, recreateRun as recreateRunServerAction, } from './workflow-server-actions';
+import { hookEventsToHookEntity, waitEventsToWaitEntity, } from '../workflow-traces/trace-span-construction';
+import { cancelRun as cancelRunServerAction, fetchEvents, fetchEventsByCorrelationId, fetchHook, fetchHooks, fetchRun, fetchRuns, fetchStep, fetchSteps, fetchStreams, readStreamServerAction, recreateRun as recreateRunServerAction, reenqueueRun as reenqueueRunServerAction, resumeHook as resumeHookServerAction, wakeUpRun as wakeUpRunServerAction, } from './workflow-server-actions';
 const MAX_ITEMS = 1000;
-const LIVE_POLL_LIMIT = 5;
+const LIVE_POLL_LIMIT = 10;
+const LIVE_STEP_UPDATE_INTERVAL_MS = 2000;
 const LIVE_UPDATE_INTERVAL_MS = 5000;
 /**
- * Helper to convert ServerActionError to WorkflowAPIError
+ * Helper to convert ServerActionError to WorkflowWebAPIError
  */
 function createWorkflowAPIError(serverError) {
-    return new WorkflowAPIError(serverError.message, {
+    return new WorkflowWebAPIError(serverError.message, {
         cause: serverError.cause,
         request: serverError.request,
         layer: serverError.layer,
@@ -17,31 +20,50 @@ function createWorkflowAPIError(serverError) {
 }
 /**
  * Gets a user-facing error message from an error object.
- * Handles both WorkflowAPIError and regular Error instances.
+ * Handles both WorkflowWebAPIError and regular Error instances.
  */
 export const getErrorMessage = (error) => {
     if ('layer' in error && error.layer) {
-        if (error instanceof WorkflowAPIError) {
+        if (error instanceof WorkflowWebAPIError) {
             if (error.request?.status === 403) {
-                return 'Your current Vercel account does not have access to this data. Please use `vercel login` to log in, or use `vercel switch` to ensure you can access the correct team.';
+                return VERCEL_403_ERROR_MESSAGE;
             }
         }
-        // WorkflowAPIError already has user-facing messages
+        // WorkflowWebAPIError already has user-facing messages
         return error.message;
     }
     return error instanceof Error ? error.message : 'An error occurred';
 };
 /**
- * Helper to handle server action results and throw WorkflowAPIError on failure
+ * Helper to handle server action results and throw WorkflowWebAPIError on failure
  */
-function unwrapServerActionResult(result) {
+export async function unwrapServerActionResult(promise) {
+    let result;
+    try {
+        result = await promise;
+    }
+    catch (error) {
+        result = {
+            success: false,
+            error: error,
+        };
+    }
     if (!result.success) {
+        console.error('[web-api-client] error', result.error);
         if (!result.error) {
-            throw new WorkflowAPIError('Unknown error occurred', { layer: 'client' });
-        }
-        throw createWorkflowAPIError(result.error);
+            return {
+                error: new WorkflowWebAPIError('Unknown error occurred', {
+                    layer: 'client',
+                }),
+                result: null,
+            };
+        }
+        return {
+            error: createWorkflowAPIError(result.error),
+            result: null,
+        };
     }
-    return result.data;
+    return { error: null, result: result.data };
 }
 /**
  *  Error instance for API and server-side errors.
@@ -57,12 +79,12 @@ function unwrapServerActionResult(result) {
  *  calling the server action, these fields will be populated:
  *  - `error.layer` will be 'server'
  */
-export class WorkflowAPIError extends Error {
+export class WorkflowWebAPIError extends Error {
     request;
     layer;
     constructor(message, options) {
         super(message, { cause: options?.cause });
-        this.name = 'WorkflowAPIError';
+        this.name = 'WorkflowWebAPIError';
         this.request = options?.request;
         this.layer = options?.layer;
         if (options?.cause instanceof Error) {
@@ -116,42 +138,14 @@ export function useWorkflowRuns(env, params) {
                 return;
             }
         }
-        try {
-            const serverResult = await fetchRuns(env, {
-                cursor: pageCursor,
-                sortOrder,
-                limit: limit,
-                workflowName,
-                status,
-            });
-            const result = unwrapServerActionResult(serverResult);
-            // Cache the result
-            pageCache.current.set(cacheKey, {
-                data: result.data,
-                cursor: result.cursor,
-                hasMore: result.hasMore,
-            });
-            setAllPageResults((prev) => {
-                const newMap = new Map(prev);
-                newMap.set(pageIndex, {
-                    data: result.data,
-                    isLoading: false,
-                    error: null,
-                });
-                return newMap;
-            });
-            setCursor(result.cursor);
-            setHasMore(result.hasMore);
-        }
-        catch (err) {
-            const error = err instanceof WorkflowAPIError
-                ? err
-                : err instanceof Error
-                    ? new WorkflowAPIError(err.message, {
-                        cause: err,
-                        layer: 'client',
-                    })
-                    : new WorkflowAPIError(String(err), { layer: 'client' });
+        const { error, result } = await unwrapServerActionResult(fetchRuns(env, {
+            cursor: pageCursor,
+            sortOrder,
+            limit: limit,
+            workflowName,
+            status,
+        }));
+        if (error) {
             setAllPageResults((prev) => {
                 const newMap = new Map(prev);
                 newMap.set(pageIndex, {
@@ -161,7 +155,25 @@ export function useWorkflowRuns(env, params) {
                 });
                 return newMap;
             });
+            return;
         }
+        // Cache the result
+        pageCache.current.set(cacheKey, {
+            data: result.data,
+            cursor: result.cursor,
+            hasMore: result.hasMore,
+        });
+        setAllPageResults((prev) => {
+            const newMap = new Map(prev);
+            newMap.set(pageIndex, {
+                data: result.data,
+                isLoading: false,
+                error: null,
+            });
+            return newMap;
+        });
+        setCursor(result.cursor);
+        setHasMore(result.hasMore);
     }, [env, workflowName, limit, sortOrder, status]);
     // Initial load
     // biome-ignore lint/correctness/useExhaustiveDependencies: Want to refetch first page on param change
@@ -204,6 +216,16 @@ export function useWorkflowRuns(env, params) {
         // Force fetch first page
         fetchPage(0, undefined, true);
     }, [fetchPage]);
+    const refresh = useCallback(() => {
+        // Refetch current page without resetting state
+        // This preserves the existing data while loading, preventing flicker
+        const currentCursor = pageHistory[currentPage];
+        // Clear cache for current page to ensure fresh data
+        const cacheKey = currentCursor ?? 'initial';
+        pageCache.current.delete(cacheKey);
+        // Force fetch current page
+        fetchPage(currentPage, currentCursor, true);
+    }, [fetchPage, currentPage, pageHistory]);
     const currentPageResult = allPageResults.get(currentPage) ?? {
         data: null,
         isLoading: true,
@@ -219,7 +241,7 @@ export function useWorkflowRuns(env, params) {
     const isOnLastVisitedPage = currentPageNumber === maxPagesVisited;
     const showPlus = isOnLastVisitedPage && hasMore;
     const pageInfo = getPaginationDisplay(currentPageNumber, maxPagesVisited, showPlus);
-    return {
+    const result = {
         data: currentPageResult,
         allData: Array.from(allPageResults.values()),
         error: globalError,
@@ -231,8 +253,10 @@ export function useWorkflowRuns(env, params) {
         hasNextPage: hasMore,
         hasPreviousPage: currentPage > 0,
         reload,
+        refresh,
         pageInfo,
     };
+    return result;
 }
 /**
  * Returns a list of hooks with pagination control
@@ -280,41 +304,13 @@ export function useWorkflowHooks(env, params) {
                 return;
             }
         }
-        try {
-            const serverResult = await fetchHooks(env, {
-                runId,
-                cursor: pageCursor,
-                sortOrder,
-                limit: limit,
-            });
-            const result = unwrapServerActionResult(serverResult);
-            // Cache the result
-            pageCache.current.set(cacheKey, {
-                data: result.data,
-                cursor: result.cursor,
-                hasMore: result.hasMore,
-            });
-            setAllPageResults((prev) => {
-                const newMap = new Map(prev);
-                newMap.set(pageIndex, {
-                    data: result.data,
-                    isLoading: false,
-                    error: null,
-                });
-                return newMap;
-            });
-            setCursor(result.cursor);
-            setHasMore(result.hasMore);
-        }
-        catch (err) {
-            const error = err instanceof WorkflowAPIError
-                ? err
-                : err instanceof Error
-                    ? new WorkflowAPIError(err.message, {
-                        cause: err,
-                        layer: 'client',
-                    })
-                    : new WorkflowAPIError(String(err), { layer: 'client' });
+        const { error, result } = await unwrapServerActionResult(fetchHooks(env, {
+            runId,
+            cursor: pageCursor,
+            sortOrder,
+            limit: limit,
+        }));
+        if (error) {
             setAllPageResults((prev) => {
                 const newMap = new Map(prev);
                 newMap.set(pageIndex, {
@@ -324,7 +320,25 @@ export function useWorkflowHooks(env, params) {
                 });
                 return newMap;
             });
+            return;
         }
+        // Cache the result
+        pageCache.current.set(cacheKey, {
+            data: result.data,
+            cursor: result.cursor,
+            hasMore: result.hasMore,
+        });
+        setAllPageResults((prev) => {
+            const newMap = new Map(prev);
+            newMap.set(pageIndex, {
+                data: result.data,
+                isLoading: false,
+                error: null,
+            });
+            return newMap;
+        });
+        setCursor(result.cursor);
+        setHasMore(result.hasMore);
     }, [env, runId, limit, sortOrder]);
     // Initial load
     useEffect(() => {
@@ -366,6 +380,16 @@ export function useWorkflowHooks(env, params) {
         // Force fetch first page
         fetchPage(0, undefined, true);
     }, [fetchPage]);
+    const refresh = useCallback(() => {
+        // Refetch current page without resetting state
+        // This preserves the existing data while loading, preventing flicker
+        const currentCursor = pageHistory[currentPage];
+        // Clear cache for current page to ensure fresh data
+        const cacheKey = currentCursor ?? 'initial';
+        pageCache.current.delete(cacheKey);
+        // Force fetch current page
+        fetchPage(currentPage, currentCursor, true);
+    }, [fetchPage, currentPage, pageHistory]);
     const currentPageResult = allPageResults.get(currentPage) ?? {
         data: null,
         isLoading: true,
@@ -393,6 +417,7 @@ export function useWorkflowHooks(env, params) {
         hasNextPage: hasMore,
         hasPreviousPage: currentPage > 0,
         reload,
+        refresh,
         pageInfo,
     };
 }
@@ -401,12 +426,15 @@ async function fetchAllSteps(env, runId) {
     let stepsData = [];
     let stepsCursor;
     while (true) {
-        const serverResult = await fetchSteps(env, runId, {
+        const { error, result } = await unwrapServerActionResult(fetchSteps(env, runId, {
             cursor: stepsCursor,
             sortOrder: 'asc',
             limit: 100,
-        });
-        const result = unwrapServerActionResult(serverResult);
+        }));
+        // TODO: We're not handling errors well for infinite fetches
+        if (error) {
+            break;
+        }
         stepsData = [...stepsData, ...result.data];
         if (!result.hasMore || !result.cursor || stepsData.length >= MAX_ITEMS) {
             break;
@@ -420,13 +448,15 @@ async function fetchAllHooks(env, runId) {
     let hooksData = [];
     let hooksCursor;
     while (true) {
-        const serverResult = await fetchHooks(env, {
+        const { error, result } = await unwrapServerActionResult(fetchHooks(env, {
             runId,
             cursor: hooksCursor,
             sortOrder: 'asc',
             limit: 100,
-        });
-        const result = unwrapServerActionResult(serverResult);
+        }));
+        if (error) {
+            break;
+        }
         hooksData = [...hooksData, ...result.data];
         if (!result.hasMore || !result.cursor || hooksData.length >= MAX_ITEMS) {
             break;
@@ -440,12 +470,14 @@ async function fetchAllEvents(env, runId) {
     let eventsData = [];
     let eventsCursor;
     while (true) {
-        const serverResult = await fetchEvents(env, runId, {
+        const { error, result } = await unwrapServerActionResult(fetchEvents(env, runId, {
             cursor: eventsCursor,
             sortOrder: 'asc',
             limit: 1000,
-        });
-        const result = unwrapServerActionResult(serverResult);
+        }));
+        if (error) {
+            break;
+        }
         eventsData = [...eventsData, ...result.data];
         if (!result.hasMore || !result.cursor || eventsData.length >= MAX_ITEMS) {
             break;
@@ -465,6 +497,7 @@ export function useWorkflowTraceViewerData(env, runId, options = {}) {
     const [hooks, setHooks] = useState([]);
     const [events, setEvents] = useState([]);
     const [loading, setLoading] = useState(true);
+    const [auxiliaryDataLoading, setAuxiliaryDataLoading] = useState(false);
     const [error, setError] = useState(null);
     const [stepsCursor, setStepsCursor] = useState();
     const [hooksCursor, setHooksCursor] = useState();
@@ -478,38 +511,41 @@ export function useWorkflowTraceViewerData(env, runId, options = {}) {
         }
         isFetchingRef.current = true;
         setLoading(true);
+        setAuxiliaryDataLoading(true);
         setError(null);
-        try {
-            // Fetch run
-            const runServerResult = await fetchRun(env, runId);
-            const runData = unwrapServerActionResult(runServerResult);
-            setRun(runData);
-            // TODO: Do these in parallel
-            // Fetch steps exhaustively
-            const stepsResult = await fetchAllSteps(env, runId);
-            setSteps(stepsResult.data);
-            setStepsCursor(stepsResult.cursor);
-            // Fetch hooks exhaustively
-            const hooksResult = await fetchAllHooks(env, runId);
-            setHooks(hooksResult.data);
-            setHooksCursor(hooksResult.cursor);
-            // Fetch events exhaustively
-            const eventsResult = await fetchAllEvents(env, runId);
-            setEvents(eventsResult.data);
-            setEventsCursor(eventsResult.cursor);
-        }
-        catch (err) {
-            const error = err instanceof WorkflowAPIError
-                ? err
-                : err instanceof Error
-                    ? new WorkflowAPIError(err.message, { cause: err, layer: 'client' })
-                    : new WorkflowAPIError(String(err), { layer: 'client' });
+        const promises = [
+            unwrapServerActionResult(fetchRun(env, runId)).then(({ error, result }) => {
+                if (error) {
+                    setError(error);
+                    return;
+                }
+                setRun(result);
+                return result;
+            }),
+            fetchAllSteps(env, runId).then((result) => {
+                setSteps(result.data);
+                setStepsCursor(result.cursor);
+            }),
+            fetchAllHooks(env, runId).then((result) => {
+                setHooks(result.data);
+                setHooksCursor(result.cursor);
+            }),
+            fetchAllEvents(env, runId).then((result) => {
+                setEvents(result.data);
+                setEventsCursor(result.cursor);
+            }),
+        ];
+        const results = await Promise.allSettled(promises);
+        setLoading(false);
+        setAuxiliaryDataLoading(false);
+        setInitialLoadCompleted(true);
+        isFetchingRef.current = false;
+        // Just doing the first error, but would be nice to show multiple
+        const error = results.find((result) => result.status === 'rejected')
+            ?.reason;
+        if (error) {
             setError(error);
-        }
-        finally {
-            setLoading(false);
-            isFetchingRef.current = false;
-            setInitialLoadCompleted(true);
+            return;
         }
     }, [env, runId]);
     // Helper to merge steps by ID
@@ -534,22 +570,31 @@ export function useWorkflowTraceViewerData(env, runId, options = {}) {
         if (run?.completedAt) {
             return false;
         }
-        const serverResult = await fetchRun(env, runId);
-        const result = unwrapServerActionResult(serverResult);
+        const { error, result } = await unwrapServerActionResult(fetchRun(env, runId));
+        if (error) {
+            setError(error);
+            return false;
+        }
         setRun(result);
         return true;
     }, [env, runId, run?.completedAt]);
     // Poll for new steps
     const pollSteps = useCallback(async () => {
-        const serverResult = await fetchSteps(env, runId, {
+        const { error, result } = await unwrapServerActionResult(fetchSteps(env, runId, {
             cursor: stepsCursor,
             sortOrder: 'asc',
             limit: LIVE_POLL_LIMIT,
-        });
-        const result = unwrapServerActionResult(serverResult);
+        }));
+        if (error) {
+            setError(error);
+            return false;
+        }
         if (result.data.length > 0) {
             setSteps((prev) => mergeSteps(prev, result.data));
-            if (result.cursor) {
+            // We intentionally leave the cursor where it is, unless we're at the end of the page
+            // in which case we roll over. This is so that we re-fetch existing steps, to ensure
+            // their status gets updated.
+            if (result.cursor && result.hasMore) {
                 setStepsCursor(result.cursor);
             }
             return true;
@@ -558,13 +603,16 @@ export function useWorkflowTraceViewerData(env, runId, options = {}) {
     }, [env, runId, stepsCursor, mergeSteps]);
     // Poll for new hooks
     const pollHooks = useCallback(async () => {
-        const serverResult = await fetchHooks(env, {
+        const { error, result } = await unwrapServerActionResult(fetchHooks(env, {
             runId,
             cursor: hooksCursor,
             sortOrder: 'asc',
             limit: LIVE_POLL_LIMIT,
-        });
-        const result = unwrapServerActionResult(serverResult);
+        }));
+        if (error) {
+            setError(error);
+            return false;
+        }
         if (result.data.length > 0) {
             setHooks((prev) => mergeHooks(prev, result.data));
             if (result.cursor) {
@@ -576,12 +624,15 @@ export function useWorkflowTraceViewerData(env, runId, options = {}) {
     }, [env, runId, hooksCursor, mergeHooks]);
     // Poll for new events
     const pollEvents = useCallback(async () => {
-        const serverResult = await fetchEvents(env, runId, {
+        const { error, result } = await unwrapServerActionResult(fetchEvents(env, runId, {
             cursor: eventsCursor,
             sortOrder: 'asc',
             limit: LIVE_POLL_LIMIT,
-        });
-        const result = unwrapServerActionResult(serverResult);
+        }));
+        if (error) {
+            setError(error);
+            return false;
+        }
         if (result.data.length > 0) {
             setEvents((prev) => mergeEvents(prev, result.data));
             if (result.cursor) {
@@ -592,17 +643,17 @@ export function useWorkflowTraceViewerData(env, runId, options = {}) {
         return false;
     }, [env, runId, eventsCursor, mergeEvents]);
     // Update function for live polling
-    const update = useCallback(async () => {
+    const update = useCallback(async (stepsOnly = false) => {
         if (isFetchingRef.current || !initialLoadCompleted) {
             return { foundNewItems: false };
         }
         let foundNewItems = false;
         try {
             const [_, stepsUpdated, hooksUpdated, eventsUpdated] = await Promise.all([
-                pollRun(),
+                stepsOnly ? Promise.resolve(false) : pollRun(),
                 pollSteps(),
-                pollHooks(),
-                pollEvents(),
+                stepsOnly ? Promise.resolve(false) : pollHooks(),
+                stepsOnly ? Promise.resolve(false) : pollEvents(),
             ]);
             foundNewItems = stepsUpdated || hooksUpdated || eventsUpdated;
         }
@@ -623,7 +674,13 @@ export function useWorkflowTraceViewerData(env, runId, options = {}) {
         const interval = setInterval(() => {
             update();
         }, LIVE_UPDATE_INTERVAL_MS);
-        return () => clearInterval(interval);
+        const stepInterval = setInterval(() => {
+            update(true);
+        }, LIVE_STEP_UPDATE_INTERVAL_MS);
+        return () => {
+            clearInterval(interval);
+            clearInterval(stepInterval);
+        };
     }, [live, initialLoadCompleted, update, run?.completedAt]);
     return {
         run: run ?? {},
@@ -631,6 +688,7 @@ export function useWorkflowTraceViewerData(env, runId, options = {}) {
         hooks,
         events,
         loading,
+        auxiliaryDataLoading,
         error,
         update,
     };
@@ -641,28 +699,37 @@ async function fetchResourceWithCorrelationId(env, resource, resourceId, options
     let correlationId;
     const resolveData = options.resolveData ?? 'all';
     if (resource === 'run') {
-        const serverResult = await fetchRun(env, resourceId, resolveData);
-        resourceData = unwrapServerActionResult(serverResult);
+        const { error, result } = await unwrapServerActionResult(fetchRun(env, resourceId, resolveData));
+        if (error) {
+            throw error;
+        }
+        resourceData = result;
         correlationId = resourceData.runId;
     }
     else if (resource === 'step') {
         const { runId } = options;
         if (!runId) {
-            throw new WorkflowAPIError('runId is required for step resource', {
+            throw new WorkflowWebAPIError('runId is required for step resource', {
                 layer: 'client',
             });
         }
-        const serverResult = await fetchStep(env, runId, resourceId, resolveData);
-        resourceData = unwrapServerActionResult(serverResult);
+        const { error, result } = await unwrapServerActionResult(fetchStep(env, runId, resourceId, resolveData));
+        if (error) {
+            throw error;
+        }
+        resourceData = result;
         correlationId = resourceData.stepId;
     }
     else if (resource === 'hook') {
-        const serverResult = await fetchHook(env, resourceId, resolveData);
-        resourceData = unwrapServerActionResult(serverResult);
+        const { error, result } = await unwrapServerActionResult(fetchHook(env, resourceId, resolveData));
+        if (error) {
+            throw error;
+        }
+        resourceData = result;
         correlationId = resourceData.hookId;
     }
     else {
-        throw new WorkflowAPIError(`Unknown resource type: ${resource}`, {
+        throw new WorkflowWebAPIError(`Unknown resource type: ${resource}`, {
             layer: 'client',
         });
     }
@@ -679,55 +746,55 @@ export function useWorkflowResourceData(env, resource, resourceId, options = {})
     const [loading, setLoading] = useState(true);
     const [error, setError] = useState(null);
     const fetchData = useCallback(async () => {
-        setLoading(true);
         setData(null);
         setError(null);
-        try {
-            if (resource === 'sleep') {
-                const events = await fetchEventsByCorrelationId(env, resourceId, {
-                    sortOrder: 'asc',
-                    limit: 100,
-                    withData: true,
-                });
-                const eventsData = unwrapServerActionResult(events);
-                const waitStartEvent = eventsData.data.find((event) => event.eventType === 'wait_created');
-                if (waitStartEvent) {
-                    setData({
-                        waitId: waitStartEvent.correlationId,
-                        runId: waitStartEvent.runId,
-                        createdAt: waitStartEvent.createdAt,
-                        resumeAt: waitStartEvent.eventData.resumeAt,
-                    });
-                }
+        if (resource === 'hook' || resource === 'sleep') {
+            const { error, result } = await unwrapServerActionResult(fetchEventsByCorrelationId(env, resourceId, {
+                sortOrder: 'asc',
+                limit: 100,
+                withData: true,
+            }));
+            if (error) {
+                setError(error);
+                return;
+            }
+            const events = result.data;
+            const data = resource === 'hook'
+                ? hookEventsToHookEntity(events)
+                : waitEventsToWaitEntity(events);
+            if (data === null) {
+                setError(new Error(`Failed to load ${resource} details: missing required event data`));
                 return;
             }
-            // Fetch resource with full data
+            setData(data);
+            return;
+        }
+        setLoading(true);
+        // Fetch resource with full data
+        try {
             const { data: resourceData } = await fetchResourceWithCorrelationId(env, resource, resourceId, {
                 runId,
             });
             setData(resourceData);
-            if (resource === 'run') {
-                setLoading(false);
-                return;
-            }
-            // // Fetch events by correlation ID
-            // const eventsData = await fetchAllEventsByCorrelationId(
-            //   env,
-            //   correlationId
-            // );
-            // setEvents(eventsData);
         }
-        catch (err) {
-            const error = err instanceof WorkflowAPIError
-                ? err
-                : err instanceof Error
-                    ? new WorkflowAPIError(err.message, { cause: err, layer: 'client' })
-                    : new WorkflowAPIError(String(err), { layer: 'client' });
-            setError(error);
+        catch (error) {
+            if (error instanceof Error) {
+                setError(error);
+            }
+            else {
+                setError(new Error(String(error)));
+            }
+            return;
         }
         finally {
             setLoading(false);
         }
+        // // Fetch events by correlation ID
+        // const eventsData = await fetchAllEventsByCorrelationId(
+        //   env,
+        //   correlationId
+        // );
+        // setEvents(eventsData);
     }, [env, resource, resourceId, runId]);
     // Initial load
     useEffect(() => {
@@ -753,45 +820,134 @@ export function useWorkflowResourceData(env, resource, resourceId, options = {})
  * Cancel a workflow run
  */
 export async function cancelRun(env, runId) {
-    try {
-        const result = await cancelRunServerAction(env, runId);
-        unwrapServerActionResult(result);
-    }
-    catch (err) {
-        console.error('Error canceling run:', err);
-        if (err instanceof WorkflowAPIError) {
-            throw err;
-        }
-        throw new WorkflowAPIError(err instanceof Error ? err.message : 'Failed to cancel run', { cause: err, layer: 'client' });
+    const { error } = await unwrapServerActionResult(cancelRunServerAction(env, runId));
+    if (error) {
+        throw error;
     }
 }
 /**
  * Start a new workflow run
  */
 export async function recreateRun(env, runId) {
-    try {
-        const result = await recreateRunServerAction(env, runId);
-        return unwrapServerActionResult(result);
+    const { error, result: resultData } = await unwrapServerActionResult(recreateRunServerAction(env, runId));
+    if (error) {
+        throw error;
     }
-    catch (err) {
-        console.error('Error starting run:', err);
-        if (err instanceof WorkflowAPIError) {
-            throw err;
-        }
-        throw new WorkflowAPIError(err instanceof Error ? err.message : 'Failed to start run', { cause: err, layer: 'client' });
+    return resultData;
+}
+/**
+ * Wake up a workflow run by re-enqueuing it
+ */
+export async function reenqueueRun(env, runId) {
+    const { error } = await unwrapServerActionResult(reenqueueRunServerAction(env, runId));
+    if (error) {
+        throw error;
     }
 }
+/**
+ * Wake up a workflow run by interrupting any pending sleep() calls
+ */
+export async function wakeUpRun(env, runId, options) {
+    const { error, result: resultData } = await unwrapServerActionResult(wakeUpRunServerAction(env, runId, options));
+    if (error) {
+        throw error;
+    }
+    return resultData;
+}
+/**
+ * Resume a hook by sending a JSON payload
+ */
+export async function resumeHook(env, token, payload) {
+    const { error, result: resultData } = await unwrapServerActionResult(resumeHookServerAction(env, token, payload));
+    if (error) {
+        throw error;
+    }
+    return resultData;
+}
+function isServerActionError(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        'message' in value &&
+        'layer' in value &&
+        'cause' in value &&
+        'request' in value);
+}
 export async function readStream(env, streamId, startIndex) {
     try {
-        const result = await readStreamServerAction(env, streamId, startIndex);
-        return unwrapServerActionResult(result);
+        const stream = await readStreamServerAction(env, streamId, startIndex);
+        if (!stream) {
+            throw new WorkflowWebAPIError('Failed to read stream', {
+                layer: 'client',
+            });
+        }
+        if (isServerActionError(stream)) {
+            throw new WorkflowWebAPIError(stream.message, {
+                layer: 'client',
+                cause: stream.cause,
+                request: stream.request,
+            });
+        }
+        return stream;
     }
-    catch (err) {
-        console.error('Error reading stream:', err);
-        if (err instanceof WorkflowAPIError) {
-            throw err;
+    catch (error) {
+        if (error instanceof WorkflowWebAPIError) {
+            throw error;
         }
-        throw new WorkflowAPIError(err instanceof Error ? err.message : 'Failed to read stream', { cause: err, layer: 'client' });
+        throw new WorkflowWebAPIError('Failed to read stream', {
+            layer: 'client',
+            cause: error,
+        });
+    }
+}
+/**
+ * List all stream IDs for a run
+ */
+export async function listStreams(env, runId) {
+    const { error, result } = await unwrapServerActionResult(fetchStreams(env, runId));
+    if (error) {
+        throw error;
     }
+    return result;
+}
+const STREAMS_REFRESH_INTERVAL_MS = 10000;
+/**
+ * Hook to fetch and manage stream list for a run
+ */
+export function useWorkflowStreams(env, runId, refreshInterval = STREAMS_REFRESH_INTERVAL_MS) {
+    const [streams, setStreams] = useState([]);
+    const [loading, setLoading] = useState(true);
+    const [error, setError] = useState(null);
+    const fetchData = useCallback(async () => {
+        setLoading(true);
+        setError(null);
+        try {
+            const result = await listStreams(env, runId);
+            setStreams(result);
+        }
+        catch (err) {
+            setError(err instanceof Error ? err : new Error(String(err)));
+        }
+        finally {
+            setLoading(false);
+        }
+    }, [env, runId]);
+    // Initial load
+    useEffect(() => {
+        fetchData();
+    }, [fetchData]);
+    // Auto-refresh interval
+    useEffect(() => {
+        if (!refreshInterval || refreshInterval <= 0) {
+            return;
+        }
+        const interval = setInterval(fetchData, refreshInterval);
+        return () => clearInterval(interval);
+    }, [refreshInterval, fetchData]);
+    return {
+        streams,
+        loading,
+        error,
+        refresh: fetchData,
+    };
 }
 //# sourceMappingURL=workflow-api-client.js.map