Fixes

Author: Sg312

apps/sim/lib/copilot/tools/server/workflow/edit-workflow/builders.ts

@@ -427,7 +427,28 @@ export function createValidatedEdge(
   skippedItems?: SkippedItem[]
 ): boolean {
   if (!modifiedState.blocks[targetBlockId]) {
-    logger.warn(`Target block "${targetBlockId}" not found. Edge skipped.`, {
+    // The target doesn't exist yet. It may be created by a later operation in
+    // this batch or by a future edit_workflow call. Record the connection as
+    // pending on the source block (persisted in block.data) so it is resolved
+    // automatically once the target appears, instead of being silently dropped.
+    const pendingSource = modifiedState.blocks[sourceBlockId]
+    if (pendingSource) {
+      if (!pendingSource.data) pendingSource.data = {}
+      if (!pendingSource.data.pendingConnections) pendingSource.data.pendingConnections = {}
+      const pending = pendingSource.data.pendingConnections as Record<
+        string,
+        Array<{ target: string; targetHandle: string }>
+      >
+      if (!pending[sourceHandle]) pending[sourceHandle] = []
+      if (
+        !pending[sourceHandle].some(
+          (p) => p.target === targetBlockId && p.targetHandle === targetHandle
+        )
+      ) {
+        pending[sourceHandle].push({ target: targetBlockId, targetHandle })
+      }
+    }
+    logger.warn(`Target block "${targetBlockId}" not found. Connection deferred until it exists.`, {
       sourceBlockId,
       targetBlockId,
       sourceHandle,
@@ -436,7 +457,7 @@ export function createValidatedEdge(
       type: 'invalid_edge_target',
       operationType,
       blockId: sourceBlockId,
-      reason: `Edge from "${sourceBlockId}" to "${targetBlockId}" skipped - target block does not exist`,
+      reason: `Edge from "${sourceBlockId}" to "${targetBlockId}" deferred - target block does not exist yet; it will be created automatically once the target block is added`,
       details: { sourceHandle, targetHandle, targetId: targetBlockId },
     })
     return false
@@ -513,6 +534,17 @@ export function createValidatedEdge(
   // Use normalized handle if available (e.g., 'if' -> 'condition-{uuid}')
   const finalSourceHandle = sourceValidation.normalizedHandle || sourceHandle
 
+  // Avoid creating duplicate edges (e.g., when a pending connection resolves to
+  // the same edge a later operation already created).
+  const edgeExists = (modifiedState.edges || []).some(
+    (e: any) =>
+      e.source === sourceBlockId &&
+      e.sourceHandle === finalSourceHandle &&
+      e.target === targetBlockId &&
+      e.targetHandle === targetHandle
+  )
+  if (edgeExists) return true
+
   modifiedState.edges.push({
     id: generateId(),
     source: sourceBlockId,

apps/sim/lib/copilot/tools/server/workflow/edit-workflow/engine.ts

@@ -3,7 +3,11 @@ import type { PermissionGroupConfig } from '@/lib/permission-groups/types'
 import { isValidKey } from '@/lib/workflows/sanitization/key-validation'
 import { validateEdges } from '@/stores/workflows/workflow/edge-validation'
 import { generateLoopBlocks, generateParallelBlocks } from '@/stores/workflows/workflow/utils'
-import { addConnectionsAsEdges, normalizeBlockIdsInOperations } from './builders'
+import {
+  addConnectionsAsEdges,
+  createValidatedEdge,
+  normalizeBlockIdsInOperations,
+} from './builders'
 import {
   handleAddOperation,
   handleDeleteOperation,
@@ -239,6 +243,13 @@ export function applyOperationsToWorkflowState(
       totalEdges: (modifiedState as any).edges?.length,
     })
   }
+
+  // Pass 3: resolve pending connections whose target block now exists. These are
+  // forward-reference connections that were recorded (on block.data) when their
+  // target didn't exist yet — possibly in an earlier edit_workflow call. Now
+  // that this batch's blocks are all created, create the edges that resolve.
+  resolvePendingConnections(modifiedState, skippedItems)
+
   // Remove edges that cross scope boundaries. This runs after all operations
   // and deferred connections are applied so that every block has its final
   // parentId. Running it per-operation would incorrectly drop edges between
@@ -280,6 +291,54 @@ export function applyOperationsToWorkflowState(
   return { state: modifiedState, validationErrors, skippedItems }
 }
 
+/**
+ * Resolves pending forward-reference connections recorded on block.data.
+ *
+ * When a connection references a target block that does not exist yet, the edge
+ * is recorded as pending on the source block instead of being dropped. This runs
+ * after all blocks for the current batch exist (and picks up pending entries
+ * persisted from earlier edit_workflow calls), creating any edges whose target
+ * now exists and leaving still-unresolved entries pending.
+ */
+function resolvePendingConnections(modifiedState: any, skippedItems: SkippedItem[]): void {
+  const blocks = modifiedState.blocks || {}
+  for (const [sourceId, block] of Object.entries(blocks) as [string, any][]) {
+    const pending = block?.data?.pendingConnections as
+      | Record<string, Array<{ target: string; targetHandle: string }>>
+      | undefined
+    if (!pending) continue
+
+    for (const [handle, targets] of Object.entries(pending)) {
+      const stillPending: Array<{ target: string; targetHandle: string }> = []
+      for (const { target, targetHandle } of targets) {
+        if (blocks[target]) {
+          createValidatedEdge(
+            modifiedState,
+            sourceId,
+            target,
+            handle,
+            targetHandle || 'target',
+            'resolve_pending_connection',
+            logger,
+            skippedItems
+          )
+        } else {
+          stillPending.push({ target, targetHandle })
+        }
+      }
+      if (stillPending.length > 0) {
+        pending[handle] = stillPending
+      } else {
+        delete pending[handle]
+      }
+    }
+
+    if (Object.keys(pending).length === 0) {
+      delete block.data.pendingConnections
+    }
+  }
+}
+
 /**
  * Removes edges that cross scope boundaries after all operations are applied.
  * An edge is invalid if:

apps/sim/lib/copilot/tools/server/workflow/edit-workflow/operations.test.ts

@@ -438,3 +438,93 @@ describe('handleEditOperation nestedNodes merge', () => {
     expect(replacementBlock.data?.parentId).toBe('outer-loop')
   })
 })
+
+describe('forward-reference connections (pending resolution)', () => {
+  function makeMinimalWorkflow() {
+    return {
+      blocks: {
+        'start-1': {
+          id: 'start-1',
+          type: 'function',
+          name: 'Start',
+          position: { x: 0, y: 0 },
+          enabled: true,
+          subBlocks: {},
+          outputs: {},
+          data: {},
+        },
+      },
+      edges: [] as any[],
+      loops: {},
+      parallels: {},
+    }
+  }
+
+  // Valid UUIDs so block_ids are not normalized/remapped on add.
+  const BLOCK_A = '11111111-1111-4111-8111-111111111111'
+  const BLOCK_B = '22222222-2222-4222-8222-222222222222'
+
+  it('defers a connection to a not-yet-created block and resolves it on a later apply', () => {
+    const workflow = makeMinimalWorkflow()
+
+    // First apply: add block A connecting to block B, which does not exist yet.
+    const first = applyOperationsToWorkflowState(workflow, [
+      {
+        operation_type: 'add',
+        block_id: BLOCK_A,
+        params: {
+          type: 'function',
+          name: 'Block A',
+          inputs: { code: 'return 1' },
+          connections: { source: BLOCK_B },
+        },
+      },
+    ])
+
+    // No edge created yet; the connection is recorded as pending on block A.
+    expect(first.state.edges.some((e: any) => e.target === BLOCK_B)).toBe(false)
+    expect(first.state.blocks[BLOCK_A].data.pendingConnections.source).toEqual([
+      { target: BLOCK_B, targetHandle: 'target' },
+    ])
+
+    // Second apply (simulating a later edit_workflow call): add block B.
+    const second = applyOperationsToWorkflowState(first.state, [
+      {
+        operation_type: 'add',
+        block_id: BLOCK_B,
+        params: { type: 'function', name: 'Block B', inputs: { code: 'return 2' } },
+      },
+    ])
+
+    // The pending edge is now created and the pending record cleared.
+    const edge = second.state.edges.find((e: any) => e.source === BLOCK_A && e.target === BLOCK_B)
+    expect(edge).toBeDefined()
+    expect(second.state.blocks[BLOCK_A].data?.pendingConnections).toBeUndefined()
+  })
+
+  it('resolves a forward-reference connection within a single apply regardless of operation order', () => {
+    const workflow = makeMinimalWorkflow()
+
+    const { state } = applyOperationsToWorkflowState(workflow, [
+      {
+        operation_type: 'add',
+        block_id: BLOCK_A,
+        params: {
+          type: 'function',
+          name: 'Block A',
+          inputs: { code: 'return 1' },
+          connections: { source: BLOCK_B },
+        },
+      },
+      {
+        operation_type: 'add',
+        block_id: BLOCK_B,
+        params: { type: 'function', name: 'Block B', inputs: { code: 'return 2' } },
+      },
+    ])
+
+    const edge = state.edges.find((e: any) => e.source === BLOCK_A && e.target === BLOCK_B)
+    expect(edge).toBeDefined()
+    expect(state.blocks[BLOCK_A].data?.pendingConnections).toBeUndefined()
+  })
+})

apps/sim/lib/copilot/tools/server/workflow/edit-workflow/operations.ts

@@ -659,6 +659,12 @@ export function handleEditOperation(op: EditWorkflowOperation, ctx: OperationCon
   if (params?.connections) {
     modifiedState.edges = modifiedState.edges.filter((edge: any) => edge.source !== block_id)
 
+    // Re-specifying connections fully replaces this block's outgoing edges, so
+    // drop any previously-recorded pending (forward-reference) connections too.
+    if (block.data?.pendingConnections) {
+      block.data.pendingConnections = undefined
+    }
+
     deferredConnections.push({
       blockId: block_id,
       connections: params.connections,
@@ -1014,6 +1020,13 @@ export function handleInsertIntoSubflowOperation(
     // Remove existing edges from this block first
     modifiedState.edges = modifiedState.edges.filter((edge: any) => edge.source !== block_id)
 
+    // Re-specifying connections fully replaces this block's outgoing edges, so
+    // drop any previously-recorded pending (forward-reference) connections too.
+    const connBlock = modifiedState.blocks[block_id]
+    if (connBlock?.data?.pendingConnections) {
+      connBlock.data.pendingConnections = undefined
+    }
+
     // Add to deferred connections list
     deferredConnections.push({
       blockId: block_id,