@genfeedai/workflow-ui 0.1.0

package/dist/chunk-CSUBLSKZ.mjs

@@ -0,0 +1,1002 @@
+import { require_dist, useWorkflowStore } from './chunk-BJ3R5R32.mjs';
+import { __toESM } from './chunk-AC6TWLRT.mjs';
+import { create } from 'zustand';
+
+var notificationId = 0;
+var useUIStore = create((set) => ({
+  showPalette: true,
+  showMinimap: true,
+  showAIGenerator: false,
+  showDebugPanel: false,
+  selectedNodeId: null,
+  selectedEdgeId: null,
+  highlightedNodeIds: [],
+  activeModal: null,
+  nodeDetailNodeId: null,
+  nodeDetailActiveTab: "preview",
+  nodeDetailStartIndex: 0,
+  notifications: [],
+  togglePalette: () => {
+    set((state) => ({ showPalette: !state.showPalette }));
+  },
+  toggleMinimap: () => {
+    set((state) => ({ showMinimap: !state.showMinimap }));
+  },
+  toggleAIGenerator: () => {
+    set((state) => ({ showAIGenerator: !state.showAIGenerator }));
+  },
+  toggleDebugPanel: () => {
+    set((state) => ({ showDebugPanel: !state.showDebugPanel }));
+  },
+  setShowDebugPanel: (show) => {
+    set({ showDebugPanel: show });
+  },
+  selectNode: (nodeId) => {
+    set({ selectedNodeId: nodeId, selectedEdgeId: null });
+  },
+  selectEdge: (edgeId) => {
+    set({ selectedEdgeId: edgeId, selectedNodeId: null });
+  },
+  setHighlightedNodeIds: (ids) => {
+    set({ highlightedNodeIds: ids });
+  },
+  openModal: (modal) => {
+    set({ activeModal: modal });
+  },
+  closeModal: () => {
+    set({ activeModal: null });
+  },
+  openNodeDetailModal: (nodeId, tab = "preview", startIndex = 0) => {
+    set({
+      activeModal: "nodeDetail",
+      nodeDetailNodeId: nodeId,
+      nodeDetailActiveTab: tab,
+      nodeDetailStartIndex: startIndex
+    });
+  },
+  closeNodeDetailModal: () => {
+    set({
+      activeModal: null,
+      nodeDetailNodeId: null,
+      nodeDetailActiveTab: "preview",
+      nodeDetailStartIndex: 0
+    });
+  },
+  setNodeDetailTab: (tab) => {
+    set({ nodeDetailActiveTab: tab });
+  },
+  addNotification: (notification) => {
+    const id = `notification-${++notificationId}`;
+    set((state) => ({
+      notifications: [...state.notifications, { ...notification, id }]
+    }));
+    if (notification.duration !== 0) {
+      setTimeout(() => {
+        set((state) => ({
+          notifications: state.notifications.filter((n) => n.id !== id)
+        }));
+      }, notification.duration ?? 5e3);
+    }
+  },
+  removeNotification: (id) => {
+    set((state) => ({
+      notifications: state.notifications.filter((n) => n.id !== id)
+    }));
+  }
+}));
+
+// src/stores/settingsStore.ts
+var import_types = __toESM(require_dist());
+var STORAGE_KEY = "genfeed-settings";
+var MAX_RECENT_MODELS = 8;
+var DEFAULT_SETTINGS = {
+  providers: {
+    replicate: { apiKey: null, enabled: true },
+    fal: { apiKey: null, enabled: false },
+    huggingface: { apiKey: null, enabled: false },
+    "genfeed-ai": { apiKey: null, enabled: true }
+  },
+  defaults: {
+    imageModel: "nano-banana-pro",
+    imageProvider: "replicate",
+    videoModel: "veo-3.1",
+    videoProvider: "replicate"
+  },
+  edgeStyle: "default",
+  showMinimap: true,
+  autoSaveEnabled: true,
+  recentModels: [],
+  hasSeenWelcome: false,
+  debugMode: false
+};
+function loadFromStorage() {
+  if (typeof window === "undefined") return {};
+  try {
+    const stored = localStorage.getItem(STORAGE_KEY);
+    if (stored) {
+      const parsed = JSON.parse(stored);
+      return {
+        providers: { ...DEFAULT_SETTINGS.providers, ...parsed.providers },
+        defaults: { ...DEFAULT_SETTINGS.defaults, ...parsed.defaults },
+        edgeStyle: parsed.edgeStyle === "bezier" ? "default" : parsed.edgeStyle ?? DEFAULT_SETTINGS.edgeStyle,
+        showMinimap: parsed.showMinimap ?? DEFAULT_SETTINGS.showMinimap,
+        autoSaveEnabled: parsed.autoSaveEnabled ?? true,
+        recentModels: parsed.recentModels ?? [],
+        hasSeenWelcome: parsed.hasSeenWelcome ?? false,
+        debugMode: parsed.debugMode ?? false
+      };
+    }
+  } catch {
+  }
+  return {};
+}
+function saveToStorage(state) {
+  if (typeof window === "undefined") return;
+  try {
+    const toSave = {
+      providers: {
+        replicate: {
+          apiKey: state.providers.replicate.apiKey,
+          enabled: state.providers.replicate.enabled
+        },
+        fal: {
+          apiKey: state.providers.fal.apiKey,
+          enabled: state.providers.fal.enabled
+        },
+        huggingface: {
+          apiKey: state.providers.huggingface.apiKey,
+          enabled: state.providers.huggingface.enabled
+        }
+      },
+      defaults: state.defaults,
+      edgeStyle: state.edgeStyle,
+      showMinimap: state.showMinimap,
+      autoSaveEnabled: state.autoSaveEnabled,
+      recentModels: state.recentModels.slice(0, MAX_RECENT_MODELS),
+      hasSeenWelcome: state.hasSeenWelcome,
+      debugMode: state.debugMode
+    };
+    localStorage.setItem(STORAGE_KEY, JSON.stringify(toSave));
+  } catch {
+  }
+}
+var initialState = { ...DEFAULT_SETTINGS, ...loadFromStorage() };
+var useSettingsStore = create((set, get) => {
+  const setAndPersist = (updater) => {
+    set((state) => {
+      const newState = updater(state);
+      saveToStorage({ ...state, ...newState });
+      return newState;
+    });
+  };
+  return {
+    providers: initialState.providers,
+    defaults: initialState.defaults,
+    edgeStyle: initialState.edgeStyle,
+    showMinimap: initialState.showMinimap,
+    autoSaveEnabled: initialState.autoSaveEnabled,
+    recentModels: initialState.recentModels,
+    hasSeenWelcome: initialState.hasSeenWelcome,
+    debugMode: initialState.debugMode,
+    toggleAutoSave: () => {
+      setAndPersist((state) => ({ autoSaveEnabled: !state.autoSaveEnabled }));
+    },
+    setProviderKey: (provider, key) => {
+      setAndPersist((state) => ({
+        providers: {
+          ...state.providers,
+          [provider]: {
+            ...state.providers[provider],
+            apiKey: key,
+            enabled: key ? true : state.providers[provider].enabled
+          }
+        }
+      }));
+    },
+    setProviderEnabled: (provider, enabled) => {
+      setAndPersist((state) => ({
+        providers: {
+          ...state.providers,
+          [provider]: {
+            ...state.providers[provider],
+            enabled
+          }
+        }
+      }));
+    },
+    setDefaultModel: (type, model, provider) => {
+      setAndPersist((state) => ({
+        defaults: {
+          ...state.defaults,
+          ...type === "image" ? { imageModel: model, imageProvider: provider } : { videoModel: model, videoProvider: provider }
+        }
+      }));
+    },
+    setEdgeStyle: (style) => {
+      setAndPersist(() => ({ edgeStyle: style }));
+      import('./workflowStore-4EGKJLYK.mjs').then(({ useWorkflowStore: useWorkflowStore2 }) => {
+        useWorkflowStore2.getState().setEdgeStyle(style);
+      });
+    },
+    setShowMinimap: (show) => {
+      setAndPersist(() => ({ showMinimap: show }));
+    },
+    addRecentModel: (model) => {
+      setAndPersist((state) => {
+        const filtered = state.recentModels.filter(
+          (m) => !(m.id === model.id && m.provider === model.provider)
+        );
+        const newRecentModels = [{ ...model, timestamp: Date.now() }, ...filtered].slice(
+          0,
+          MAX_RECENT_MODELS
+        );
+        return { recentModels: newRecentModels };
+      });
+    },
+    clearProviderKey: (provider) => {
+      setAndPersist((state) => ({
+        providers: {
+          ...state.providers,
+          [provider]: {
+            ...state.providers[provider],
+            apiKey: null
+          }
+        }
+      }));
+    },
+    clearAllKeys: () => {
+      setAndPersist((state) => ({
+        providers: {
+          replicate: { ...state.providers.replicate, apiKey: null },
+          fal: { ...state.providers.fal, apiKey: null },
+          huggingface: { ...state.providers.huggingface, apiKey: null },
+          "genfeed-ai": { ...state.providers["genfeed-ai"], apiKey: null }
+        }
+      }));
+    },
+    setHasSeenWelcome: (seen) => {
+      setAndPersist(() => ({ hasSeenWelcome: seen }));
+    },
+    setDebugMode: (enabled) => {
+      setAndPersist(() => ({ debugMode: enabled }));
+    },
+    isProviderConfigured: (provider) => {
+      const state = get();
+      return !!state.providers[provider].apiKey;
+    },
+    getProviderHeader: (provider) => {
+      const state = get();
+      const key = state.providers[provider].apiKey;
+      if (!key) return {};
+      const headerMap = {
+        [import_types.ProviderTypeEnum.REPLICATE]: "X-Replicate-Key",
+        [import_types.ProviderTypeEnum.FAL]: "X-Fal-Key",
+        [import_types.ProviderTypeEnum.HUGGINGFACE]: "X-HF-Key",
+        [import_types.ProviderTypeEnum.GENFEED_AI]: "X-Genfeed-Key"
+      };
+      return { [headerMap[provider]]: key };
+    },
+    // API Sync - stubbed as no-ops (consuming app provides real implementations)
+    isSyncing: false,
+    syncFromServer: async () => {
+    },
+    syncToServer: async () => {
+    }
+  };
+});
+var PROVIDER_INFO = {
+  [import_types.ProviderTypeEnum.REPLICATE]: {
+    name: "Replicate",
+    description: "Access thousands of open-source AI models",
+    docsUrl: "https://replicate.com/docs"
+  },
+  [import_types.ProviderTypeEnum.FAL]: {
+    name: "fal.ai",
+    description: "Fast inference for image and video generation",
+    docsUrl: "https://fal.ai/docs"
+  },
+  [import_types.ProviderTypeEnum.HUGGINGFACE]: {
+    name: "Hugging Face",
+    description: "The AI community platform with 500k+ models",
+    docsUrl: "https://huggingface.co/docs/api-inference"
+  },
+  [import_types.ProviderTypeEnum.GENFEED_AI]: {
+    name: "Genfeed AI",
+    description: "Built-in models powered by Genfeed",
+    docsUrl: "https://genfeed.ai/docs"
+  }
+};
+
+// src/stores/execution/slices/executionSlice.ts
+var import_types3 = __toESM(require_dist());
+
+// src/stores/execution/helpers/sseSubscription.ts
+var import_types2 = __toESM(require_dist());
+
+// src/stores/execution/helpers/outputHelpers.ts
+function extractOutputValue(output) {
+  if (!output) return null;
+  if (typeof output === "string") {
+    return output;
+  }
+  if (Array.isArray(output) && output.length > 0) {
+    const first = output[0];
+    if (typeof first === "string") return first;
+    if (first && typeof first === "object" && "url" in first) {
+      return String(first.url);
+    }
+  }
+  if (typeof output === "object" && output !== null) {
+    const obj = output;
+    if ("url" in obj) return String(obj.url);
+    if ("image" in obj) return String(obj.image);
+    if ("video" in obj) return String(obj.video);
+    if ("audio" in obj) return String(obj.audio);
+  }
+  return null;
+}
+function extractAllOutputValues(output) {
+  if (!output) return [];
+  if (typeof output === "string") {
+    return [output];
+  }
+  if (Array.isArray(output)) {
+    return output.filter((item) => typeof item === "string");
+  }
+  if (typeof output === "object" && output !== null) {
+    const obj = output;
+    if ("images" in obj && Array.isArray(obj.images)) {
+      return obj.images.filter((item) => typeof item === "string");
+    }
+    if ("image" in obj && typeof obj.image === "string") {
+      return [obj.image];
+    }
+  }
+  return [];
+}
+function getOutputUpdate(nodeId, output, workflowStore) {
+  const node = workflowStore.getNodeById(nodeId);
+  if (!node) return {};
+  const nodeType = node.type;
+  const outputValue = extractOutputValue(output);
+  if (["imageGen"].includes(nodeType)) {
+    const allImages = extractAllOutputValues(output);
+    return {
+      outputImage: allImages[0] ?? null,
+      outputImages: allImages
+    };
+  }
+  if (["reframe", "upscale"].includes(nodeType)) {
+    const inputType = node.data.inputType;
+    if (inputType === "video") {
+      return { outputVideo: outputValue };
+    }
+    return { outputImage: outputValue };
+  }
+  if (["videoGen", "animation", "videoStitch", "lipSync", "voiceChange", "motionControl"].includes(
+    nodeType
+  )) {
+    return { outputVideo: outputValue };
+  }
+  if (nodeType === "textToSpeech") {
+    return { outputAudio: outputValue };
+  }
+  if (nodeType === "llm") {
+    const textOutput = Array.isArray(output) ? output.join("") : outputValue;
+    return { outputText: textOutput };
+  }
+  if (nodeType === "resize") {
+    return { outputMedia: outputValue };
+  }
+  return { output: outputValue };
+}
+
+// src/stores/execution/helpers/sseSubscription.ts
+var API_BASE_URL = process.env.NEXT_PUBLIC_API_URL || "http://local.genfeed.ai:3001/api";
+var statusMap = {
+  pending: import_types2.NodeStatusEnum.IDLE,
+  processing: import_types2.NodeStatusEnum.PROCESSING,
+  complete: import_types2.NodeStatusEnum.COMPLETE,
+  succeeded: import_types2.NodeStatusEnum.COMPLETE,
+  error: import_types2.NodeStatusEnum.ERROR
+};
+function applyJobUpdates(jobs, workflowStore, debugMode, set, filterNodeId) {
+  if (!jobs || jobs.length === 0) return;
+  set((state) => {
+    let didChange = false;
+    const newJobs = new Map(state.jobs);
+    const newDebugPayloads = [];
+    for (const job of jobs) {
+      if (filterNodeId && job.nodeId !== filterNodeId) continue;
+      const status = job.status;
+      const output = job.output ?? null;
+      const error = job.error ?? null;
+      const existing = state.jobs.get(job.predictionId);
+      if (!existing) {
+        didChange = true;
+        newJobs.set(job.predictionId, {
+          nodeId: job.nodeId,
+          predictionId: job.predictionId,
+          status,
+          progress: 0,
+          output,
+          error,
+          createdAt: (/* @__PURE__ */ new Date()).toISOString()
+        });
+      } else if (existing.status !== status || existing.output !== output || existing.error !== error) {
+        didChange = true;
+        newJobs.set(job.predictionId, {
+          ...existing,
+          status,
+          output,
+          error
+        });
+      }
+      if (job.result?.debugPayload) {
+        const node = workflowStore.getNodeById(job.nodeId);
+        newDebugPayloads.push({
+          nodeId: job.nodeId,
+          nodeName: String(node?.data?.label || node?.data?.name || job.nodeId),
+          nodeType: node?.type || "unknown",
+          model: job.result.debugPayload.model,
+          input: job.result.debugPayload.input,
+          timestamp: job.result.debugPayload.timestamp
+        });
+      }
+    }
+    if (!didChange && newDebugPayloads.length === 0) return state;
+    if (newDebugPayloads.length > 0 && debugMode) {
+      useUIStore.getState().setShowDebugPanel(true);
+    }
+    return {
+      jobs: didChange ? newJobs : state.jobs,
+      debugPayloads: newDebugPayloads.length > 0 ? [
+        ...state.debugPayloads.filter(
+          (existing) => !newDebugPayloads.some((newP) => newP.nodeId === existing.nodeId)
+        ),
+        ...newDebugPayloads
+      ] : state.debugPayloads
+    };
+  });
+}
+async function reconcileNodeStatuses(executionId) {
+  try {
+    const response = await fetch(`${API_BASE_URL}/executions/${executionId}`);
+    if (!response.ok) return;
+    const execution = await response.json();
+    const workflowStore = useWorkflowStore.getState();
+    for (const nodeResult of execution.nodeResults || []) {
+      const nodeStatus = statusMap[nodeResult.status] ?? import_types2.NodeStatusEnum.IDLE;
+      const isSuccess = nodeResult.status === "complete" || nodeResult.status === "succeeded";
+      workflowStore.updateNodeData(nodeResult.nodeId, {
+        status: nodeStatus,
+        error: isSuccess ? void 0 : nodeResult.error,
+        ...nodeResult.output && getOutputUpdate(nodeResult.nodeId, nodeResult.output, workflowStore)
+      });
+      if (isSuccess && nodeResult.output) {
+        workflowStore.propagateOutputsDownstream(nodeResult.nodeId);
+      }
+    }
+  } catch {
+  }
+}
+function createExecutionSubscription(executionId, set) {
+  const eventSource = new EventSource(`${API_BASE_URL}/executions/${executionId}/stream`);
+  const propagatedNodeIds = /* @__PURE__ */ new Set();
+  set({ eventSource });
+  eventSource.onmessage = (event) => {
+    void (async () => {
+      try {
+        const data = JSON.parse(event.data);
+        const workflowStore = useWorkflowStore.getState();
+        const nodeResults = data.nodeResults || [];
+        for (const nodeResult of nodeResults) {
+          const nodeStatus = statusMap[nodeResult.status] ?? import_types2.NodeStatusEnum.IDLE;
+          const isSuccess = nodeResult.status === "complete" || nodeResult.status === "succeeded";
+          workflowStore.updateNodeData(nodeResult.nodeId, {
+            status: nodeStatus,
+            error: isSuccess ? void 0 : nodeResult.error,
+            ...nodeResult.output && getOutputUpdate(nodeResult.nodeId, nodeResult.output, workflowStore)
+          });
+          if ((nodeResult.status === "complete" || nodeResult.status === "succeeded") && nodeResult.output && !propagatedNodeIds.has(nodeResult.nodeId)) {
+            propagatedNodeIds.add(nodeResult.nodeId);
+            workflowStore.propagateOutputsDownstream(nodeResult.nodeId);
+          }
+          if (nodeResult.status === "error") {
+            set({ lastFailedNodeId: nodeResult.nodeId });
+          }
+        }
+        applyJobUpdates(data.jobs, workflowStore, data.debugMode, set);
+        const isComplete = ["completed", "failed", "cancelled", "error"].includes(data.status);
+        const hasFailedNode = (data.nodeResults || []).some((r) => r.status === "error");
+        const hasPendingNodes = (data.pendingNodes || []).length > 0;
+        const hasProcessingNodes = (data.nodeResults || []).some((r) => r.status === "processing");
+        const isDone = isComplete || hasFailedNode && !hasPendingNodes && !hasProcessingNodes;
+        if (isDone) {
+          propagatedNodeIds.clear();
+          eventSource.close();
+          await reconcileNodeStatuses(executionId);
+          set({ isRunning: false, eventSource: null, currentNodeId: null, jobs: /* @__PURE__ */ new Map() });
+          if (data.status === "failed" || hasFailedNode) {
+          }
+        }
+      } catch {
+      }
+    })();
+  };
+  eventSource.onerror = () => {
+    eventSource.close();
+    void reconcileNodeStatuses(executionId).then(() => {
+      set({ isRunning: false, eventSource: null });
+    });
+  };
+  return eventSource;
+}
+function createNodeExecutionSubscription(executionId, nodeId, set, _get) {
+  const eventSource = new EventSource(`${API_BASE_URL}/executions/${executionId}/stream`);
+  const propagatedNodeIds = /* @__PURE__ */ new Set();
+  eventSource.onmessage = (event) => {
+    void (async () => {
+      try {
+        const data = JSON.parse(event.data);
+        const workflowStore = useWorkflowStore.getState();
+        const nodeResults = data.nodeResults || [];
+        for (const nodeResult of nodeResults) {
+          const nodeStatus = statusMap[nodeResult.status] ?? import_types2.NodeStatusEnum.IDLE;
+          const isSuccess = nodeResult.status === "complete" || nodeResult.status === "succeeded";
+          workflowStore.updateNodeData(nodeResult.nodeId, {
+            status: nodeStatus,
+            error: isSuccess ? void 0 : nodeResult.error,
+            ...nodeResult.output && getOutputUpdate(nodeResult.nodeId, nodeResult.output, workflowStore)
+          });
+          if ((nodeResult.status === "complete" || nodeResult.status === "succeeded") && nodeResult.output && !propagatedNodeIds.has(nodeResult.nodeId)) {
+            propagatedNodeIds.add(nodeResult.nodeId);
+            workflowStore.propagateOutputsDownstream(nodeResult.nodeId);
+          }
+          if (nodeResult.status === "error") {
+            set({ lastFailedNodeId: nodeResult.nodeId });
+          }
+        }
+        applyJobUpdates(data.jobs, workflowStore, data.debugMode, set, nodeId);
+        const isComplete = ["completed", "failed", "cancelled", "error"].includes(data.status);
+        const hasFailedNode = (data.nodeResults || []).some((r) => r.status === "error");
+        const hasPendingNodes = (data.pendingNodes || []).length > 0;
+        const hasProcessingNodes = (data.nodeResults || []).some((r) => r.status === "processing");
+        const isDone = isComplete || hasFailedNode && !hasPendingNodes && !hasProcessingNodes;
+        if (isDone) {
+          propagatedNodeIds.clear();
+          eventSource.close();
+          await reconcileNodeStatuses(executionId);
+          set((state) => {
+            const newMap = new Map(state.activeNodeExecutions);
+            newMap.delete(nodeId);
+            return { activeNodeExecutions: newMap };
+          });
+        }
+      } catch {
+      }
+    })();
+  };
+  eventSource.onerror = () => {
+    eventSource.close();
+    void reconcileNodeStatuses(executionId).then(() => {
+      set((state) => {
+        const newMap = new Map(state.activeNodeExecutions);
+        newMap.delete(nodeId);
+        return { activeNodeExecutions: newMap };
+      });
+    });
+  };
+  return eventSource;
+}
+
+// src/stores/execution/slices/executionSlice.ts
+var API_BASE_URL2 = process.env.NEXT_PUBLIC_API_URL || "http://local.genfeed.ai:3001/api";
+async function apiPost(path, body) {
+  const response = await fetch(`${API_BASE_URL2}${path}`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    ...body && { body: JSON.stringify(body) }
+  });
+  if (!response.ok) {
+    const errorData = await response.json().catch(() => ({}));
+    throw new Error(errorData.message || `API error: ${response.status}`);
+  }
+  return response.json();
+}
+var createExecutionSlice = (set, get) => ({
+  executeWorkflow: async () => {
+    const { isRunning, resetExecution } = get();
+    if (isRunning) return;
+    const workflowStore = useWorkflowStore.getState();
+    const debugMode = useSettingsStore.getState().debugMode;
+    const validation = workflowStore.validateWorkflow();
+    if (!validation.isValid) {
+      set({ validationErrors: validation });
+      return;
+    }
+    set({ validationErrors: null });
+    resetExecution();
+    if (debugMode) {
+      useUIStore.getState().setShowDebugPanel(true);
+    }
+    if (workflowStore.isDirty || !workflowStore.workflowId) {
+      try {
+        await workflowStore.saveWorkflow();
+      } catch {
+        set({
+          validationErrors: {
+            isValid: false,
+            errors: [{ nodeId: "", message: "Failed to save workflow", severity: "error" }],
+            warnings: []
+          }
+        });
+        return;
+      }
+    }
+    const workflowId = workflowStore.workflowId;
+    if (!workflowId) {
+      set({
+        validationErrors: {
+          isValid: false,
+          errors: [{ nodeId: "", message: "Workflow must be saved first", severity: "error" }],
+          warnings: []
+        }
+      });
+      return;
+    }
+    set({ isRunning: true });
+    for (const node of workflowStore.nodes) {
+      workflowStore.updateNodeData(node.id, {
+        status: import_types3.NodeStatusEnum.IDLE,
+        error: void 0,
+        progress: void 0
+      });
+    }
+    try {
+      const execution = await apiPost(`/workflows/${workflowId}/execute`, {
+        debugMode
+      });
+      const executionId = execution._id;
+      set({ executionId });
+      createExecutionSubscription(executionId, set);
+    } catch (error) {
+      set({
+        isRunning: false,
+        validationErrors: {
+          isValid: false,
+          errors: [
+            {
+              nodeId: "",
+              message: error instanceof Error ? error.message : "Execution failed",
+              severity: "error"
+            }
+          ],
+          warnings: []
+        }
+      });
+    }
+  },
+  executeNode: async (nodeId) => {
+    const workflowStore = useWorkflowStore.getState();
+    const debugMode = useSettingsStore.getState().debugMode;
+    if (workflowStore.isDirty || !workflowStore.workflowId) {
+      try {
+        await workflowStore.saveWorkflow();
+      } catch {
+        workflowStore.updateNodeData(nodeId, {
+          status: import_types3.NodeStatusEnum.ERROR,
+          error: "Failed to save workflow"
+        });
+        return;
+      }
+    }
+    const workflowId = workflowStore.workflowId;
+    if (!workflowId) {
+      workflowStore.updateNodeData(nodeId, {
+        status: import_types3.NodeStatusEnum.ERROR,
+        error: "Workflow must be saved first"
+      });
+      return;
+    }
+    if (debugMode) {
+      useUIStore.getState().setShowDebugPanel(true);
+    }
+    try {
+      const execution = await apiPost(`/workflows/${workflowId}/execute`, {
+        debugMode,
+        selectedNodeIds: [nodeId]
+      });
+      const executionId = execution._id;
+      const eventSource = createNodeExecutionSubscription(executionId, nodeId, set, get);
+      const nodeExecution = {
+        executionId,
+        nodeIds: [nodeId],
+        eventSource
+      };
+      set((state) => {
+        const newMap = new Map(state.activeNodeExecutions);
+        newMap.set(nodeId, nodeExecution);
+        return { activeNodeExecutions: newMap };
+      });
+    } catch (error) {
+      workflowStore.updateNodeData(nodeId, {
+        status: import_types3.NodeStatusEnum.ERROR,
+        error: error instanceof Error ? error.message : "Node execution failed"
+      });
+    }
+  },
+  executeSelectedNodes: async () => {
+    const { isRunning, resetExecution } = get();
+    if (isRunning) return;
+    const workflowStore = useWorkflowStore.getState();
+    const debugMode = useSettingsStore.getState().debugMode;
+    const { selectedNodeIds } = workflowStore;
+    if (selectedNodeIds.length === 0) {
+      set({
+        validationErrors: {
+          isValid: false,
+          errors: [{ nodeId: "", message: "No nodes selected", severity: "error" }],
+          warnings: []
+        }
+      });
+      return;
+    }
+    set({ validationErrors: null });
+    resetExecution();
+    if (workflowStore.isDirty || !workflowStore.workflowId) {
+      try {
+        await workflowStore.saveWorkflow();
+      } catch {
+        set({
+          validationErrors: {
+            isValid: false,
+            errors: [{ nodeId: "", message: "Failed to save workflow", severity: "error" }],
+            warnings: []
+          }
+        });
+        return;
+      }
+    }
+    const workflowId = workflowStore.workflowId;
+    if (!workflowId) {
+      set({
+        validationErrors: {
+          isValid: false,
+          errors: [{ nodeId: "", message: "Workflow must be saved first", severity: "error" }],
+          warnings: []
+        }
+      });
+      return;
+    }
+    set({ isRunning: true, executingNodeIds: selectedNodeIds });
+    if (debugMode) {
+      useUIStore.getState().setShowDebugPanel(true);
+    }
+    for (const nodeId of selectedNodeIds) {
+      workflowStore.updateNodeData(nodeId, {
+        status: import_types3.NodeStatusEnum.IDLE,
+        error: void 0,
+        progress: void 0
+      });
+    }
+    try {
+      const execution = await apiPost(`/workflows/${workflowId}/execute`, {
+        debugMode,
+        selectedNodeIds
+      });
+      const executionId = execution._id;
+      set({ executionId });
+      createExecutionSubscription(executionId, set);
+    } catch (error) {
+      set({
+        isRunning: false,
+        validationErrors: {
+          isValid: false,
+          errors: [
+            {
+              nodeId: "",
+              message: error instanceof Error ? error.message : "Partial execution failed",
+              severity: "error"
+            }
+          ],
+          warnings: []
+        }
+      });
+    }
+  },
+  resumeFromFailed: async () => {
+    const { isRunning, executionId, lastFailedNodeId } = get();
+    if (isRunning || !executionId || !lastFailedNodeId) return;
+    const workflowStore = useWorkflowStore.getState();
+    const debugMode = useSettingsStore.getState().debugMode;
+    const workflowId = workflowStore.workflowId;
+    if (!workflowId) {
+      set({
+        validationErrors: {
+          isValid: false,
+          errors: [{ nodeId: "", message: "Workflow must be saved first", severity: "error" }],
+          warnings: []
+        }
+      });
+      return;
+    }
+    set({ isRunning: true, validationErrors: null });
+    if (debugMode) {
+      useUIStore.getState().setShowDebugPanel(true);
+    }
+    workflowStore.updateNodeData(lastFailedNodeId, {
+      status: import_types3.NodeStatusEnum.IDLE,
+      error: void 0,
+      progress: void 0
+    });
+    try {
+      const execution = await apiPost(`/workflows/${workflowId}/execute`, {
+        debugMode
+      });
+      const newExecutionId = execution._id;
+      set({ executionId: newExecutionId, lastFailedNodeId: null });
+      createExecutionSubscription(newExecutionId, set);
+    } catch (error) {
+      set({
+        isRunning: false,
+        validationErrors: {
+          isValid: false,
+          errors: [
+            {
+              nodeId: "",
+              message: error instanceof Error ? error.message : "Resume failed",
+              severity: "error"
+            }
+          ],
+          warnings: []
+        }
+      });
+    }
+  },
+  stopExecution: () => {
+    const { eventSource, executionId } = get();
+    if (eventSource) {
+      eventSource.close();
+    }
+    if (executionId) {
+      apiPost(`/executions/${executionId}/stop`).catch(() => {
+      });
+    }
+    set({
+      isRunning: false,
+      eventSource: null,
+      currentNodeId: null
+    });
+  },
+  stopNodeExecution: (nodeId) => {
+    const { activeNodeExecutions } = get();
+    const nodeExecution = activeNodeExecutions.get(nodeId);
+    if (nodeExecution) {
+      nodeExecution.eventSource.close();
+      apiPost(`/executions/${nodeExecution.executionId}/stop`).catch(() => {
+      });
+      set((state) => {
+        const newMap = new Map(state.activeNodeExecutions);
+        newMap.delete(nodeId);
+        return { activeNodeExecutions: newMap };
+      });
+    }
+    const workflowStore = useWorkflowStore.getState();
+    workflowStore.updateNodeData(nodeId, { status: import_types3.NodeStatusEnum.IDLE, error: void 0 });
+  },
+  isNodeExecuting: (nodeId) => {
+    const { activeNodeExecutions } = get();
+    return activeNodeExecutions.has(nodeId);
+  },
+  clearValidationErrors: () => {
+    set({ validationErrors: null });
+  },
+  resetExecution: () => {
+    const { eventSource, activeNodeExecutions } = get();
+    if (eventSource) {
+      eventSource.close();
+    }
+    for (const nodeExecution of activeNodeExecutions.values()) {
+      nodeExecution.eventSource.close();
+    }
+    set({
+      isRunning: false,
+      jobs: /* @__PURE__ */ new Map(),
+      executionId: null,
+      currentNodeId: null,
+      executingNodeIds: [],
+      eventSource: null,
+      actualCost: 0,
+      lastFailedNodeId: null,
+      debugPayloads: [],
+      activeNodeExecutions: /* @__PURE__ */ new Map()
+    });
+    const workflowStore = useWorkflowStore.getState();
+    for (const node of workflowStore.nodes) {
+      workflowStore.updateNodeData(node.id, {
+        status: import_types3.NodeStatusEnum.IDLE,
+        error: void 0,
+        progress: void 0
+      });
+    }
+  },
+  canResumeFromFailed: () => {
+    const { executionId, lastFailedNodeId, isRunning } = get();
+    return !isRunning && Boolean(executionId) && Boolean(lastFailedNodeId);
+  },
+  setEstimatedCost: (cost) => {
+    set({ estimatedCost: cost });
+  }
+});
+
+// src/stores/execution/slices/jobSlice.ts
+var createJobSlice = (set, get) => ({
+  addJob: (nodeId, predictionId) => {
+    set((state) => {
+      const newJobs = new Map(state.jobs);
+      newJobs.set(predictionId, {
+        nodeId,
+        predictionId,
+        status: "pending",
+        progress: 0,
+        output: null,
+        error: null,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      return { jobs: newJobs };
+    });
+  },
+  updateJob: (predictionId, updates) => {
+    set((state) => {
+      const newJobs = new Map(state.jobs);
+      const job = newJobs.get(predictionId);
+      if (job) {
+        newJobs.set(predictionId, { ...job, ...updates });
+      }
+      return { jobs: newJobs };
+    });
+  },
+  getJobByNodeId: (nodeId) => {
+    const { jobs } = get();
+    for (const job of jobs.values()) {
+      if (job.nodeId === nodeId) return job;
+    }
+    return void 0;
+  }
+});
+
+// src/stores/execution/executionStore.ts
+var useExecutionStore = create()((...args) => {
+  const [set] = args;
+  return {
+    // Initial state
+    isRunning: false,
+    executionId: null,
+    currentNodeId: null,
+    executingNodeIds: [],
+    validationErrors: null,
+    eventSource: null,
+    lastFailedNodeId: null,
+    pausedAtNodeId: null,
+    jobs: /* @__PURE__ */ new Map(),
+    estimatedCost: 0,
+    actualCost: 0,
+    debugPayloads: [],
+    activeNodeExecutions: /* @__PURE__ */ new Map(),
+    // Debug payload actions
+    addDebugPayload: (payload) => {
+      set((state) => ({
+        debugPayloads: [...state.debugPayloads, payload]
+      }));
+    },
+    clearDebugPayloads: () => {
+      set({ debugPayloads: [] });
+    },
+    // Compose slices
+    ...createJobSlice(...args),
+    ...createExecutionSlice(...args)
+  };
+});
+
+export { PROVIDER_INFO, useExecutionStore, useSettingsStore, useUIStore };