orcheo-canvas 0.0.1

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

@@ -0,0 +1,122 @@
+import React from "react";
+import type { Edge, Node } from "@xyflow/react";
+
+import type {
+  WorkflowEdge as PersistedWorkflowEdge,
+  WorkflowNode as PersistedWorkflowNode,
+} from "@features/workflow/data/workflow-data";
+
+export interface NodeRuntimeData {
+  inputs?: unknown;
+  outputs?: unknown;
+  messages?: unknown;
+  raw?: unknown;
+  updatedAt: string;
+}
+
+export interface NodeData {
+  type: string;
+  label: string;
+  description?: string;
+  status: "idle" | "running" | "success" | "error" | "warning";
+  iconKey?: string;
+  icon?: React.ReactNode;
+  onOpenChat?: () => void;
+  onDelete?: (id: string) => void;
+  isDisabled?: boolean;
+  runtime?: NodeRuntimeData;
+  code?: string;
+  [key: string]: unknown;
+}
+
+export type CanvasNode = Node<NodeData>;
+export type CanvasEdge = Edge<Record<string, unknown>>;
+
+export interface WorkflowSnapshot {
+  nodes: CanvasNode[];
+  edges: CanvasEdge[];
+}
+
+export type WorkflowClipboardPayload = {
+  version: 1;
+  type: "workflow-selection";
+  nodes: PersistedWorkflowNode[];
+  edges: PersistedWorkflowEdge[];
+  copiedAt?: number;
+};
+
+export type CopyClipboardOptions = {
+  skipSuccessToast?: boolean;
+};
+
+export type CopyClipboardResult = {
+  success: boolean;
+  nodeCount: number;
+  edgeCount: number;
+  usedFallback: boolean;
+};
+
+export type WorkflowExecutionStatus =
+  | "running"
+  | "success"
+  | "failed"
+  | "partial";
+
+export type NodeStatus = "idle" | "running" | "success" | "error" | "warning";
+
+export interface WorkflowExecutionNode {
+  id: string;
+  type: string;
+  name: string;
+  position: { x: number; y: number };
+  status: NodeStatus;
+  iconKey?: string;
+  details?: Record<string, unknown>;
+}
+
+export interface WorkflowExecution {
+  id: string;
+  runId: string;
+  status: WorkflowExecutionStatus;
+  startTime: string;
+  endTime?: string;
+  duration: number;
+  issues: number;
+  nodes: WorkflowExecutionNode[];
+  edges: WorkflowEdge[];
+  logs: {
+    timestamp: string;
+    level: "INFO" | "DEBUG" | "ERROR" | "WARNING";
+    message: string;
+  }[];
+  metadata?: {
+    graphToCanvas?: Record<string, string>;
+  };
+}
+
+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[];
+}
+
+export interface SidebarNodeDefinition {
+  id?: string;
+  type?: string;
+  name?: string;
+  description?: string;
+  iconKey?: string;
+  icon?: React.ReactNode;
+  data?: Record<string, unknown>;
+}

package/src/features/workflow/pages/workflow-canvas/helpers/validation.ts

@@ -0,0 +1,57 @@
+export const isRecord = (value: unknown): value is Record<string, unknown> => {
+  return typeof value === "object" && value !== null;
+};
+
+export const determineNodeType = (nodeId?: string) => {
+  if (nodeId?.includes("chat-trigger")) {
+    return "chatTrigger" as const;
+  }
+  if (nodeId === "sticky-note") {
+    return "stickyNote" as const;
+  }
+  if (nodeId === "start-node" || nodeId === "end-node") {
+    return "startEnd" as const;
+  }
+  return "default" as const;
+};
+
+export const validateWorkflowData = (data: unknown) => {
+  if (!isRecord(data)) {
+    throw new Error("Invalid workflow file structure.");
+  }
+
+  const { nodes, edges } = data as {
+    nodes: unknown;
+    edges: unknown;
+  };
+
+  if (!Array.isArray(nodes)) {
+    throw new Error("Invalid nodes array in workflow file.");
+  }
+
+  nodes.forEach((node, index) => {
+    if (!isRecord(node)) {
+      throw new Error(`Invalid node at index ${index}.`);
+    }
+    if (!isRecord(node.position)) {
+      throw new Error(`Node ${node.id ?? index} is missing position data.`);
+    }
+    const { x, y } = node.position as Record<string, unknown>;
+    if (typeof x !== "number" || typeof y !== "number") {
+      throw new Error(`Node ${node.id ?? index} has invalid coordinates.`);
+    }
+  });
+
+  if (!Array.isArray(edges)) {
+    throw new Error("Invalid edges array in workflow file.");
+  }
+
+  edges.forEach((edge, index) => {
+    if (!isRecord(edge)) {
+      throw new Error(`Invalid edge at index ${index}.`);
+    }
+    if (typeof edge.source !== "string" || typeof edge.target !== "string") {
+      throw new Error(`Edge ${edge.id ?? index} has invalid connections.`);
+    }
+  });
+};

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

@@ -0,0 +1,229 @@
+import type { CanvasTabContentProps } from "@features/workflow/pages/workflow-canvas/components/canvas-tab-content";
+import type { ExecutionTabContentProps } from "@features/workflow/pages/workflow-canvas/components/execution-tab-content";
+import type { ReadinessTabContentProps } from "@features/workflow/pages/workflow-canvas/components/readiness-tab-content";
+import type { SettingsTabContentProps } from "@features/workflow/pages/workflow-canvas/components/settings-tab-content";
+import type { TraceTabContentProps } from "@features/workflow/pages/workflow-canvas/components/trace-tab-content";
+import type { WorkflowCanvasCore } from "./use-workflow-canvas-core";
+import type { WorkflowCanvasResources } from "./use-workflow-canvas-resources";
+import type { WorkflowCanvasExecution } from "./use-workflow-canvas-execution";
+import { summarizeTrace } from "@features/workflow/pages/workflow-canvas/helpers/trace";
+
+export interface WorkflowLayoutProps {
+  topNavigationProps: {
+    currentWorkflow: { name: string; path: string[] };
+    credentials: WorkflowCanvasResources["credentials"]["credentials"];
+    isCredentialsLoading: boolean;
+    onAddCredential: WorkflowCanvasResources["credentials"]["handleAddCredential"];
+    onDeleteCredential: WorkflowCanvasResources["credentials"]["handleDeleteCredential"];
+  };
+  tabsProps: {
+    activeTab: string;
+    onTabChange: (value: string) => void;
+    readinessAlertCount: number;
+  };
+  canvasProps: CanvasTabContentProps;
+  executionProps: ExecutionTabContentProps;
+  traceProps: TraceTabContentProps;
+  readinessProps: ReadinessTabContentProps;
+  settingsProps: SettingsTabContentProps;
+  nodeInspector: {
+    selectedNode: CanvasTabContentProps["flowHandlers"]["nodes"][number] | null;
+    nodes: CanvasTabContentProps["flowHandlers"]["nodes"];
+    edges: CanvasTabContentProps["flowHandlers"]["edges"];
+    onClose: WorkflowCanvasExecution["inspectorHandlers"]["handleCloseNodeInspector"];
+    onSave: WorkflowCanvasExecution["inspectorHandlers"]["handleNodeUpdate"];
+    runtimeCache: Record<string, unknown>;
+    onCacheRuntime: WorkflowCanvasExecution["inspectorHandlers"]["handleCacheNodeRuntime"];
+  } | null;
+  chat: {
+    isChatOpen: boolean;
+    chatTitle: string;
+    user: { id: string; name: string; avatar: string };
+    ai: { id: string; name: string; avatar: string };
+    activeChatNodeId: string | null;
+    handleChatResponseStart: () => void;
+    handleChatResponseEnd: () => void;
+    handleChatClientTool: (tool: unknown) => void;
+  } | null;
+}
+
+export function buildWorkflowLayoutProps(
+  core: WorkflowCanvasCore,
+  resources: WorkflowCanvasResources,
+  execution: WorkflowCanvasExecution,
+): WorkflowLayoutProps {
+  const selectedNode =
+    core.history.nodes.find((node) => node.id === core.ui.selectedNodeId) ??
+    null;
+
+  const canvasProps: CanvasTabContentProps = {
+    sidebarCollapsed: core.ui.sidebarCollapsed,
+    onToggleSidebar: () =>
+      core.ui.setSidebarCollapsed(!core.ui.sidebarCollapsed),
+    onAddNode: execution.nodeCreation.handleAddNode,
+    reactFlowWrapperRef: core.reactFlowWrapper,
+    onDragOver: execution.nodeCreation.onDragOver,
+    onDrop: execution.nodeCreation.onDrop,
+    edgeHoverContextValue: {
+      hoveredEdgeId: core.ui.hoveredEdgeId,
+      setHoveredEdgeId: core.ui.setHoveredEdgeId,
+    },
+    flowHandlers: {
+      nodes: core.nodeState.decoratedNodes,
+      edges: core.history.edges,
+      onNodesChange: core.history.onNodesChange,
+      onEdgesChange: core.history.onEdgesChange,
+      onConnect: execution.handleConnect,
+      onNodeClick: () => {},
+      onNodeDoubleClick: (_event, node) => {
+        if (node.type !== "startEnd") {
+          core.ui.setSelectedNodeId(node.id);
+        }
+      },
+      onEdgeMouseEnter: execution.edgeHoverHandlers.onEnter,
+      onEdgeMouseLeave: execution.edgeHoverHandlers.onLeave,
+      onInit: (instance) => {
+        core.reactFlowInstance.current = instance;
+      },
+    },
+    searchHandlers: {
+      isOpen: core.search.isSearchOpen,
+      onSearch: core.search.handleSearchNodes,
+      onHighlightNext: core.search.handleHighlightNext,
+      onHighlightPrevious: core.search.handleHighlightPrevious,
+      onClose: core.search.handleCloseSearch,
+      matchCount: core.search.searchMatches.length,
+      currentMatchIndex: core.search.currentSearchIndex,
+      className: "backdrop-blur supports-[backdrop-filter]:bg-background/60",
+    },
+    controlsHandlers: {
+      isRunning: core.execution.isRunning,
+      onRun: execution.handleRunWorkflow,
+      onPause: execution.handlePauseWorkflow,
+      onSave: resources.saver.handleSaveWorkflow,
+      onUndo: core.history.handleUndo,
+      onRedo: core.history.handleRedo,
+      canUndo: core.history.canUndo,
+      canRedo: core.history.canRedo,
+      onDuplicate: resources.duplicateNodes.handleDuplicateSelectedNodes,
+      onExport: resources.fileTransfer.handleExportWorkflow,
+      onImport: resources.fileTransfer.handleImportWorkflow,
+      onToggleSearch: core.search.handleToggleSearch,
+      isSearchOpen: core.search.isSearchOpen,
+    },
+    fileInputRef: resources.fileTransfer.fileInputRef,
+    onFileSelected: resources.fileTransfer.handleWorkflowFileSelected,
+    validation: {
+      errors: core.validation.validationErrors,
+      onDismiss: execution.handleDismissValidation,
+      onFix: execution.handleFixValidation,
+    },
+  };
+
+  const executionProps: ExecutionTabContentProps = {
+    executions: core.execution.executions,
+    onViewDetails:
+      execution.executionHistoryHandlers.handleViewExecutionDetails,
+    onRefresh: execution.executionHistoryHandlers.handleRefreshExecutionHistory,
+    onCopyToEditor:
+      execution.executionHistoryHandlers.handleCopyExecutionToEditor,
+    onDelete: execution.executionHistoryHandlers.handleDeleteExecution,
+    onRunWorkflow: execution.handleRunWorkflow,
+    onPauseWorkflow: execution.handlePauseWorkflow,
+    isRunning: core.execution.isRunning,
+    activeExecutionId: core.execution.activeExecutionId,
+    setActiveExecutionId: core.execution.setActiveExecutionId,
+  };
+
+  const activeTrace = execution.trace.activeTrace;
+  const traceSummary = activeTrace ? summarizeTrace(activeTrace) : undefined;
+
+  const traceProps: TraceTabContentProps = {
+    status: execution.trace.status,
+    error: execution.trace.error,
+    viewerData: execution.trace.viewerData,
+    activeViewer: execution.trace.activeTraceViewer,
+    onRefresh: () => execution.trace.refresh(),
+    onSelectTrace: (traceId) => core.execution.setActiveExecutionId(traceId),
+    summary: traceSummary,
+    lastUpdatedAt: activeTrace?.lastUpdatedAt,
+    isLive: Boolean(activeTrace && !activeTrace.isComplete),
+  };
+
+  const readinessProps: ReadinessTabContentProps = {
+    subworkflows: core.subworkflowState.subworkflows,
+    onCreateSubworkflow: execution.handleCreateSubworkflow,
+    onInsertSubworkflow: execution.handleInsertSubworkflow,
+    onDeleteSubworkflow: execution.handleDeleteSubworkflow,
+    validationErrors: core.validation.validationErrors,
+    onRunValidation: execution.runPublishValidation,
+    onDismissValidation: execution.handleDismissValidation,
+    onFixValidation: execution.handleFixValidation,
+    isValidating: core.validation.isValidating,
+    lastValidationRun: core.validation.lastValidationRun,
+  };
+
+  const settingsProps: SettingsTabContentProps = {
+    workflowName: core.metadata.workflowName,
+    workflowDescription: core.metadata.workflowDescription,
+    workflowTags: core.metadata.workflowTags,
+    onWorkflowNameChange: core.metadata.setWorkflowName,
+    onWorkflowDescriptionChange: core.metadata.setWorkflowDescription,
+    onTagsChange: resources.saver.handleTagsChange,
+    workflowVersions: core.metadata.workflowVersions ?? [],
+    onRestoreVersion: resources.saver.handleRestoreVersion,
+    onSaveWorkflow: resources.saver.handleSaveWorkflow,
+  };
+
+  return {
+    topNavigationProps: {
+      currentWorkflow: {
+        name: core.metadata.workflowName,
+        path: ["Projects", "Workflows", core.metadata.workflowName],
+      },
+      credentials: resources.credentials.credentials,
+      isCredentialsLoading: resources.credentials.isCredentialsLoading,
+      onAddCredential: resources.credentials.handleAddCredential,
+      onDeleteCredential: resources.credentials.handleDeleteCredential,
+    },
+    tabsProps: {
+      activeTab: core.ui.activeTab,
+      onTabChange: core.ui.setActiveTab,
+      readinessAlertCount: core.validation.validationErrors.length,
+    },
+    canvasProps,
+    executionProps,
+    traceProps,
+    readinessProps,
+    settingsProps,
+    nodeInspector: selectedNode
+      ? {
+          selectedNode,
+          nodes: core.history.nodes,
+          edges: core.history.edges,
+          onClose: execution.inspectorHandlers.handleCloseNodeInspector,
+          onSave: execution.inspectorHandlers.handleNodeUpdate,
+          runtimeCache: core.nodeRuntimeCache,
+          onCacheRuntime: execution.inspectorHandlers.handleCacheNodeRuntime,
+        }
+      : null,
+    chat: {
+      isChatOpen: core.chat.isChatOpen,
+      chatTitle: core.chat.chatTitle,
+      user: core.user,
+      ai: core.ai,
+      activeChatNodeId: core.chat.activeChatNodeId,
+      workflowId: core.chat.workflowId,
+      backendBaseUrl: core.chat.backendBaseUrl,
+      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-canvas/hooks/controller/use-workflow-canvas-controller.ts

@@ -0,0 +1,26 @@
+import { useParams } from "react-router-dom";
+
+import type {
+  CanvasEdge,
+  CanvasNode,
+} from "@features/workflow/pages/workflow-canvas/helpers/types";
+import { useWorkflowCanvasCore } from "./use-workflow-canvas-core";
+import { useWorkflowCanvasResources } from "./use-workflow-canvas-resources";
+import { useWorkflowCanvasExecution } from "./use-workflow-canvas-execution";
+import { useWorkflowCanvasLifecycle } from "./use-workflow-canvas-lifecycle";
+import { buildWorkflowLayoutProps } from "./build-layout-props";
+
+export function useWorkflowCanvasController(
+  initialNodes: CanvasNode[],
+  initialEdges: CanvasEdge[],
+) {
+  const { workflowId } = useParams<{ workflowId?: string }>();
+  const core = useWorkflowCanvasCore({ initialNodes, initialEdges });
+  const resources = useWorkflowCanvasResources(core, workflowId ?? undefined);
+  const execution = useWorkflowCanvasExecution(core, resources);
+  useWorkflowCanvasLifecycle(core, workflowId ?? undefined);
+
+  const layoutProps = buildWorkflowLayoutProps(core, resources, execution);
+
+  return { layoutProps };
+}

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

@@ -0,0 +1,188 @@
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { useParams } from "react-router-dom";
+import type { ReactFlowInstance } from "@xyflow/react";
+
+import { getBackendBaseUrl } from "@/lib/config";
+import {
+  getRuntimeCacheStorageKey,
+  readRuntimeCacheFromSession,
+} from "@features/workflow/pages/workflow-canvas/helpers/runtime-cache";
+import type { WorkflowNode as PersistedWorkflowNode } from "@features/workflow/data/workflow-data";
+import { toCanvasNodeBase } from "@features/workflow/pages/workflow-canvas/helpers/transformers";
+import { useWorkflowCanvasHistory } from "@features/workflow/pages/workflow-canvas/hooks/use-workflow-canvas-history";
+import { useWorkflowSearch } from "@features/workflow/pages/workflow-canvas/hooks/use-workflow-search";
+import { useWorkflowNodeState } from "@features/workflow/pages/workflow-canvas/hooks/use-workflow-node-state";
+import { useWorkflowChat } from "@features/workflow/pages/workflow-canvas/hooks/use-workflow-chat";
+import { useWorkflowMetadataState } from "@features/workflow/pages/workflow-canvas/hooks/use-workflow-metadata-state";
+import { useWorkflowValidationState } from "@features/workflow/pages/workflow-canvas/hooks/use-workflow-validation-state";
+import { useWorkflowExecutionState } from "@features/workflow/pages/workflow-canvas/hooks/use-workflow-execution-state";
+import { useSubworkflowState } from "@features/workflow/pages/workflow-canvas/hooks/use-subworkflow-state";
+import { useCanvasUiState } from "@features/workflow/pages/workflow-canvas/hooks/use-canvas-ui-state";
+import { useRuntimeCacheSync } from "@features/workflow/pages/workflow-canvas/hooks/use-runtime-cache-sync";
+
+import type {
+  CanvasEdge,
+  CanvasNode,
+  NodeRuntimeCacheEntry,
+} from "@features/workflow/pages/workflow-canvas/helpers/types";
+
+export interface WorkflowCanvasCore {
+  history: ReturnType<typeof useWorkflowCanvasHistory>;
+  metadata: ReturnType<typeof useWorkflowMetadataState>;
+  validation: ReturnType<typeof useWorkflowValidationState>;
+  execution: ReturnType<typeof useWorkflowExecutionState>;
+  subworkflowState: ReturnType<typeof useSubworkflowState>;
+  ui: ReturnType<typeof useCanvasUiState>;
+  reactFlowWrapper: React.MutableRefObject<HTMLDivElement | null>;
+  reactFlowInstance: React.MutableRefObject<ReactFlowInstance<
+    CanvasNode,
+    CanvasEdge
+  > | null>;
+  websocketRef: React.MutableRefObject<WebSocket | null>;
+  isMountedRef: React.MutableRefObject<boolean>;
+  nodeRuntimeCache: Record<string, NodeRuntimeCacheEntry>;
+  setNodeRuntimeCache: React.Dispatch<
+    React.SetStateAction<Record<string, NodeRuntimeCacheEntry>>
+  >;
+  search: ReturnType<typeof useWorkflowSearch>;
+  chat: ReturnType<typeof useWorkflowChat>;
+  nodeState: ReturnType<typeof useWorkflowNodeState>;
+  convertPersistedNodesToCanvas: (
+    nodes: PersistedWorkflowNode[],
+  ) => CanvasNode[];
+  user: { id: string; name: string; avatar: string };
+  ai: { id: string; name: string; avatar: string };
+}
+
+interface UseWorkflowCanvasCoreArgs {
+  initialNodes: CanvasNode[];
+  initialEdges: CanvasEdge[];
+}
+
+export function useWorkflowCanvasCore({
+  initialNodes,
+  initialEdges,
+}: UseWorkflowCanvasCoreArgs): WorkflowCanvasCore {
+  const { workflowId } = useParams<{ workflowId?: string }>();
+  const history = useWorkflowCanvasHistory({ initialNodes, initialEdges });
+  const metadata = useWorkflowMetadataState();
+  const validation = useWorkflowValidationState();
+  const execution = useWorkflowExecutionState();
+  const subworkflowState = useSubworkflowState();
+  const ui = useCanvasUiState();
+
+  const reactFlowWrapper = useRef<HTMLDivElement>(null);
+  const reactFlowInstance = useRef<ReactFlowInstance<
+    CanvasNode,
+    CanvasEdge
+  > | null>(null);
+  const websocketRef = useRef<WebSocket | null>(null);
+  const isMountedRef = useRef(true);
+
+  const runtimeCacheKey = useMemo(
+    () => getRuntimeCacheStorageKey(workflowId ?? null),
+    [workflowId],
+  );
+  const [nodeRuntimeCache, setNodeRuntimeCache] = useState<
+    Record<string, NodeRuntimeCacheEntry>
+  >(() => readRuntimeCacheFromSession(runtimeCacheKey));
+  const previousRuntimeCacheKeyRef = useRef(runtimeCacheKey);
+
+  useRuntimeCacheSync({
+    runtimeCacheKey,
+    nodeRuntimeCache,
+    setNodeRuntimeCache,
+    previousRuntimeCacheKeyRef,
+  });
+
+  useEffect(() => {
+    isMountedRef.current = true;
+    return () => {
+      isMountedRef.current = false;
+      if (websocketRef.current) {
+        websocketRef.current.close();
+        websocketRef.current = null;
+      }
+    };
+  }, []);
+
+  const search = useWorkflowSearch({
+    nodesRef: history.nodesRef,
+    reactFlowInstance,
+  });
+
+  const user = useMemo(
+    () => ({
+      id: "user-1",
+      name: "Avery Chen",
+      avatar: "https://avatar.vercel.sh/avery",
+    }),
+    [],
+  );
+  const ai = useMemo(
+    () => ({
+      id: "ai-1",
+      name: "Orcheo Canvas Assistant",
+      avatar: "https://avatar.vercel.sh/orcheo-canvas",
+    }),
+    [],
+  );
+
+  const chat = useWorkflowChat({
+    nodesRef: history.nodesRef,
+    setNodes: history.setNodes,
+    workflowId,
+    backendBaseUrl: getBackendBaseUrl(),
+    userName: user.name,
+  });
+
+  const convertPersistedNodesToCanvas = useCallback(
+    (persisted: PersistedWorkflowNode[]) =>
+      persisted
+        .map((node) => toCanvasNodeBase(node))
+        .map(chat.attachChatHandlerToNode),
+    [chat.attachChatHandlerToNode],
+  );
+
+  const nodeState = useWorkflowNodeState({
+    nodes: history.nodes,
+    searchMatches: search.searchMatches,
+    searchMatchSet: search.searchMatchSet,
+    isSearchOpen: search.isSearchOpen,
+    currentSearchIndex: search.currentSearchIndex,
+    latestNodesRef: history.latestNodesRef,
+    isRestoringRef: history.isRestoringRef,
+    setNodes: history.setNodes,
+    setNodesState: history.setNodesState,
+    setEdgesState: history.setEdgesState,
+    recordSnapshot: history.recordSnapshot,
+    setNodeRuntimeCache,
+    setValidationErrors: validation.setValidationErrors,
+    setSearchMatches: search.setSearchMatches,
+    setSelectedNodeId: ui.setSelectedNodeId,
+    setActiveChatNodeId: chat.setActiveChatNodeId,
+    setIsChatOpen: chat.setIsChatOpen,
+    activeChatNodeId: chat.activeChatNodeId,
+  });
+
+  return {
+    history,
+    metadata,
+    validation,
+    execution,
+    subworkflowState,
+    ui,
+    reactFlowWrapper,
+    reactFlowInstance,
+    websocketRef,
+    isMountedRef,
+    nodeRuntimeCache,
+    setNodeRuntimeCache,
+    search,
+    chat,
+    nodeState,
+    convertPersistedNodesToCanvas,
+    user,
+    ai,
+  };
+}