Fix router block for copilot

Author: Sg312

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

@@ -878,6 +878,25 @@ function validateSourceHandleForBlock(
         error: `Invalid source handle "${sourceHandle}" for router block. Valid handles: source, ${EDGE.ROUTER_PREFIX}{targetId}, error`,
       }
 
+    case 'router_v2': {
+      if (!sourceHandle.startsWith(EDGE.ROUTER_PREFIX)) {
+        return {
+          valid: false,
+          error: `Invalid source handle "${sourceHandle}" for router_v2 block. Must start with "${EDGE.ROUTER_PREFIX}"`,
+        }
+      }
+
+      const routesValue = sourceBlock?.subBlocks?.routes?.value
+      if (!routesValue) {
+        return {
+          valid: false,
+          error: `Invalid router handle "${sourceHandle}" - no routes defined`,
+        }
+      }
+
+      return validateRouterHandle(sourceHandle, sourceBlock.id, routesValue)
+    }
+
     default:
       if (sourceHandle === 'source') {
         return { valid: true }
@@ -963,6 +982,85 @@ function validateConditionHandle(
   }
 }
 
+/**
+ * Validates router handle references a valid route in the block.
+ * Accepts both internal IDs (router-{routeId}) and semantic keys (router-{blockId}-route-1)
+ */
+function validateRouterHandle(
+  sourceHandle: string,
+  blockId: string,
+  routesValue: string | any[]
+): EdgeHandleValidationResult {
+  let routes: any[]
+  if (typeof routesValue === 'string') {
+    try {
+      routes = JSON.parse(routesValue)
+    } catch {
+      return {
+        valid: false,
+        error: `Cannot validate router handle "${sourceHandle}" - routes is not valid JSON`,
+      }
+    }
+  } else if (Array.isArray(routesValue)) {
+    routes = routesValue
+  } else {
+    return {
+      valid: false,
+      error: `Cannot validate router handle "${sourceHandle}" - routes is not an array`,
+    }
+  }
+
+  if (!Array.isArray(routes) || routes.length === 0) {
+    return {
+      valid: false,
+      error: `Invalid router handle "${sourceHandle}" - no routes defined`,
+    }
+  }
+
+  const validHandles = new Set<string>()
+  const semanticPrefix = `router-${blockId}-`
+
+  for (let i = 0; i < routes.length; i++) {
+    const route = routes[i]
+
+    // Accept internal ID format: router-{uuid}
+    if (route.id) {
+      validHandles.add(`router-${route.id}`)
+    }
+
+    // Accept 1-indexed route number format: router-{blockId}-route-1, router-{blockId}-route-2, etc.
+    validHandles.add(`${semanticPrefix}route-${i + 1}`)
+
+    // Accept normalized title format: router-{blockId}-{normalized-title}
+    // Normalize: lowercase, replace spaces with dashes, remove special chars
+    if (route.title && typeof route.title === 'string') {
+      const normalizedTitle = route.title
+        .toLowerCase()
+        .replace(/\s+/g, '-')
+        .replace(/[^a-z0-9-]/g, '')
+      if (normalizedTitle) {
+        validHandles.add(`${semanticPrefix}${normalizedTitle}`)
+      }
+    }
+  }
+
+  if (validHandles.has(sourceHandle)) {
+    return { valid: true }
+  }
+
+  const validOptions = Array.from(validHandles).slice(0, 5)
+  const moreCount = validHandles.size - validOptions.length
+  let validOptionsStr = validOptions.join(', ')
+  if (moreCount > 0) {
+    validOptionsStr += `, ... and ${moreCount} more`
+  }
+
+  return {
+    valid: false,
+    error: `Invalid router handle "${sourceHandle}". Valid handles: ${validOptionsStr}`,
+  }
+}
+
 /**
  * Validates target handle is valid (must be 'target')
  */

apps/sim/lib/workflows/sanitization/json-sanitizer.ts

@@ -268,12 +268,130 @@ function sanitizeSubBlocks(
   return sanitized
 }
 
+/**
+ * Convert internal condition handle (condition-{uuid}) to semantic format (condition-{blockId}-if)
+ */
+function convertConditionHandleToSemantic(
+  handle: string,
+  blockId: string,
+  block: BlockState
+): string {
+  if (!handle.startsWith('condition-')) {
+    return handle
+  }
+
+  // Extract the condition UUID from the handle
+  const conditionId = handle.substring('condition-'.length)
+
+  // Get conditions from block subBlocks
+  const conditionsValue = block.subBlocks?.conditions?.value
+  if (!conditionsValue || typeof conditionsValue !== 'string') {
+    return handle
+  }
+
+  let conditions: Array<{ id: string; title: string }>
+  try {
+    conditions = JSON.parse(conditionsValue)
+  } catch {
+    return handle
+  }
+
+  if (!Array.isArray(conditions)) {
+    return handle
+  }
+
+  // Find the condition by ID and generate semantic handle
+  let elseIfCount = 0
+  for (const condition of conditions) {
+    const title = condition.title?.toLowerCase()
+    if (condition.id === conditionId) {
+      if (title === 'if') {
+        return `condition-${blockId}-if`
+      } else if (title === 'else if') {
+        elseIfCount++
+        return elseIfCount === 1
+          ? `condition-${blockId}-else-if`
+          : `condition-${blockId}-else-if-${elseIfCount}`
+      } else if (title === 'else') {
+        return `condition-${blockId}-else`
+      }
+    }
+    // Count else-ifs as we iterate
+    if (title === 'else if') {
+      elseIfCount++
+    }
+  }
+
+  // Fallback: return original handle if condition not found
+  return handle
+}
+
+/**
+ * Convert internal router handle (router-{uuid}) to semantic format (router-{blockId}-route-N)
+ */
+function convertRouterHandleToSemantic(
+  handle: string,
+  blockId: string,
+  block: BlockState
+): string {
+  if (!handle.startsWith('router-')) {
+    return handle
+  }
+
+  // Extract the route UUID from the handle
+  const routeId = handle.substring('router-'.length)
+
+  // Get routes from block subBlocks
+  const routesValue = block.subBlocks?.routes?.value
+  if (!routesValue || typeof routesValue !== 'string') {
+    return handle
+  }
+
+  let routes: Array<{ id: string; title?: string }>
+  try {
+    routes = JSON.parse(routesValue)
+  } catch {
+    return handle
+  }
+
+  if (!Array.isArray(routes)) {
+    return handle
+  }
+
+  // Find the route by ID and generate semantic handle (1-indexed)
+  for (let i = 0; i < routes.length; i++) {
+    if (routes[i].id === routeId) {
+      return `router-${blockId}-route-${i + 1}`
+    }
+  }
+
+  // Fallback: return original handle if route not found
+  return handle
+}
+
+/**
+ * Convert source handle to semantic format for condition and router blocks
+ */
+function convertToSemanticHandle(handle: string, blockId: string, block: BlockState): string {
+  if (handle.startsWith('condition-') && block.type === 'condition') {
+    return convertConditionHandleToSemantic(handle, blockId, block)
+  }
+
+  if (handle.startsWith('router-') && block.type === 'router_v2') {
+    return convertRouterHandleToSemantic(handle, blockId, block)
+  }
+
+  return handle
+}
+
 /**
  * Extract connections for a block from edges and format as operations-style connections
+ * Converts internal UUID handles to semantic format for training data
  */
 function extractConnectionsForBlock(
   blockId: string,
-  edges: WorkflowState['edges']
+  edges: WorkflowState['edges'],
+  block: BlockState
 ): Record<string, string | string[]> | undefined {
   const connections: Record<string, string[]> = {}
 
@@ -284,9 +402,12 @@ function extractConnectionsForBlock(
     return undefined
   }
 
-  // Group by source handle
+  // Group by source handle (converting to semantic format)
   for (const edge of outgoingEdges) {
-    const handle = edge.sourceHandle || 'source'
+    let handle = edge.sourceHandle || 'source'
+
+    // Convert internal UUID handles to semantic format
+    handle = convertToSemanticHandle(handle, blockId, block)
 
     if (!connections[handle]) {
       connections[handle] = []
@@ -321,7 +442,7 @@ export function sanitizeForCopilot(state: WorkflowState): CopilotWorkflowState {
 
   // Helper to recursively sanitize a block and its children
   const sanitizeBlock = (blockId: string, block: BlockState): CopilotBlockState => {
-    const connections = extractConnectionsForBlock(blockId, state.edges)
+    const connections = extractConnectionsForBlock(blockId, state.edges, block)
 
     // For loop/parallel blocks, extract config from block.data instead of subBlocks
     let inputs: Record<string, string | number | string[][] | object>