@foresthubai/workflow-builder 0.3.0

package/dist/utils/functionOperations.js

@@ -0,0 +1,140 @@
+import { generateId } from "@foresthubai/workflow-core/id";
+import { ensureUid } from "@foresthubai/workflow-core/variable";
+import { useEditorStore } from "../stores/editorStore";
+import { getCanvasStore, getOrCreateCanvasStore, deleteCanvasStore, syncFunctionArgVariables, notifyCanvasRegistryChange, } from "../stores/canvasStore";
+import { uniqueName } from "./resourceHelpers";
+/**
+ * Functions are a project-scoped resource: the declaration ({@link FunctionDeclaration}
+ * — signature + bundled output assignments) lives in editorStore, the body lives in
+ * the matching canvas store (id === fn.id). These operations keep the two in sync.
+ * Like channel/memory/model operations they write straight to the store (no undo
+ * history). A declaration change (name/arguments/outputs) forward-reconciles call
+ * sites via the migration subscription; an output *expression* edit does not (call
+ * sites never see the callee's expressions), so it doesn't bump the version.
+ */
+const emptyExpression = (dataType) => ({ expression: "", references: [], dataType });
+/** Re-derive the body's fnarg variables from the declaration's current arguments. */
+function syncBody(fn) {
+    const store = getCanvasStore(fn.id);
+    if (store)
+        syncFunctionArgVariables(store, fn.arguments);
+}
+/**
+ * Apply an update to one function. `bumpVersion` is true for signature changes
+ * (name/arguments/outputs declaration) so call sites detect staleness, and false for
+ * pure output-expression edits. Version-bumping changes re-sync the body's fnargs.
+ */
+function mutate(id, updater, bumpVersion) {
+    let next;
+    useEditorStore.getState().setFunctions((fns) => {
+        const fn = fns[id];
+        if (!fn)
+            return fns;
+        const updated = updater(fn);
+        next = bumpVersion ? { ...updated, version: fn.version + 1 } : updated;
+        return { ...fns, [id]: next };
+    });
+    if (next && bumpVersion)
+        syncBody(next);
+}
+/** Create a new (empty) function + its body canvas. Returns the new definition. */
+export function addFunction() {
+    const id = generateId();
+    const existing = Object.values(useEditorStore.getState().functions).map((f) => f.name);
+    const fn = {
+        id,
+        version: 1,
+        name: uniqueName("function", existing),
+        arguments: [],
+        outputs: [],
+    };
+    useEditorStore.getState().setFunctions((fns) => ({ ...fns, [id]: fn }));
+    // Create the body canvas (seeds an OnFunctionCall node) and watch it.
+    getOrCreateCanvasStore(id);
+    notifyCanvasRegistryChange();
+    return fn;
+}
+/** Delete a function: its declaration, its body canvas, and any selection of it. */
+export function deleteFunction(id) {
+    useEditorStore.getState().setFunctions((fns) => {
+        const { [id]: _drop, ...rest } = fns;
+        return rest;
+    });
+    deleteCanvasStore(id);
+    const sel = useEditorStore.getState().selection;
+    if (sel.kind === "function" && sel.id === id) {
+        useEditorStore.getState().clearSelection();
+    }
+}
+/** Rename a function. Call-site migration detects this via the name comparison, so
+ *  it needs no version bump. */
+export function renameFunction(id, name) {
+    mutate(id, (fn) => ({ ...fn, name }), false);
+}
+// ── Input arguments (declarations) ─────────────────────────────────────────────
+export function addArgument(id) {
+    mutate(id, (fn) => ({
+        ...fn,
+        arguments: [...fn.arguments, ensureUid({ name: `input${fn.arguments.length + 1}`, dataType: "string" })],
+    }), true);
+}
+export function updateArgument(id, index, patch) {
+    mutate(id, (fn) => {
+        const existing = fn.arguments[index];
+        if (!existing)
+            return fn;
+        const next = [...fn.arguments];
+        next[index] = { ...existing, ...patch };
+        return { ...fn, arguments: next };
+    }, true);
+}
+export function removeArgument(id, index) {
+    mutate(id, (fn) => ({ ...fn, arguments: fn.arguments.filter((_, i) => i !== index) }), true);
+}
+// ── Outputs (declaration + assignment bundled) ─────────────────────────────────
+export function addOutput(id) {
+    mutate(id, (fn) => {
+        const dataType = "string";
+        return {
+            ...fn,
+            outputs: [...fn.outputs, { uid: generateId(), name: `output${fn.outputs.length + 1}`, dataType, expression: emptyExpression(dataType) }],
+        };
+    }, true);
+}
+/** Update an output's declaration (name/dataType). A dataType change retags the
+ *  bundled expression's dataType but keeps the entered text. */
+export function updateOutput(id, index, patch) {
+    mutate(id, (fn) => {
+        const existing = fn.outputs[index];
+        if (!existing)
+            return fn;
+        const dataType = patch.dataType ?? existing.dataType;
+        const next = [...fn.outputs];
+        next[index] = {
+            ...existing,
+            ...patch,
+            dataType,
+            expression: patch.dataType ? { ...existing.expression, dataType } : existing.expression,
+        };
+        return { ...fn, outputs: next };
+    }, true);
+}
+export function removeOutput(id, index) {
+    mutate(id, (fn) => ({ ...fn, outputs: fn.outputs.filter((_, i) => i !== index) }), true);
+}
+/** Set one output's return-value expression. Not a signature change → no version bump. */
+export function setOutputExpression(id, index, expression) {
+    mutate(id, (fn) => {
+        const existing = fn.outputs[index];
+        if (!existing)
+            return fn;
+        const next = [...fn.outputs];
+        next[index] = { ...existing, expression };
+        return { ...fn, outputs: next };
+    }, false);
+}
+/** Read a function declaration without subscribing (for non-component callers). */
+export function getFunction(id) {
+    return useEditorStore.getState().functions[id];
+}
+//# sourceMappingURL=functionOperations.js.map

package/dist/utils/functionOperations.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"functionOperations.js","sourceRoot":"","sources":["../../src/utils/functionOperations.ts"],"names":[],"mappings":"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"}

package/dist/utils/graphOperations.d.ts

@@ -0,0 +1,54 @@
+import { NodeDefinition, NodeData, NodeType } from "@foresthubai/workflow-core/node";
+import type { FunctionInfo } from "@foresthubai/workflow-core/function";
+import { Connection, Edge, Node } from "@xyflow/react";
+import type { EdgeData, EdgeType } from "@foresthubai/workflow-core/edge";
+import { CanvasStore } from "../stores/canvasStore";
+/** Check if a node definition can be added to the store (respects isUnremovable and isSingleton). */
+export declare function canAddNode(store: CanvasStore, nodeDef: NodeDefinition): boolean;
+/** Add a node to the store given a node definition and optional position. Returns the new node ID, or null if the node cannot be added. */
+export declare function addNodeToStore(store: CanvasStore, nodeDef: NodeDefinition, position?: {
+    x: number;
+    y: number;
+}): string | null;
+/**
+ * Update a node's data in the store. Returns true if the node was found and updated.
+ *
+ * FunctionCallNode is no longer a special case — its arguments are flat, so the same
+ * shallow-merge path handles input edits, output binding edits, and migrations uniformly.
+ * Migration callers simply pass the full replacement arguments record alongside
+ * `functionInfo`; normal edits pass the single changed key.
+ */
+export declare function updateNodeInStore(store: CanvasStore, nodeId: string, updates: {
+    arguments?: Record<string, unknown>;
+    label?: string;
+    functionInfo?: FunctionInfo;
+}): boolean;
+/**
+ * Delete a node from the store, removing connected edges and variables.
+ * Takes optional getNodeDefinition callback for isUnremovable check.
+ * Returns true if the node was deleted.
+ */
+export declare function deleteNodeFromStore(store: CanvasStore, nodeId: string, getNodeDefinition?: (node: NodeData) => NodeDefinition | undefined): boolean;
+/** Add an edge if the connection is valid. Returns true if the edge was added. */
+export declare function connectNodesInStore(store: CanvasStore, connection: Connection): EdgeType | false;
+/** Update an edge's data in the store. Returns true if the edge was found and updated. */
+export declare function updateEdgeInStore(store: CanvasStore, edgeId: string, updates: Record<string, unknown>): boolean;
+/** Delete edges by ID from the store. */
+export declare function deleteEdgesFromStore(store: CanvasStore, edgeIds: string[]): void;
+export interface Clipboard {
+    nodes: Node<NodeData>[];
+    edges: Edge<EdgeData>[];
+}
+export interface PasteResult {
+    pasted: boolean;
+    /** Labels of nodes that were skipped because they cannot be added (singleton already present or unremovable). */
+    skippedLabels: string[];
+}
+/** Paste clipboard contents into the store with new IDs and optional position offset. */
+export declare function pasteToStore(store: CanvasStore, clipboard: Clipboard, offset?: {
+    x: number;
+    y: number;
+}, getNodeDefinition?: (node: NodeData) => NodeDefinition | undefined): PasteResult;
+/** Determine React Flow node type based on NodeCategory */
+export declare function getReactFlowType(type: NodeType): string;
+//# sourceMappingURL=graphOperations.d.ts.map

package/dist/utils/graphOperations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graphOperations.d.ts","sourceRoot":"","sources":["../../src/utils/graphOperations.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,cAAc,EACd,QAAQ,EAGR,QAAQ,EAMT,MAAM,iCAAiC,CAAC;AAEzC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qCAAqC,CAAC;AAExE,OAAO,EAAW,UAAU,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AAChE,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,iCAAiC,CAAC;AAC1E,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAoEpD,qGAAqG;AACrG,wBAAgB,UAAU,CAAC,KAAK,EAAE,WAAW,EAAE,OAAO,EAAE,cAAc,GAAG,OAAO,CAO/E;AAED,2IAA2I;AAC3I,wBAAgB,cAAc,CAAC,KAAK,EAAE,WAAW,EAAE,OAAO,EAAE,cAAc,EAAE,QAAQ,CAAC,EAAE;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,MAAM,GAAG,IAAI,CA2E9H;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,WAAW,EAClB,MAAM,EAAE,MAAM,EACd,OAAO,EAAE;IACP,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACpC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,YAAY,CAAC,EAAE,YAAY,CAAC;CAC7B,GACA,OAAO,CAoFT;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,WAAW,EAClB,MAAM,EAAE,MAAM,EACd,iBAAiB,CAAC,EAAE,CAAC,IAAI,EAAE,QAAQ,KAAK,cAAc,GAAG,SAAS,GACjE,OAAO,CA4BT;AAoBD,kFAAkF;AAClF,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,UAAU,GAAG,QAAQ,GAAG,KAAK,CAahG;AAED,0FAA0F;AAC1F,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAO/G;AAED,yCAAyC;AACzC,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,WAAW,EAAE,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI,CAIhF;AAMD,MAAM,WAAW,SAAS;IACxB,KAAK,EAAE,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC;IACxB,KAAK,EAAE,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC;CACzB;AAED,MAAM,WAAW,WAAW;IAC1B,MAAM,EAAE,OAAO,CAAC;IAChB,iHAAiH;IACjH,aAAa,EAAE,MAAM,EAAE,CAAC;CACzB;AAED,yFAAyF;AACzF,wBAAgB,YAAY,CAC1B,KAAK,EAAE,WAAW,EAClB,SAAS,EAAE,SAAS,EACpB,MAAM,GAAE;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAqB,EACnD,iBAAiB,CAAC,EAAE,CAAC,IAAI,EAAE,QAAQ,KAAK,cAAc,GAAG,SAAS,GACjE,WAAW,CA+Fb;AAoDD,2DAA2D;AAC3D,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,QAAQ,GAAG,MAAM,CAavD"}

package/dist/utils/graphOperations.js

@@ -0,0 +1,461 @@
+import { NodeCategory, NodeRegistry, getArguments, getNodeOutput, } from "@foresthubai/workflow-core/node";
+import { addEdge } from "@xyflow/react";
+import { computeVariablesFromNodes } from "@foresthubai/workflow-core/workflow";
+import { nodeOutputVarKey, paramKey } from "@foresthubai/workflow-core/variable";
+import { isExpression } from "@foresthubai/workflow-core/expression";
+import { isValidConnection } from "./connectionRules";
+import { generateId } from "@foresthubai/workflow-core/id";
+import { uniqueName } from "./resourceHelpers";
+// ============================================================================
+// Output Name Deduplication
+// ============================================================================
+/** Collect all output variable names currently in the store. */
+function collectVariableNames(store) {
+    const vars = store.getState().variables;
+    return new Set(Object.values(vars).map((v) => v.name));
+}
+/**
+ * Walk a node instance and rename any emit bindings/declarations whose name collides
+ * with `existingNames`. Mutates in place. Handles all three locations:
+ *  - Static outputs, incl. FunctionCall returns (direct field on arguments — OutputBinding)
+ *  - List output entries (each entry IS an OutputDeclaration — mutate its `name` field directly
+ *    when mode === "emit". Assign-mode entries have no name to rename, so they're skipped.)
+ * `existingNames` is updated with each rename so subsequent calls see the new names.
+ */
+function deduplicateEmitNames(node, existingNames) {
+    const args = node.arguments;
+    const renameBindingAt = (key) => {
+        const binding = args[key];
+        // Only active emit bindings produce a variable that could collide.
+        if (!binding || !binding.active || binding.mode !== "emit" || !existingNames.has(binding.name))
+            return;
+        const deduped = uniqueName(binding.name, existingNames);
+        existingNames.add(deduped);
+        args[key] = { active: true, mode: "emit", name: deduped };
+    };
+    if (node.type === "FunctionCall") {
+        for (const ret of node.functionInfo.returns) {
+            renameBindingAt(paramKey(ret));
+        }
+        return;
+    }
+    const def = NodeRegistry.getByType(node.type);
+    if (!def?.outputs)
+        return;
+    for (const out of def.outputs) {
+        if (out.type === "static") {
+            renameBindingAt(out.id);
+        }
+        else {
+            const entries = args[out.id] ?? [];
+            for (const entry of entries) {
+                if (entry.mode !== "emit")
+                    continue;
+                if (!existingNames.has(entry.name))
+                    continue;
+                const deduped = uniqueName(entry.name, existingNames);
+                existingNames.add(deduped);
+                entry.name = deduped;
+            }
+        }
+    }
+}
+// ============================================================================
+// Pure Store Operations
+// ============================================================================
+/** Check if a node definition can be added to the store (respects isUnremovable and isSingleton). */
+export function canAddNode(store, nodeDef) {
+    if (nodeDef.isUnremovable)
+        return false;
+    if (nodeDef.isSingleton) {
+        const { nodes } = store.getState();
+        if (nodes.some((n) => n.data.type === nodeDef.type))
+            return false;
+    }
+    return true;
+}
+/** Add a node to the store given a node definition and optional position. Returns the new node ID, or null if the node cannot be added. */
+export function addNodeToStore(store, nodeDef, position) {
+    if (!canAddNode(store, nodeDef))
+        return null;
+    const nodeId = generateId();
+    // Initialize parameters with default values. Clone so object/array defaults
+    // (Expression, weekdays `[]`, memory-refs `[]`) aren't shared by reference
+    // across instances or with the definition itself — a shared mutable default
+    // would alias on edit.
+    const args = {};
+    nodeDef.parameters.forEach((param) => {
+        if (param.default !== undefined) {
+            args[param.id] = structuredClone(param.default);
+        }
+    });
+    // Seed outputs directly into args:
+    //  - Static outputs: `args[out.id] = { active: true, mode: "emit", name: out.id }` (OutputBinding)
+    //  - List outputs: `args[out.id] = []` (empty OutputDeclaration[] — user adds entries)
+    for (const out of nodeDef.outputs ?? []) {
+        if (out.type === "static") {
+            args[out.id] = { active: true, mode: "emit", name: out.id };
+        }
+        else {
+            args[out.id] = [];
+        }
+    }
+    const nodeData = {
+        id: nodeId,
+        type: nodeDef.type,
+        arguments: args,
+    };
+    if (nodeDef.type === "FunctionCall") {
+        const functionDef = nodeDef;
+        const functionNode = nodeData;
+        functionNode.functionInfo = functionDef.functionInfo;
+        // Seed input bindings keyed by arg uid — empty expressions with the declared dataType.
+        // Output bindings were already seeded above by the generic outputs[] loop since
+        // buildFunctionNodeDef now emits real StaticOutput entries.
+        for (const arg of functionDef.functionInfo.arguments) {
+            args[paramKey(arg)] = { expression: "", references: [], dataType: arg.dataType };
+        }
+        // Generic seeding uses the output id as the default emit name, but for function
+        // returns we want the return's variable name.
+        for (const ret of functionDef.functionInfo.returns) {
+            args[paramKey(ret)] = { active: true, mode: "emit", name: ret.name };
+        }
+    }
+    // Deduplicate emit binding names against existing variables on the canvas
+    const existingNames = collectVariableNames(store);
+    deduplicateEmitNames(nodeData, existingNames);
+    // Nudge position if another node is already nearby (avoids stacking on click-to-add)
+    const currentNodes = store.getState().nodes;
+    let pos = position || { x: 250, y: 100 };
+    const SNAP_DISTANCE = 50;
+    while (currentNodes.some((n) => Math.abs(n.position.x - pos.x) < SNAP_DISTANCE && Math.abs(n.position.y - pos.y) < SNAP_DISTANCE)) {
+        pos = { x: pos.x + 40, y: pos.y + 40 };
+    }
+    const newNode = {
+        id: nodeData.id,
+        type: getReactFlowType(nodeDef.type),
+        position: pos,
+        data: nodeData,
+    };
+    const { setNodes, setVariables } = store.getState();
+    setNodes((nds) => [...nds, newNode]);
+    // Add new node's output variables to store (computed via getNodeOutput)
+    setVariables((vars) => ({ ...vars, ...computeVariablesFromNodes([newNode.data]) }));
+    return nodeId;
+}
+/**
+ * Update a node's data in the store. Returns true if the node was found and updated.
+ *
+ * FunctionCallNode is no longer a special case — its arguments are flat, so the same
+ * shallow-merge path handles input edits, output binding edits, and migrations uniformly.
+ * Migration callers simply pass the full replacement arguments record alongside
+ * `functionInfo`; normal edits pass the single changed key.
+ */
+export function updateNodeInStore(store, nodeId, updates) {
+    const { setNodes, setVariables } = store.getState();
+    // Track output changes to update variables store
+    let oldOutputs = {};
+    let newOutputs = {};
+    let outputsChanged = false;
+    let found = false;
+    setNodes((nds) => {
+        const targetNodeIndex = nds.findIndex((node) => node.id === nodeId);
+        if (targetNodeIndex === -1)
+            return nds;
+        const targetNode = nds[targetNodeIndex];
+        if (!targetNode)
+            return nds;
+        found = true;
+        const currentData = targetNode.data;
+        oldOutputs = getNodeOutput(currentData);
+        // When functionInfo changes (FunctionCall signature update), arguments are a
+        // full replacement so stale keys for removed args/returns get dropped;
+        // otherwise shallow-merge.
+        let updatedNodeData;
+        if (updates.arguments) {
+            const mergedArgs = updates.functionInfo
+                ? updates.arguments
+                : { ...currentData.arguments, ...updates.arguments };
+            updatedNodeData = {
+                ...currentData,
+                ...updates,
+                arguments: mergedArgs,
+            };
+        }
+        else {
+            updatedNodeData = { ...currentData, ...updates };
+        }
+        newOutputs = getNodeOutput(updatedNodeData);
+        // Build the updated nodes array
+        const updatedNodes = nds.map((node, index) => {
+            if (index === targetNodeIndex) {
+                return { ...node, data: updatedNodeData };
+            }
+            return node;
+        });
+        // Check if any output variable changed (keys added/removed or values changed)
+        const oldKeys = Object.keys(oldOutputs);
+        const newKeys = Object.keys(newOutputs);
+        outputsChanged =
+            oldKeys.length !== newKeys.length ||
+                newKeys.some((key) => {
+                    const oldVar = oldOutputs[key];
+                    const newVar = newOutputs[key];
+                    return !oldVar || !newVar || oldVar.name !== newVar.name || oldVar.dataType !== newVar.dataType;
+                });
+        return updatedNodes;
+    });
+    // Update variables store if outputs changed
+    if (outputsChanged) {
+        setVariables((vars) => {
+            const updated = { ...vars };
+            // Remove old outputs that no longer exist in new outputs
+            for (const outputId of Object.keys(oldOutputs)) {
+                if (!(outputId in newOutputs)) {
+                    delete updated[nodeOutputVarKey(nodeId, outputId)];
+                }
+            }
+            // Add/update new outputs (only if actually changed)
+            for (const [outputId, variable] of Object.entries(newOutputs)) {
+                const key = nodeOutputVarKey(nodeId, outputId);
+                const oldVar = vars[key];
+                if (!oldVar || oldVar.name !== variable.name || oldVar.dataType !== variable.dataType) {
+                    updated[key] = { kind: "node", nodeId, outputId, name: variable.name, dataType: variable.dataType };
+                }
+            }
+            return updated;
+        });
+    }
+    return found;
+}
+/**
+ * Delete a node from the store, removing connected edges and variables.
+ * Takes optional getNodeDefinition callback for isUnremovable check.
+ * Returns true if the node was deleted.
+ */
+export function deleteNodeFromStore(store, nodeId, getNodeDefinition) {
+    const { nodes, edges, setNodes, setEdges, setVariables } = store.getState();
+    // Check if node can be deleted
+    const nodeToDelete = nodes.find((node) => node.id === nodeId);
+    if (!nodeToDelete)
+        return false;
+    if (getNodeDefinition) {
+        const nodeDef = getNodeDefinition(nodeToDelete.data);
+        if (nodeDef?.isUnremovable ?? false)
+            return false;
+    }
+    setNodes((nds) => nds.filter((node) => node.id !== nodeId));
+    setEdges((eds) => eds.filter((edge) => edge.source !== nodeId && edge.target !== nodeId));
+    // Remove deleted node's emitted variables from store
+    const outputKeys = Object.keys(getNodeOutput(nodeToDelete.data));
+    if (outputKeys.length > 0) {
+        setVariables((vars) => {
+            const updated = { ...vars };
+            for (const outputId of outputKeys) {
+                delete updated[nodeOutputVarKey(nodeId, outputId)];
+            }
+            return updated;
+        });
+    }
+    return true;
+}
+/**
+ * Determine the specific edge type based on base port type and connected nodes.
+ * Agent nodes get specialized control-edge types (agentTask, agentChoice, agentDelegate).
+ * Tool edges have no agent-specific variant — every tool edge points at an agent.
+ */
+function resolveEdgeType(basePortType, sourceNode, targetNode) {
+    const sourceIsAgent = sourceNode.data.type === "Agent";
+    const targetIsAgent = targetNode.data.type === "Agent";
+    if (basePortType === "control") {
+        if (sourceIsAgent && targetIsAgent)
+            return "agentDelegate";
+        if (targetIsAgent)
+            return "agentTask";
+        if (sourceIsAgent)
+            return "agentChoice";
+        return "control";
+    }
+    return basePortType;
+}
+/** Add an edge if the connection is valid. Returns true if the edge was added. */
+export function connectNodesInStore(store, connection) {
+    const { nodes, edges, setEdges } = store.getState();
+    const portType = isValidConnection(connection.source, connection.target, connection.sourceHandle, connection.targetHandle, nodes, edges);
+    if (!portType)
+        return false;
+    const sourceNode = nodes.find((n) => n.id === connection.source);
+    const targetNode = nodes.find((n) => n.id === connection.target);
+    if (!sourceNode || !targetNode)
+        return false;
+    const edgeType = resolveEdgeType(portType, sourceNode, targetNode);
+    setEdges((eds) => addEdge({ ...connection, type: edgeType }, eds));
+    return edgeType;
+}
+/** Update an edge's data in the store. Returns true if the edge was found and updated. */
+export function updateEdgeInStore(store, edgeId, updates) {
+    const { edges, setEdges } = store.getState();
+    const edge = edges.find((e) => e.id === edgeId);
+    if (!edge)
+        return false;
+    setEdges((eds) => eds.map((e) => (e.id === edgeId ? { ...e, data: { ...e.data, ...updates } } : e)));
+    return true;
+}
+/** Delete edges by ID from the store. */
+export function deleteEdgesFromStore(store, edgeIds) {
+    const { setEdges } = store.getState();
+    const idSet = new Set(edgeIds);
+    setEdges((eds) => eds.filter((e) => !idSet.has(e.id)));
+}
+/** Paste clipboard contents into the store with new IDs and optional position offset. */
+export function pasteToStore(store, clipboard, offset = { x: 50, y: 50 }, getNodeDefinition) {
+    const empty = { pasted: false, skippedLabels: [] };
+    if (clipboard.nodes.length === 0)
+        return empty;
+    const { setNodes, setEdges, setVariables } = store.getState();
+    // Filter out nodes that cannot be pasted (unremovable or singleton already on canvas)
+    const skippedLabels = [];
+    const pastableNodes = clipboard.nodes.filter((node) => {
+        if (!getNodeDefinition)
+            return true;
+        const def = getNodeDefinition(node.data);
+        if (!def)
+            return true;
+        if (!canAddNode(store, def)) {
+            skippedLabels.push(def.label);
+            return false;
+        }
+        return true;
+    });
+    if (pastableNodes.length === 0)
+        return { pasted: false, skippedLabels };
+    // Build old ID -> new ID mapping (only for pastable nodes)
+    const idMap = new Map();
+    pastableNodes.forEach((node) => {
+        const newId = generateId();
+        idMap.set(node.id, newId);
+    });
+    // Create new nodes with updated IDs and positions
+    const newNodes = pastableNodes.map((node) => {
+        const newId = idMap.get(node.id);
+        // Deep copy and update node data
+        const newData = JSON.parse(JSON.stringify(node.data));
+        newData.id = newId;
+        // Update expression references to point to new node IDs
+        newData.arguments = updateExpressionsInArgs(getArguments(newData), idMap);
+        return {
+            ...node,
+            id: newId,
+            position: {
+                x: node.position.x + offset.x,
+                y: node.position.y + offset.y,
+            },
+            data: newData,
+            selected: true,
+        };
+    });
+    // Dedupe emit binding names on pasted nodes against existing variables.
+    // (Pasted nodes come from JSON.parse(JSON.stringify(...)) of live nodes, so
+    // their bindings are already present in the correct arguments locations.)
+    const existingNames = collectVariableNames(store);
+    for (const node of newNodes) {
+        deduplicateEmitNames(node.data, existingNames);
+    }
+    // Create new edges with updated IDs (only for edges where both nodes are pasted)
+    const newEdges = clipboard.edges
+        .filter((edge) => idMap.has(edge.source) && idMap.has(edge.target))
+        .map((edge) => {
+        const newEdge = {
+            ...edge,
+            id: generateId(),
+            source: idMap.get(edge.source),
+            target: idMap.get(edge.target),
+            data: edge.data ? { ...edge.data } : edge.data,
+        };
+        // Remap prompt references on agentTask edges
+        if (newEdge.data?.prompt && isExpression(newEdge.data.prompt)) {
+            const prompt = newEdge.data.prompt;
+            newEdge.data = {
+                ...newEdge.data,
+                prompt: {
+                    ...prompt,
+                    references: prompt.references.map((ref) => ({
+                        srcId: idMap.get(ref.srcId) ?? ref.srcId,
+                        varId: ref.varId,
+                    })),
+                },
+            };
+        }
+        return newEdge;
+    });
+    // Deselect existing nodes before adding new ones
+    setNodes((nds) => [...nds.map((n) => ({ ...n, selected: false })), ...newNodes]);
+    setEdges((eds) => [...eds, ...newEdges]);
+    // Add pasted nodes' variables to store
+    setVariables((vars) => ({ ...vars, ...computeVariablesFromNodes(newNodes.map((n) => n.data)) }));
+    return { pasted: true, skippedLabels };
+}
+// ============================================================================
+// Expression Reference Updater (for paste)
+// ============================================================================
+/** Update expression references to point to new node IDs after paste */
+function updateExpressionsInArgs(args, idMap) {
+    const updated = {};
+    for (const [key, value] of Object.entries(args)) {
+        if (isExpression(value)) {
+            // Update references with new node IDs
+            const updatedExpr = {
+                expression: value.expression,
+                dataType: value.dataType,
+                references: value.references.map((ref) => ({
+                    srcId: idMap.get(ref.srcId) ?? ref.srcId,
+                    varId: ref.varId,
+                })),
+            };
+            updated[key] = updatedExpr;
+        }
+        else if (Array.isArray(value)) {
+            // Handle arrays of expressions
+            updated[key] = value.map((item) => {
+                if (isExpression(item)) {
+                    return {
+                        expression: item.expression,
+                        dataType: item.dataType,
+                        references: item.references.map((ref) => ({
+                            srcId: idMap.get(ref.srcId) ?? ref.srcId,
+                            varId: ref.varId,
+                        })),
+                    };
+                }
+                return item;
+            });
+        }
+        else if (value !== null && typeof value === "object") {
+            // Handle nested objects
+            updated[key] = updateExpressionsInArgs(value, idMap);
+        }
+        else {
+            updated[key] = value;
+        }
+    }
+    return updated;
+}
+// ============================================================================
+// ReactFlow Type Resolution
+// ============================================================================
+/** Determine React Flow node type based on NodeCategory */
+export function getReactFlowType(type) {
+    if (type === "FunctionCall") {
+        return "FunctionCall";
+    }
+    const category = NodeRegistry.getByType(type)?.category ?? "Uncategorized";
+    switch (category) {
+        case NodeCategory.Trigger:
+        case NodeCategory.Tool:
+        case NodeCategory.AI:
+            return category;
+        default:
+            return "Standard";
+    }
+}
+//# sourceMappingURL=graphOperations.js.map