orcheo-canvas 0.0.1

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

@@ -0,0 +1,269 @@
+import { useMemo } from "react";
+import type { Connection } from "@xyflow/react";
+import { addEdge, MarkerType } from "@xyflow/react";
+import { convertPersistedEdgesToCanvas } from "@features/workflow/pages/workflow-canvas/helpers/transformers";
+import { useExecutionUpdates } from "@features/workflow/pages/workflow-canvas/hooks/use-execution-updates";
+import { useRunWorkflow } from "@features/workflow/pages/workflow-canvas/hooks/use-run-workflow";
+import { usePauseWorkflow } from "@features/workflow/pages/workflow-canvas/hooks/use-pause-workflow";
+import { useNodeCreation } from "@features/workflow/pages/workflow-canvas/hooks/use-node-creation";
+import { useWorkflowKeybindings } from "@features/workflow/pages/workflow-canvas/hooks/use-workflow-keybindings";
+import { useNodeInspectorHandlers } from "@features/workflow/pages/workflow-canvas/hooks/use-node-inspector-handlers";
+import { useExecutionHistoryHandlers } from "@features/workflow/pages/workflow-canvas/hooks/use-execution-history-handlers";
+import { useExecutionTrace } from "@features/workflow/pages/workflow-canvas/hooks/use-execution-trace";
+import { getBackendBaseUrl } from "@/lib/config";
+import {
+  createHandleCreateSubworkflow,
+  createHandleDeleteSubworkflow,
+  createHandleInsertSubworkflow,
+} from "@features/workflow/pages/workflow-canvas/handlers/subworkflows";
+import {
+  createHandleDismissValidation,
+  createHandleFixValidation,
+  createRunPublishValidation,
+} from "@features/workflow/pages/workflow-canvas/handlers/validation";
+import type { CanvasEdge } from "@features/workflow/pages/workflow-canvas/helpers/types";
+import type { WorkflowCanvasCore } from "./use-workflow-canvas-core";
+import type { WorkflowCanvasResources } from "./use-workflow-canvas-resources";
+export interface WorkflowCanvasExecution {
+  executionUpdates: ReturnType<typeof useExecutionUpdates>;
+  handleRunWorkflow: () => Promise<void>;
+  handlePauseWorkflow: () => void;
+  nodeCreation: ReturnType<typeof useNodeCreation>;
+  inspectorHandlers: ReturnType<typeof useNodeInspectorHandlers>;
+  executionHistoryHandlers: ReturnType<typeof useExecutionHistoryHandlers>;
+  trace: ReturnType<typeof useExecutionTrace>;
+  runPublishValidation: ReturnType<typeof createRunPublishValidation>;
+  handleDismissValidation: ReturnType<typeof createHandleDismissValidation>;
+  handleFixValidation: ReturnType<typeof createHandleFixValidation>;
+  handleCreateSubworkflow: ReturnType<typeof createHandleCreateSubworkflow>;
+  handleDeleteSubworkflow: ReturnType<typeof createHandleDeleteSubworkflow>;
+  handleInsertSubworkflow: ReturnType<typeof createHandleInsertSubworkflow>;
+  handleConnect: (connection: Connection) => void;
+  edgeHoverHandlers: {
+    onEnter: (_event: React.MouseEvent<Element>, edge: CanvasEdge) => void;
+    onLeave: (event: React.MouseEvent<Element>, edge: CanvasEdge) => void;
+  };
+}
+export function useWorkflowCanvasExecution(
+  core: WorkflowCanvasCore,
+  resources: WorkflowCanvasResources,
+): WorkflowCanvasExecution {
+  const executionUpdates = useExecutionUpdates({
+    resolveNodeLabel: core.nodeState.resolveNodeLabel,
+    setExecutions: core.execution.setExecutions,
+    setNodes: core.history.setNodes,
+    setIsRunning: core.execution.setIsRunning,
+    websocketRef: core.websocketRef,
+    isMountedRef: core.isMountedRef,
+  });
+
+  const executionIds = useMemo(
+    () => core.execution.executions.map((execution) => execution.id),
+    [core.execution.executions],
+  );
+
+  const trace = useExecutionTrace({
+    backendBaseUrl: core.chat.backendBaseUrl ?? getBackendBaseUrl(),
+    activeExecutionId: core.execution.activeExecutionId,
+    isMountedRef: core.isMountedRef,
+    executionIds,
+  });
+
+  const handleRunWorkflow = useRunWorkflow({
+    nodes: core.history.nodes,
+    edges: core.history.edges,
+    setNodes: core.history.setNodes,
+    setExecutions: core.execution.setExecutions,
+    setActiveExecutionId: core.execution.setActiveExecutionId,
+    setIsRunning: core.execution.setIsRunning,
+    websocketRef: core.websocketRef,
+    isMountedRef: core.isMountedRef,
+    currentWorkflowId: core.metadata.currentWorkflowId,
+    applyExecutionUpdate: executionUpdates.applyExecutionUpdate,
+    handleTraceUpdate: trace.handleTraceUpdate,
+  });
+
+  const handlePauseWorkflow = usePauseWorkflow({
+    activeExecutionId: core.execution.activeExecutionId,
+    isRunning: core.execution.isRunning,
+    setIsRunning: core.execution.setIsRunning,
+    setNodes: core.history.setNodes,
+    setExecutions: core.execution.setExecutions,
+    websocketRef: core.websocketRef,
+  });
+
+  const nodeCreation = useNodeCreation({
+    reactFlowWrapper: core.reactFlowWrapper,
+    reactFlowInstance: core.reactFlowInstance,
+    nodesRef: core.history.nodesRef,
+    setNodes: core.history.setNodes,
+    handleOpenChat: core.chat.handleOpenChat,
+    handleUpdateStickyNoteNode: core.nodeState.handleUpdateStickyNoteNode,
+  });
+
+  useWorkflowKeybindings({
+    nodesRef: core.history.nodesRef,
+    deleteNodes: core.nodeState.deleteNodes,
+    handleUndo: core.history.handleUndo,
+    handleRedo: core.history.handleRedo,
+    copySelectedNodes: resources.clipboard.copySelectedNodes,
+    cutSelectedNodes: resources.clipboard.cutSelectedNodes,
+    pasteNodes: resources.clipboard.pasteNodes,
+    setIsSearchOpen: core.search.setIsSearchOpen,
+    setSearchMatches: core.search.setSearchMatches,
+    setCurrentSearchIndex: core.search.setCurrentSearchIndex,
+  });
+
+  const inspectorHandlers = useNodeInspectorHandlers({
+    nodesRef: core.history.nodesRef,
+    edgesRef: core.history.edgesRef,
+    isRestoringRef: core.history.isRestoringRef,
+    recordSnapshot: core.history.recordSnapshot,
+    setNodesState: core.history.setNodesState,
+    setEdgesState: core.history.setEdgesState,
+    setValidationErrors: core.validation.setValidationErrors,
+    setSearchMatches: core.search.setSearchMatches,
+    setActiveChatNodeId: core.chat.setActiveChatNodeId,
+    setChatTitle: core.chat.setChatTitle,
+    setSelectedNodeId: core.ui.setSelectedNodeId,
+    setNodeRuntimeCache: core.setNodeRuntimeCache,
+    handleOpenChat: core.chat.handleOpenChat,
+    activeChatNodeId: core.chat.activeChatNodeId,
+  });
+
+  const executionHistoryHandlers = useExecutionHistoryHandlers({
+    setNodes: core.history.setNodes,
+    setExecutions: core.execution.setExecutions,
+    setActiveExecutionId: core.execution.setActiveExecutionId,
+    activeExecutionId: core.execution.activeExecutionId,
+    executions: core.execution.executions,
+    determineLogLevel: executionUpdates.determineLogLevel,
+    describePayload: executionUpdates.describePayload,
+    setActiveTab: core.ui.setActiveTab,
+  });
+
+  const handleCreateSubworkflow = useMemo(
+    () =>
+      createHandleCreateSubworkflow({
+        getSelectedNodes: () =>
+          core.history.nodesRef.current.filter((node) => node.selected),
+        setSubworkflows: core.subworkflowState.setSubworkflows,
+      }),
+    [core.history.nodesRef, core.subworkflowState.setSubworkflows],
+  );
+
+  const handleDeleteSubworkflow = useMemo(
+    () =>
+      createHandleDeleteSubworkflow({
+        setSubworkflows: core.subworkflowState.setSubworkflows,
+      }),
+    [core.subworkflowState.setSubworkflows],
+  );
+
+  const handleInsertSubworkflow = useMemo(
+    () =>
+      createHandleInsertSubworkflow({
+        nodesRef: core.history.nodesRef,
+        setNodes: core.history.setNodes,
+        setEdges: core.history.setEdges,
+        setSubworkflows: core.subworkflowState.setSubworkflows,
+        convertPersistedNodesToCanvas: core.convertPersistedNodesToCanvas,
+        convertPersistedEdgesToCanvas,
+        setSelectedNodeId: core.ui.setSelectedNodeId,
+        setActiveTab: core.ui.setActiveTab,
+        reactFlowInstance: core.reactFlowInstance,
+      }),
+    [
+      core.convertPersistedNodesToCanvas,
+      core.history.nodesRef,
+      core.history.setEdges,
+      core.history.setNodes,
+      core.reactFlowInstance,
+      core.subworkflowState.setSubworkflows,
+      core.ui,
+    ],
+  );
+
+  const runPublishValidation = useMemo(
+    () =>
+      createRunPublishValidation({
+        getNodes: () => core.history.nodesRef.current,
+        getEdges: () => core.history.edgesRef.current,
+        setValidationErrors: core.validation.setValidationErrors,
+        setIsValidating: core.validation.setIsValidating,
+        setLastValidationRun: core.validation.setLastValidationRun,
+      }),
+    [core.history.edgesRef, core.history.nodesRef, core.validation],
+  );
+
+  const handleDismissValidation = useMemo(
+    () =>
+      createHandleDismissValidation({
+        setValidationErrors: core.validation.setValidationErrors,
+      }),
+    [core.validation.setValidationErrors],
+  );
+
+  const handleFixValidation = useMemo(
+    () =>
+      createHandleFixValidation({
+        getNodes: () => core.history.nodesRef.current,
+        setActiveTab: core.ui.setActiveTab,
+        setSelectedNodeId: core.ui.setSelectedNodeId,
+        reactFlowInstance: core.reactFlowInstance,
+      }),
+    [core.history.nodesRef, core.reactFlowInstance, core.ui],
+  );
+
+  const handleConnect = (params: Connection) => {
+    const id = `edge-${params.source}-${params.target}`;
+    const exists = core.history.edges.some(
+      (edge) => edge.source === params.source && edge.target === params.target,
+    );
+    if (!exists) {
+      core.history.setEdges((eds) =>
+        addEdge(
+          {
+            ...params,
+            id,
+            animated: false,
+            type: "default",
+            markerEnd: { type: MarkerType.ArrowClosed, width: 12, height: 12 },
+            style: { stroke: "#99a1b3", strokeWidth: 2 },
+          },
+          eds,
+        ),
+      );
+    }
+  };
+
+  const edgeHoverHandlers = {
+    onEnter: (_: React.MouseEvent<Element>, edge: CanvasEdge) =>
+      core.ui.setHoveredEdgeId(edge.id),
+    onLeave: (event: React.MouseEvent<Element>, edge: CanvasEdge) => {
+      const relatedTarget = event.relatedTarget as HTMLElement | null;
+      if (relatedTarget?.closest?.(`[data-edge-id="${edge.id}"]`)) return;
+      core.ui.setHoveredEdgeId((current) =>
+        current === edge.id ? null : current,
+      );
+    },
+  };
+
+  return {
+    executionUpdates,
+    handleRunWorkflow,
+    handlePauseWorkflow,
+    nodeCreation,
+    inspectorHandlers,
+    executionHistoryHandlers,
+    trace,
+    runPublishValidation,
+    handleDismissValidation,
+    handleFixValidation,
+    handleCreateSubworkflow,
+    handleDeleteSubworkflow,
+    handleInsertSubworkflow,
+    handleConnect,
+    edgeHoverHandlers,
+  };
+}

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

@@ -0,0 +1,44 @@
+import { useEffect } from "react";
+
+import { convertPersistedEdgesToCanvas } from "@features/workflow/pages/workflow-canvas/helpers/transformers";
+import { useWorkflowLoader } from "@features/workflow/pages/workflow-canvas/hooks/use-workflow-loader";
+import { useWorkflowStorageListener } from "@features/workflow/pages/workflow-canvas/hooks/use-workflow-storage-listener";
+import { useInitialFitView } from "@features/workflow/pages/workflow-canvas/hooks/use-initial-fit-view";
+
+import type { WorkflowCanvasCore } from "./use-workflow-canvas-core";
+
+export function useWorkflowCanvasLifecycle(
+  core: WorkflowCanvasCore,
+  workflowId: string | undefined,
+) {
+  useWorkflowLoader({
+    workflowId,
+    setCurrentWorkflowId: core.metadata.setCurrentWorkflowId,
+    setWorkflowName: core.metadata.setWorkflowName,
+    setWorkflowDescription: core.metadata.setWorkflowDescription,
+    setWorkflowTags: core.metadata.setWorkflowTags,
+    setWorkflowVersions: core.metadata.setWorkflowVersions,
+    setExecutions: core.execution.setExecutions,
+    setActiveExecutionId: core.execution.setActiveExecutionId,
+    convertPersistedNodesToCanvas: core.convertPersistedNodesToCanvas,
+    convertPersistedEdgesToCanvas,
+    applySnapshot: core.history.applySnapshot,
+  });
+
+  useWorkflowStorageListener({
+    currentWorkflowId: core.metadata.currentWorkflowId,
+    setWorkflowVersions: core.metadata.setWorkflowVersions,
+    setWorkflowTags: core.metadata.setWorkflowTags,
+  });
+
+  useInitialFitView(core.reactFlowInstance);
+
+  useEffect(() => {
+    if (
+      core.ui.hoveredEdgeId &&
+      !core.history.edges.some((edge) => edge.id === core.ui.hoveredEdgeId)
+    ) {
+      core.ui.setHoveredEdgeId(null);
+    }
+  }, [core.history.edges, core.ui]);
+}

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

@@ -0,0 +1,92 @@
+import { useNavigate } from "react-router-dom";
+import { getBackendBaseUrl } from "@/lib/config";
+import { convertPersistedEdgesToCanvas } from "@features/workflow/pages/workflow-canvas/helpers/transformers";
+import { useWorkflowCredentials } from "@features/workflow/pages/workflow-canvas/hooks/use-workflow-credentials";
+import { useWorkflowDuplicateNodes } from "@features/workflow/pages/workflow-canvas/hooks/use-workflow-duplicate-nodes";
+import { useWorkflowClipboard } from "@features/workflow/pages/workflow-canvas/hooks/use-workflow-clipboard";
+import { useWorkflowFileTransfer } from "@features/workflow/pages/workflow-canvas/hooks/use-workflow-file-transfer";
+import { useWorkflowSaver } from "@features/workflow/pages/workflow-canvas/hooks/use-workflow-saver";
+
+import type { WorkflowCanvasCore } from "./use-workflow-canvas-core";
+
+export interface WorkflowCanvasResources {
+  credentials: ReturnType<typeof useWorkflowCredentials>;
+  duplicateNodes: ReturnType<typeof useWorkflowDuplicateNodes>;
+  clipboard: ReturnType<typeof useWorkflowClipboard>;
+  fileTransfer: ReturnType<typeof useWorkflowFileTransfer>;
+  saver: ReturnType<typeof useWorkflowSaver>;
+}
+
+export function useWorkflowCanvasResources(
+  core: WorkflowCanvasCore,
+  workflowId: string | undefined,
+): WorkflowCanvasResources {
+  const navigate = useNavigate();
+
+  const credentials = useWorkflowCredentials({
+    routeWorkflowId: workflowId,
+    currentWorkflowId: core.metadata.currentWorkflowId,
+    backendBaseUrl: getBackendBaseUrl(),
+    userName: core.user.name,
+  });
+
+  const duplicateNodes = useWorkflowDuplicateNodes({
+    nodes: core.history.nodes,
+    edges: core.history.edges,
+    nodesRef: core.history.nodesRef,
+    isRestoringRef: core.history.isRestoringRef,
+    recordSnapshot: core.history.recordSnapshot,
+    setNodesState: core.history.setNodesState,
+    setEdgesState: core.history.setEdgesState,
+    handleOpenChat: core.chat.handleOpenChat,
+  });
+
+  const clipboard = useWorkflowClipboard({
+    nodesRef: core.history.nodesRef,
+    edgesRef: core.history.edgesRef,
+    recordSnapshot: core.history.recordSnapshot,
+    setNodesState: core.history.setNodesState,
+    setEdgesState: core.history.setEdgesState,
+    deleteNodes: core.nodeState.deleteNodes,
+    isRestoringRef: core.history.isRestoringRef,
+    convertPersistedNodesToCanvas: core.convertPersistedNodesToCanvas,
+    convertPersistedEdgesToCanvas,
+  });
+
+  const fileTransfer = useWorkflowFileTransfer({
+    createSnapshot: core.history.createSnapshot,
+    convertPersistedNodesToCanvas: core.convertPersistedNodesToCanvas,
+    convertPersistedEdgesToCanvas,
+    setNodesState: core.history.setNodesState,
+    setEdgesState: core.history.setEdgesState,
+    setWorkflowName: core.metadata.setWorkflowName,
+    setWorkflowDescription: core.metadata.setWorkflowDescription,
+    setCurrentWorkflowId: core.metadata.setCurrentWorkflowId,
+    setWorkflowVersions: core.metadata.setWorkflowVersions,
+    setWorkflowTags: core.metadata.setWorkflowTags,
+    workflowName: core.metadata.workflowName,
+    workflowDescription: core.metadata.workflowDescription,
+    recordSnapshot: core.history.recordSnapshot,
+    isRestoringRef: core.history.isRestoringRef,
+  });
+
+  const saver = useWorkflowSaver({
+    createSnapshot: core.history.createSnapshot,
+    convertPersistedNodesToCanvas: core.convertPersistedNodesToCanvas,
+    convertPersistedEdgesToCanvas,
+    setWorkflowName: core.metadata.setWorkflowName,
+    setWorkflowDescription: core.metadata.setWorkflowDescription,
+    setCurrentWorkflowId: core.metadata.setCurrentWorkflowId,
+    setWorkflowVersions: core.metadata.setWorkflowVersions,
+    setWorkflowTags: core.metadata.setWorkflowTags,
+    workflowName: core.metadata.workflowName,
+    workflowDescription: core.metadata.workflowDescription,
+    workflowTags: core.metadata.workflowTags,
+    currentWorkflowId: core.metadata.currentWorkflowId,
+    workflowIdFromRoute: workflowId,
+    navigate,
+    applySnapshot: core.history.applySnapshot,
+  });
+
+  return { credentials, duplicateNodes, clipboard, fileTransfer, saver };
+}

package/src/features/workflow/pages/workflow-canvas/hooks/execution-canvas-updater.ts

@@ -0,0 +1,79 @@
+import type {
+  CanvasNode,
+  NodeData,
+  NodeRuntimeData,
+  NodeStatus,
+  WorkflowExecutionStatus,
+} from "@features/workflow/pages/workflow-canvas/helpers/types";
+
+interface CanvasNodeUpdateParams {
+  nodes: CanvasNode[];
+  nodeUpdates: Record<string, NodeStatus>;
+  runtimeUpdates: Record<string, NodeRuntimeData>;
+  executionStatus: WorkflowExecutionStatus | null;
+}
+
+export function updateCanvasNodes({
+  nodes,
+  nodeUpdates,
+  runtimeUpdates,
+  executionStatus,
+}: CanvasNodeUpdateParams): CanvasNode[] {
+  const shouldUpdate =
+    Object.keys(nodeUpdates).length > 0 ||
+    Object.keys(runtimeUpdates).length > 0 ||
+    (executionStatus && executionStatus !== "running");
+
+  if (!shouldUpdate) {
+    return nodes;
+  }
+
+  return nodes.map((node) => {
+    const nextStatus = nodeUpdates[node.id];
+    const runtime = runtimeUpdates[node.id];
+    let nextData = node.data as NodeData;
+    let changed = false;
+
+    if (nextStatus) {
+      nextData = { ...nextData, status: nextStatus };
+      changed = true;
+    } else if (
+      executionStatus &&
+      executionStatus !== "running" &&
+      (node.data?.status === "running" || node.data?.status === undefined)
+    ) {
+      const fallback: NodeStatus =
+        executionStatus === "failed"
+          ? "error"
+          : executionStatus === "partial"
+            ? "warning"
+            : "success";
+      nextData = { ...nextData, status: fallback };
+      changed = true;
+    }
+
+    if (runtime) {
+      const nextRuntime: NodeRuntimeData = {
+        ...((nextData.runtime ?? {}) as NodeRuntimeData),
+        ...(runtime.inputs !== undefined ? { inputs: runtime.inputs } : {}),
+        ...(runtime.outputs !== undefined ? { outputs: runtime.outputs } : {}),
+        ...(runtime.messages !== undefined
+          ? { messages: runtime.messages }
+          : {}),
+        raw: runtime.raw,
+        updatedAt: runtime.updatedAt,
+      };
+      nextData = { ...nextData, runtime: nextRuntime };
+      changed = true;
+    }
+
+    if (changed) {
+      return {
+        ...node,
+        data: nextData,
+      };
+    }
+
+    return node;
+  });
+}

package/src/features/workflow/pages/workflow-canvas/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>,
+  graphToCanvas: 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 canvasNodeId = graphToCanvas[graphNode] ?? graphNode;
+    const label = resolveNodeLabel(canvasNodeId);
+    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-canvas/hooks/execution-node-status.ts

@@ -0,0 +1,46 @@
+import {
+  executionStatusFromValue,
+  nodeStatusFromValue,
+} from "@features/workflow/pages/workflow-canvas/helpers/execution";
+
+import type {
+  NodeStatus,
+  WorkflowExecutionStatus,
+} from "@features/workflow/pages/workflow-canvas/helpers/types";
+
+export function deriveNodeStatusUpdates(
+  payload: Record<string, unknown>,
+  graphToCanvas: 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 canvasNodeId = graphToCanvas[graphNode] ?? graphNode;
+  const status = nodeStatusFromValue(statusValue);
+  return { [canvasNodeId]: 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;
+}