orcheo-studio 0.21.1

package/src/features/workflow/pages/workflow/helpers/types.ts

@@ -0,0 +1,28 @@
+import type {
+  WorkflowExecution as SharedWorkflowExecution,
+  WorkflowExecutionNode as SharedWorkflowExecutionNode,
+  WorkflowExecutionNodeStatus as SharedWorkflowExecutionNodeStatus,
+  WorkflowExecutionStatus as SharedWorkflowExecutionStatus,
+} from "@features/workflow/lib/workflow-execution.types";
+
+export type WorkflowExecutionStatus = SharedWorkflowExecutionStatus;
+export type NodeStatus = SharedWorkflowExecutionNodeStatus;
+export type WorkflowExecutionNode = SharedWorkflowExecutionNode;
+export type WorkflowExecution = SharedWorkflowExecution;
+
+export interface RunHistoryStep {
+  index: number;
+  at: string;
+  payload: Record<string, unknown>;
+}
+
+export interface RunHistoryResponse {
+  execution_id: string;
+  workflow_id: string;
+  status: string;
+  started_at: string;
+  completed_at?: string | null;
+  error?: string | null;
+  inputs?: Record<string, unknown>;
+  steps: RunHistoryStep[];
+}

package/src/features/workflow/pages/workflow/hooks/controller/build-layout-props.ts

@@ -0,0 +1,171 @@
+import type { SettingsTabContentProps } from "@features/workflow/pages/workflow/components/settings-tab-content";
+import type { TraceTabContentProps } from "@features/workflow/pages/workflow/components/trace-tab-content";
+import type { WorkflowTabContentProps } from "@features/workflow/pages/workflow/components/workflow-tab-content";
+import type {
+  ChatKitStartScreenPrompt,
+  ChatKitSupportedModel,
+  WorkflowVersionRecord,
+} from "@features/workflow/lib/workflow-storage.types";
+import type { WorkflowCore } from "./use-workflow-core";
+import type { WorkflowResources } from "./use-workflow-resources";
+import type { WorkflowExecutionController } from "./use-workflow-execution-controller";
+
+export const hasSchedulableCronTrigger = (
+  versions: WorkflowVersionRecord[],
+): boolean => {
+  const latestVersion = versions.reduce<WorkflowVersionRecord | undefined>(
+    (latest, current) =>
+      !latest || current.versionNumber > latest.versionNumber
+        ? current
+        : latest,
+    undefined,
+  );
+
+  return latestVersion?.hasCronTrigger === true;
+};
+
+export interface WorkflowLayoutProps {
+  topNavigationProps: {
+    currentWorkflow: {
+      name: string;
+      onNameChange?: (name: string) => void;
+    };
+    credentials: WorkflowResources["credentials"]["credentials"];
+    isCredentialsLoading: boolean;
+    onAddCredential: WorkflowResources["credentials"]["handleAddCredential"];
+    onUpdateCredential: WorkflowResources["credentials"]["handleUpdateCredential"];
+    onDeleteCredential: WorkflowResources["credentials"]["handleDeleteCredential"];
+    onRevealCredentialSecret: WorkflowResources["credentials"]["handleRevealCredentialSecret"];
+  };
+  tabsProps: {
+    activeTab: string;
+    onTabChange: (value: string) => void;
+  };
+  workflowProps: WorkflowTabContentProps;
+  traceProps: TraceTabContentProps;
+  settingsProps: SettingsTabContentProps;
+  chat: {
+    isChatOpen: boolean;
+    chatTitle: string;
+    user: { id: string; name: string; avatar: string };
+    ai: { id: string; name: string; avatar: string };
+    activeChatNodeId: string | null;
+    workflowId: string | null;
+    chatkitWorkflowId: string | null;
+    backendBaseUrl: string | null;
+    startScreenPrompts: ChatKitStartScreenPrompt[] | null;
+    supportedModels: ChatKitSupportedModel[] | null;
+    handleChatResponseStart: () => void;
+    handleChatResponseEnd: () => void;
+    handleChatClientTool: (tool: {
+      name: string;
+      params: Record<string, unknown>;
+    }) => Promise<Record<string, unknown>>;
+    getClientSecret: (currentSecret: string | null) => Promise<string>;
+    refreshSession: () => Promise<string>;
+    sessionStatus: "idle" | "loading" | "ready" | "error";
+    sessionError: string | null;
+    handleCloseChat: () => void;
+    setIsChatOpen: (open: boolean) => void;
+  } | null;
+}
+
+export function buildWorkflowLayoutProps(
+  core: WorkflowCore,
+  resources: WorkflowResources,
+  execution: WorkflowExecutionController,
+): WorkflowLayoutProps {
+  const workflowProps: WorkflowTabContentProps = {
+    workflowId: core.metadata.currentWorkflowId,
+    workflowRouteRef: core.routeWorkflowRef,
+    workflowName: core.metadata.workflowName,
+    versions: core.metadata.workflowVersions ?? [],
+    isLoading: core.metadata.isWorkflowLoading,
+    loadError: core.metadata.workflowLoadError,
+    isRunPending: execution.isRunPending,
+    onRunWorkflow: execution.handleRunPersistedWorkflow,
+    onSaveConfig: resources.saver.handleSaveWorkflowConfig,
+    hasCronTriggerNode: hasSchedulableCronTrigger(
+      core.metadata.workflowVersions ?? [],
+    ),
+    initialIsPublished: core.metadata.isWorkflowPublic,
+    initialShareUrl: core.metadata.workflowShareUrl,
+    missingCredentials: resources.credentialReadiness.missingCredentials,
+  };
+
+  const traceProps: TraceTabContentProps = {
+    error: execution.trace.error,
+    viewerData: execution.trace.viewerData,
+    activeViewer: execution.trace.activeTraceViewer,
+    onRefresh: () => execution.trace.refresh(),
+    isRefreshing: execution.trace.isRefreshing,
+    onSelectTrace: (traceId) => core.execution.setActiveExecutionId(traceId),
+  };
+
+  const settingsProps: SettingsTabContentProps = {
+    workflowId: core.metadata.currentWorkflowId,
+    workflowName: core.metadata.workflowName,
+    workflowDescription: core.metadata.workflowDescription,
+    workflowTags: core.metadata.workflowTags,
+    missingCredentials: resources.credentialReadiness.missingCredentials,
+    onWorkflowNameChange: core.metadata.setWorkflowName,
+    onWorkflowDescriptionChange: core.metadata.setWorkflowDescription,
+    onTagsChange: resources.saver.handleTagsChange,
+    onSaveWorkflowDetails: resources.saver.handleSaveWorkflowDetails,
+    isSavingWorkflowDetails: resources.saver.isSavingWorkflowDetails,
+    workflowVersions: core.metadata.workflowVersions ?? [],
+    onRestoreVersion: resources.saver.handleRestoreVersion,
+    listeners: resources.listeners.listeners,
+    listenerMetrics: resources.listeners.metrics,
+    isListenersLoading: resources.listeners.isLoading,
+    isListenersRefreshing: resources.listeners.isRefreshing,
+    activeListenerSubscriptionId: resources.listeners.activeSubscriptionId,
+    onRefreshListeners: resources.listeners.refreshListeners,
+    onPauseListener: resources.listeners.pauseListener,
+    onResumeListener: resources.listeners.resumeListener,
+  };
+
+  return {
+    topNavigationProps: {
+      currentWorkflow: {
+        name: core.metadata.workflowName,
+        onNameChange: core.metadata.setWorkflowName,
+      },
+      credentials: resources.credentials.credentials,
+      isCredentialsLoading: resources.credentials.isCredentialsLoading,
+      onAddCredential: resources.credentials.handleAddCredential,
+      onUpdateCredential: resources.credentials.handleUpdateCredential,
+      onDeleteCredential: resources.credentials.handleDeleteCredential,
+      onRevealCredentialSecret:
+        resources.credentials.handleRevealCredentialSecret,
+    },
+    tabsProps: {
+      activeTab: core.ui.activeTab,
+      onTabChange: core.ui.setActiveTab,
+    },
+    workflowProps,
+    traceProps,
+    settingsProps,
+    chat: {
+      isChatOpen: core.chat.isChatOpen,
+      chatTitle: core.chat.chatTitle,
+      user: core.user,
+      ai: core.ai,
+      activeChatNodeId: core.chat.activeChatNodeId,
+      workflowId: core.chat.workflowId,
+      chatkitWorkflowId: core.metadata.currentWorkflowId,
+      backendBaseUrl: core.chat.backendBaseUrl,
+      startScreenPrompts: core.metadata.chatkitStartScreenPrompts,
+      supportedModels: core.metadata.chatkitSupportedModels,
+      handleChatResponseStart: core.chat.handleChatResponseStart,
+      handleChatResponseEnd: core.chat.handleChatResponseEnd,
+      handleChatClientTool: core.chat.handleChatClientTool,
+      getClientSecret: core.chat.getClientSecret,
+      refreshSession: core.chat.refreshSession,
+      sessionStatus: core.chat.sessionStatus,
+      sessionError: core.chat.sessionError,
+      handleCloseChat: core.chat.handleCloseChat,
+      setIsChatOpen: core.chat.setIsChatOpen,
+    },
+  };
+}

package/src/features/workflow/pages/workflow/hooks/controller/use-workflow-controller.ts

@@ -0,0 +1,19 @@
+import { useWorkflowCore } from "./use-workflow-core";
+import { useWorkflowResources } from "./use-workflow-resources";
+import { useWorkflowExecutionController } from "./use-workflow-execution-controller";
+import { useWorkflowLifecycle } from "./use-workflow-lifecycle";
+import { buildWorkflowLayoutProps } from "./build-layout-props";
+
+export function useWorkflowController(
+  workflowId?: string,
+  workflowRouteRef?: string | null,
+) {
+  const core = useWorkflowCore({ workflowId, workflowRouteRef });
+  const resources = useWorkflowResources(core, workflowId);
+  const execution = useWorkflowExecutionController(core);
+  useWorkflowLifecycle(core, workflowId);
+
+  const layoutProps = buildWorkflowLayoutProps(core, resources, execution);
+
+  return { layoutProps };
+}

package/src/features/workflow/pages/workflow/hooks/controller/use-workflow-core.ts

@@ -0,0 +1,84 @@
+import { useEffect, useMemo, useRef } from "react";
+
+import { getBackendBaseUrl } from "@/lib/config";
+import { useWorkflowChat } from "@features/workflow/pages/workflow/hooks/use-workflow-chat";
+import { useWorkflowMetadataState } from "@features/workflow/pages/workflow/hooks/use-workflow-metadata-state";
+import { useWorkflowExecutionState } from "@features/workflow/pages/workflow/hooks/use-workflow-execution-state";
+import { useStudioUiState } from "@features/workflow/pages/workflow/hooks/use-studio-ui-state";
+
+export interface WorkflowCore {
+  routeWorkflowId: string | null;
+  routeWorkflowRef: string | null;
+  metadata: ReturnType<typeof useWorkflowMetadataState>;
+  execution: ReturnType<typeof useWorkflowExecutionState>;
+  ui: ReturnType<typeof useStudioUiState>;
+  websocketRef: React.MutableRefObject<WebSocket | null>;
+  isMountedRef: React.MutableRefObject<boolean>;
+  chat: ReturnType<typeof useWorkflowChat>;
+  user: { id: string; name: string; avatar: string };
+  ai: { id: string; name: string; avatar: string };
+}
+
+interface UseWorkflowCoreArgs {
+  workflowId?: string;
+  workflowRouteRef?: string | null;
+}
+
+export function useWorkflowCore({
+  workflowId,
+  workflowRouteRef,
+}: UseWorkflowCoreArgs): WorkflowCore {
+  const metadata = useWorkflowMetadataState();
+  const execution = useWorkflowExecutionState();
+  const ui = useStudioUiState();
+
+  const websocketRef = useRef<WebSocket | null>(null);
+  const isMountedRef = useRef(true);
+
+  useEffect(() => {
+    isMountedRef.current = true;
+    return () => {
+      isMountedRef.current = false;
+      if (websocketRef.current) {
+        websocketRef.current.close();
+        websocketRef.current = null;
+      }
+    };
+  }, []);
+
+  const user = useMemo(
+    () => ({
+      id: "user-1",
+      name: "Avery Chen",
+      avatar: "https://avatar.vercel.sh/avery",
+    }),
+    [],
+  );
+  const ai = useMemo(
+    () => ({
+      id: "ai-1",
+      name: "Orcheo Assistant",
+      avatar: "https://avatar.vercel.sh/orcheo-assistant",
+    }),
+    [],
+  );
+
+  const chat = useWorkflowChat({
+    workflowId,
+    backendBaseUrl: getBackendBaseUrl(),
+    userName: user.name,
+  });
+
+  return {
+    routeWorkflowId: workflowId ?? null,
+    routeWorkflowRef: workflowRouteRef ?? null,
+    metadata,
+    execution,
+    ui,
+    websocketRef,
+    isMountedRef,
+    chat,
+    user,
+    ai,
+  };
+}

package/src/features/workflow/pages/workflow/hooks/controller/use-workflow-execution-controller.ts

@@ -0,0 +1,167 @@
+import { useState } from "react";
+import { toast } from "@/hooks/use-toast";
+import { getAccessToken } from "@features/auth/lib/auth-session";
+import {
+  buildWorkflowWebSocketProtocols,
+  buildWorkflowWebSocketUrl,
+  getBackendBaseUrl,
+} from "@/lib/config";
+import {
+  fetchWorkflowVersions,
+  selectLatestWorkflowVersion,
+} from "@features/workflow/lib/workflow-storage-api";
+import { useExecutionUpdates } from "@features/workflow/pages/workflow/hooks/use-execution-updates";
+import { usePauseWorkflow } from "@features/workflow/pages/workflow/hooks/use-pause-workflow";
+import { useExecutionTrace } from "@features/workflow/pages/workflow/hooks/use-execution-trace";
+import { createExecutionRecord } from "@features/workflow/pages/workflow/hooks/execution-record";
+import { setupExecutionWebSocket } from "@features/workflow/pages/workflow/hooks/workflow-runner-websocket";
+
+const generateRandomId = (prefix: string) =>
+  `${prefix}-${Math.random().toString(36).slice(2, 10)}`;
+import type { WorkflowCore } from "./use-workflow-core";
+
+export interface WorkflowExecutionController {
+  executionUpdates: ReturnType<typeof useExecutionUpdates>;
+  handleRunPersistedWorkflow: () => Promise<void>;
+  handlePauseWorkflow: () => void;
+  isRunPending: boolean;
+  trace: ReturnType<typeof useExecutionTrace>;
+}
+
+export function useWorkflowExecutionController(
+  core: WorkflowCore,
+): WorkflowExecutionController {
+  const [isRunPending, setIsRunPending] = useState(false);
+
+  const executionUpdates = useExecutionUpdates({
+    setExecutions: core.execution.setExecutions,
+    setIsRunning: core.execution.setIsRunning,
+    websocketRef: core.websocketRef,
+    isMountedRef: core.isMountedRef,
+  });
+
+  const executionIds = core.execution.executions.map(
+    (execution) => execution.id,
+  );
+
+  const trace = useExecutionTrace({
+    backendBaseUrl: core.chat.backendBaseUrl ?? getBackendBaseUrl(),
+    workflowId: core.metadata.currentWorkflowId,
+    activeExecutionId: core.execution.activeExecutionId,
+    isMountedRef: core.isMountedRef,
+    executionIds,
+    enabled: core.ui.activeTab === "trace",
+  });
+
+  const handleRunPersistedWorkflow = async () => {
+    const workflowId = core.metadata.currentWorkflowId;
+    if (!workflowId) {
+      toast({
+        title: "Save workflow first",
+        description:
+          "Running requires a saved workflow with an ingested Python version.",
+        variant: "destructive",
+      });
+      return;
+    }
+
+    setIsRunPending(true);
+    try {
+      const persistedVersions = await fetchWorkflowVersions(workflowId);
+      const latestPersistedVersion =
+        selectLatestWorkflowVersion(persistedVersions);
+      if (!latestPersistedVersion) {
+        throw new Error(
+          "Running requires a saved workflow with an ingested Python version.",
+        );
+      }
+
+      const latestVersionRecord =
+        core.metadata.workflowVersions.find(
+          (version) => version.id === latestPersistedVersion.id,
+        ) ??
+        core.metadata.workflowVersions.reduce<
+          (typeof core.metadata.workflowVersions)[number] | undefined
+        >(
+          (latest, current) =>
+            !latest || current.versionNumber > latest.versionNumber
+              ? current
+              : latest,
+          undefined,
+        );
+
+      const graphToWorkflow = latestVersionRecord?.graphToWorkflow ?? {};
+      const executionId = generateRandomId("run");
+      const executionRecord = createExecutionRecord(executionId, graphToWorkflow);
+
+      if (core.websocketRef.current) {
+        core.websocketRef.current.close();
+        core.websocketRef.current = null;
+      }
+
+      const token = getAccessToken();
+      const websocketUrl = buildWorkflowWebSocketUrl(
+        workflowId,
+        getBackendBaseUrl(),
+        token,
+      );
+      const websocketProtocols = buildWorkflowWebSocketProtocols(token);
+
+      core.execution.setExecutions((prev) => [
+        executionRecord,
+        ...prev.filter((entry) => entry.id !== executionId),
+      ]);
+      core.execution.setActiveExecutionId(executionId);
+      core.execution.setIsRunning(true);
+
+      const ws = websocketProtocols
+        ? new WebSocket(websocketUrl, websocketProtocols)
+        : new WebSocket(websocketUrl);
+      core.websocketRef.current = ws;
+
+      setupExecutionWebSocket({
+        ws,
+        executionId,
+        config: latestPersistedVersion.graph,
+        graphToWorkflow,
+        storedRunnableConfig: latestPersistedVersion.runnable_config,
+        nodes: [],
+        currentWorkflowId: workflowId,
+        isMountedRef: core.isMountedRef,
+        applyExecutionUpdate: executionUpdates.applyExecutionUpdate,
+        setIsRunning: core.execution.setIsRunning,
+        setExecutions: core.execution.setExecutions,
+        websocketRef: core.websocketRef,
+        onTraceUpdate: trace.handleTraceUpdate,
+      });
+    } catch (error) {
+      core.execution.setIsRunning(false);
+      toast({
+        title: "Failed to run workflow",
+        description:
+          error instanceof Error
+            ? error.message
+            : "Unable to start workflow run.",
+        variant: "destructive",
+      });
+    } finally {
+      setIsRunPending(false);
+    }
+  };
+
+  const handlePauseWorkflow = usePauseWorkflow({
+    activeExecutionId: core.execution.activeExecutionId,
+    isRunning: core.execution.isRunning,
+    setIsRunning: core.execution.setIsRunning,
+    setExecutions: core.execution.setExecutions,
+    websocketRef: core.websocketRef,
+  });
+
+  return {
+    executionUpdates,
+    handleRunPersistedWorkflow,
+    handlePauseWorkflow,
+    isRunPending,
+    trace,
+  };
+}

package/src/features/workflow/pages/workflow/hooks/controller/use-workflow-lifecycle.ts

@@ -0,0 +1,37 @@
+import { useWorkflowLoader } from "@features/workflow/pages/workflow/hooks/use-workflow-loader";
+import { useWorkflowStorageListener } from "@features/workflow/pages/workflow/hooks/use-workflow-storage-listener";
+
+import type { WorkflowCore } from "./use-workflow-core";
+
+export function useWorkflowLifecycle(
+  core: WorkflowCore,
+  workflowId: string | undefined,
+) {
+  useWorkflowLoader({
+    workflowId,
+    loadExecutionHistory: core.ui.activeTab === "trace",
+    setCurrentWorkflowId: core.metadata.setCurrentWorkflowId,
+    setWorkflowName: core.metadata.setWorkflowName,
+    setWorkflowDescription: core.metadata.setWorkflowDescription,
+    setWorkflowTags: core.metadata.setWorkflowTags,
+    setWorkflowVersions: core.metadata.setWorkflowVersions,
+    setChatkitStartScreenPrompts: core.metadata.setChatkitStartScreenPrompts,
+    setChatkitSupportedModels: core.metadata.setChatkitSupportedModels,
+    setIsWorkflowPublic: core.metadata.setIsWorkflowPublic,
+    setWorkflowShareUrl: core.metadata.setWorkflowShareUrl,
+    setIsWorkflowLoading: core.metadata.setIsWorkflowLoading,
+    setWorkflowLoadError: core.metadata.setWorkflowLoadError,
+    setExecutions: core.execution.setExecutions,
+    setActiveExecutionId: core.execution.setActiveExecutionId,
+  });
+
+  useWorkflowStorageListener({
+    currentWorkflowId: core.metadata.currentWorkflowId,
+    setWorkflowName: core.metadata.setWorkflowName,
+    setWorkflowDescription: core.metadata.setWorkflowDescription,
+    setWorkflowVersions: core.metadata.setWorkflowVersions,
+    setWorkflowTags: core.metadata.setWorkflowTags,
+    setChatkitStartScreenPrompts: core.metadata.setChatkitStartScreenPrompts,
+    setChatkitSupportedModels: core.metadata.setChatkitSupportedModels,
+  });
+}

package/src/features/workflow/pages/workflow/hooks/controller/use-workflow-resources.ts

@@ -0,0 +1,57 @@
+import { getBackendBaseUrl } from "@/lib/config";
+import { useWorkflowCredentialReadiness } from "@features/workflow/pages/workflow/hooks/use-workflow-credential-readiness";
+import { useWorkflowCredentials } from "@features/workflow/pages/workflow/hooks/use-workflow-credentials";
+import { useWorkflowListeners } from "@features/workflow/pages/workflow/hooks/use-workflow-listeners";
+import { useWorkflowSaver } from "@features/workflow/pages/workflow/hooks/use-workflow-saver";
+
+import type { WorkflowCore } from "./use-workflow-core";
+
+export interface WorkflowResources {
+  credentials: ReturnType<typeof useWorkflowCredentials>;
+  credentialReadiness: ReturnType<typeof useWorkflowCredentialReadiness>;
+  listeners: ReturnType<typeof useWorkflowListeners>;
+  saver: ReturnType<typeof useWorkflowSaver>;
+}
+
+export function useWorkflowResources(
+  core: WorkflowCore,
+  workflowId: string | undefined,
+): WorkflowResources {
+  const credentials = useWorkflowCredentials({
+    routeWorkflowId: workflowId,
+    currentWorkflowId: core.metadata.currentWorkflowId,
+    backendBaseUrl: getBackendBaseUrl(),
+    userName: core.user.name,
+  });
+
+  const credentialReadiness = useWorkflowCredentialReadiness({
+    workflowId: core.metadata.currentWorkflowId ?? workflowId ?? null,
+    refreshKey: credentials.credentials.length,
+  });
+
+  const listeners = useWorkflowListeners({
+    routeWorkflowId: workflowId,
+    currentWorkflowId: core.metadata.currentWorkflowId,
+    workflowVersionCount: core.metadata.workflowVersions.length,
+    actor: core.user.name,
+    enabled: core.ui.activeTab === "settings",
+  });
+
+  const saver = useWorkflowSaver({
+    setWorkflowName: core.metadata.setWorkflowName,
+    setWorkflowDescription: core.metadata.setWorkflowDescription,
+    setWorkflowVersions: core.metadata.setWorkflowVersions,
+    setWorkflowTags: core.metadata.setWorkflowTags,
+    workflowName: core.metadata.workflowName,
+    workflowDescription: core.metadata.workflowDescription,
+    workflowTags: core.metadata.workflowTags,
+    currentWorkflowId: core.metadata.currentWorkflowId,
+  });
+
+  return {
+    credentials,
+    credentialReadiness,
+    listeners,
+    saver,
+  };
+}

package/src/features/workflow/pages/workflow/hooks/execution-log-helpers.ts

@@ -0,0 +1,75 @@
+export type ExecutionLogLevel = "INFO" | "DEBUG" | "ERROR" | "WARNING";
+
+export function determineLogLevel(
+  payload: Record<string, unknown>,
+): ExecutionLogLevel {
+  const explicit = payload.level ?? payload.log_level;
+  if (typeof explicit === "string") {
+    const level = explicit.trim().toLowerCase();
+    if (level === "debug") {
+      return "DEBUG";
+    }
+    if (level === "error") {
+      return "ERROR";
+    }
+    if (level === "warning" || level === "warn") {
+      return "WARNING";
+    }
+  }
+
+  if (typeof payload.error === "string" && payload.error.trim()) {
+    return "ERROR";
+  }
+
+  const status =
+    typeof payload.status === "string" ? payload.status.toLowerCase() : null;
+  if (status === "error" || status === "failed") {
+    return "ERROR";
+  }
+  if (status === "warning" || status === "cancelled" || status === "partial") {
+    return "WARNING";
+  }
+  if (status === "debug") {
+    return "DEBUG";
+  }
+  return "INFO";
+}
+
+export function describePayload(
+  payload: Record<string, unknown>,
+  graphToWorkflow: Record<string, string>,
+  resolveNodeLabel: (nodeId: string) => string,
+): string {
+  if (typeof payload.error === "string" && payload.error.trim()) {
+    return `Run error: ${payload.error.trim()}`;
+  }
+
+  if (typeof payload.message === "string" && payload.message.trim()) {
+    return payload.message.trim();
+  }
+
+  const nodeKey = ["node", "step", "name"].find(
+    (key) => typeof payload[key] === "string" && payload[key],
+  );
+
+  const status =
+    typeof payload.status === "string"
+      ? payload.status.toLowerCase()
+      : undefined;
+
+  if (nodeKey) {
+    const graphNode = String(payload[nodeKey]);
+    const workflowNodeId = graphToWorkflow[graphNode] ?? graphNode;
+    const label = resolveNodeLabel(workflowNodeId);
+    if (status) {
+      return `Node ${label} ${status}`;
+    }
+    return `Node ${label} emitted an update`;
+  }
+
+  if (status) {
+    return `Run status changed to ${status}`;
+  }
+
+  return JSON.stringify(payload);
+}

package/src/features/workflow/pages/workflow/hooks/execution-node-status.ts

@@ -0,0 +1,46 @@
+import {
+  executionStatusFromValue,
+  nodeStatusFromValue,
+} from "@features/workflow/pages/workflow/helpers/execution";
+
+import type {
+  NodeStatus,
+  WorkflowExecutionStatus,
+} from "@features/workflow/pages/workflow/helpers/types";
+
+export function deriveNodeStatusUpdates(
+  payload: Record<string, unknown>,
+  graphToWorkflow: Record<string, string>,
+): Record<string, NodeStatus> {
+  const nodeKey = ["node", "step", "name"].find(
+    (key) => typeof payload[key] === "string" && payload[key],
+  );
+  if (!nodeKey) {
+    return {};
+  }
+  const statusValue =
+    typeof payload.status === "string" ? payload.status : undefined;
+  if (!statusValue) {
+    return {};
+  }
+  const graphNode = String(payload[nodeKey]);
+  const workflowNodeId = graphToWorkflow[graphNode] ?? graphNode;
+  const status = nodeStatusFromValue(statusValue);
+  return { [workflowNodeId]: status };
+}
+
+export function nextExecutionStatus(
+  payload: Record<string, unknown>,
+  hasNodeReference: boolean,
+): WorkflowExecutionStatus | null {
+  const statusValue =
+    typeof payload.status === "string" ? payload.status : undefined;
+  let executionStatus = executionStatusFromValue(statusValue);
+  if (hasNodeReference) {
+    executionStatus = null;
+  }
+  if (typeof payload.error === "string" && payload.error.trim()) {
+    executionStatus = "failed";
+  }
+  return executionStatus;
+}