Skip to content

Self-improving AI Employees for everyone

7.9 KB
Raw Blame
import { useCallback } from 'react';
import { Edge, Node } from 'reactflow';
import { toast } from 'sonner';
import { useAppStore } from '../store/useAppStore';
import { createBrowserAgent } from '../services/browserAgentApi';
import { createAgent, createSavedGraphResource } from '../services/agentCreationApi';
import { addSavedNodes, addSavedEdges } from '../lib/workflowOps';
import { snapToGrid, getDefaultNodePosition, nextNodeInstanceId } from '../utils/workflow';
import { theme } from '../styles/theme';
import { getCachedNodeSpec } from '../lib/nodeSpec';

import { resolveNodeDescription } from '../lib/nodeSpec';
// Wave 10.E: agent detection reads `componentKind: "agent"` from the
// backend NodeSpec. Falls back to the node-definition group during the
// brief window before the spec cache warms.
const isAgentType = (nodeType: string): boolean => {
  const spec = getCachedNodeSpec(nodeType);
  if (spec?.componentKind === 'agent') return true;
  return nodeType === 'aiAgent' || nodeType === 'chatAgent';
};

interface UseDragAndDropProps {
  nodes: Node[];
  setNodes: (nodes: Node[] | ((nodes: Node[]) => Node[])) => void;
  edges?: Edge[];
  setEdges?: (edges: Edge[] | ((edges: Edge[]) => Edge[])) => void;
  saveNodeParameters?: (nodeId: string, parameters: Record<string, any>) => Promise<boolean>;
  globalModelDefaults?: { provider: string; model: string } | null;
  workflowId: string;
  flushCanvas?: () => void;
  /** React Flow's `screenToFlowPosition`: turns a pointer position into
   *  canvas coordinates, accounting for the pane's offset, pan and zoom. */
  screenToFlowPosition: (position: { x: number; y: number }) => { x: number; y: number };
}

/**
 * Generate a unique label for a new node (n8n pattern).
 * First node of type: "Cron Scheduler"
 * Second node of type: "Cron Scheduler 1"
 * Third node of type: "Cron Scheduler 2"
 */
export const generateUniqueLabel = (displayName: string, nodeType: string, existingNodes: Node[]): string => {
  // Collect all labels from nodes of the same type
  const existingLabels = existingNodes
    .filter(n => n.type === nodeType)
    .map(n => n.data?.label as string | undefined)
    .filter((label): label is string => !!label);

  // If no nodes have this base displayName, use it as-is
  if (!existingLabels.includes(displayName)) {
    return displayName;
  }

  // Find next available suffix
  let suffix = 1;
  while (existingLabels.includes(`${displayName} ${suffix}`)) {
    suffix++;
  }
  return `${displayName} ${suffix}`;
};

export const useDragAndDrop = ({ nodes, setNodes, edges = [], setEdges, saveNodeParameters, globalModelDefaults, workflowId, screenToFlowPosition, flushCanvas }: UseDragAndDropProps) => {
  const onDragOver = useCallback((event: React.DragEvent) => {
    event.preventDefault();
    event.dataTransfer.dropEffect = 'move';
  }, []);

  const onDrop = useCallback(
    async (event: React.DragEvent) => {
      event.preventDefault();

      try {
        const nodeData = JSON.parse(event.dataTransfer.getData('application/reactflow'));
        if (!nodeData || !nodeData.type) {
          return;
        }

        // Canvas coordinates under the pointer. The drop target's own rect
        // is not used: it ignores pan and zoom, and when the drop lands on
        // an existing node it is that node's rect, not the canvas's.
        const pointer = screenToFlowPosition({ x: event.clientX, y: event.clientY });

        let position = {
          x: pointer.x - theme.constants.dragOffset.x,
          y: pointer.y - theme.constants.dragOffset.y,
        };

        // Snap to grid for better alignment
        position = snapToGrid(position);

        // If no nodes exist, use default position
        if (nodes.length === 0) {
          position = getDefaultNodePosition(nodes.length);
        }

        const spec = getCachedNodeSpec(nodeData.type);
        const authoritativeAgent = spec?.componentKind === 'agent' && spec?.uiHints?.creationParameters?.runtime_behavior_version === 1;
        if (spec?.uiHints?.createsBrowserAgent || authoritativeAgent) {
          const store = useAppStore.getState();
          if (!setEdges || !store.currentWorkflow || store.currentWorkflow.id !== workflowId) {
            toast.error('Open a workflow before adding an agent.');
            return;
          }
          const mutationId = crypto.randomUUID();
          const create = async () => {
            try {
              const result = await createSavedGraphResource(workflowId,
                flushCanvas ?? (() => useAppStore.getState().updateWorkflow({ nodes, edges })),
                () => spec?.uiHints?.createsBrowserAgent
                  ? createBrowserAgent({ workflow_id: workflowId, position: [position.x, position.y], ...(globalModelDefaults || {}) }, mutationId)
                  : createAgent({ workflow_id: workflowId, node_type: nodeData.type, position: [position.x, position.y],
                    parameters: { ...(nodeData.data || {}), ...(globalModelDefaults || {}) } }, mutationId));
              if (!result) return;
              if (useAppStore.getState().currentWorkflow?.id === workflowId) {
                setNodes(current => addSavedNodes(current, result.operations));
                setEdges(current => addSavedEdges(current, result.operations));
              }
            } catch (error) {
              toast.error(error instanceof Error ? error.message : 'Could not create the agent.', { action: { label: 'Retry', onClick: () => void create() } });
            }
          };
          await create();
          return;
        }

        // Get node definition to access displayName
        const nodeDef = resolveNodeDescription(nodeData.type);
        const displayName = nodeDef?.displayName || nodeData.type;

        // Generate unique label for template variable resolution (n8n pattern)
        const uniqueLabel = generateUniqueLabel(displayName, nodeData.type, nodes);

        const newNode: Node = {
          id: nextNodeInstanceId(workflowId, nodeData.type, nodes),
          type: nodeData.type,
          position,
          data: {
            label: uniqueLabel,  // Only UI-display fields in node.data (not parameters)
          },
        };

        // Save full default parameters to DB only (not to node.data)
        const defaults = nodeData.data || {};

        // Apply global model defaults for agent nodes (componentKind="agent")
        if (globalModelDefaults && isAgentType(nodeData.type)) {
          defaults.provider = globalModelDefaults.provider;
          defaults.model = globalModelDefaults.model;
        }

        if (Object.keys(defaults).length > 0 && saveNodeParameters) {
          try {
            await saveNodeParameters(newNode.id, { ...defaults, label: uniqueLabel });
            console.log(`[DragAndDrop] Saved default parameters for node ${newNode.id}`);
          } catch (error) {
            console.error(`[DragAndDrop] Failed to save parameters for node ${newNode.id}:`, error);
          }
        }

        setNodes((nds) => nds.concat(newNode));
      } catch (error) {
        console.error('Error dropping node:', error);
        toast.error(error instanceof Error ? error.message : 'Could not add node.');
      }
    },
    [setNodes, nodes, edges, setEdges, saveNodeParameters, globalModelDefaults, workflowId, screenToFlowPosition, flushCanvas]
  );

  const handleComponentDragStart = useCallback((event: React.DragEvent, definition: any) => {
    const defaults: any = {};
    // Handle both old (parameters) and new (properties) interface formats
    const properties = definition.properties || definition.parameters || [];
    properties.forEach((param: any) => {
      defaults[param.name] = param.default;
    });
    event.dataTransfer.setData('application/reactflow', JSON.stringify({ 
      type: definition.name || definition.type, // Handle both new (name) and old (type) formats
      data: defaults 
    }));
    event.dataTransfer.effectAllowed = 'move';
  }, []);

  return {
    onDragOver,
    onDrop,
    handleComponentDragStart,
  };
};