Prompt surface

Author: Sg312

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

@@ -457,7 +457,7 @@ export function createValidatedEdge(
       type: 'invalid_edge_target',
       operationType,
       blockId: sourceBlockId,
-      reason: `Edge from "${sourceBlockId}" to "${targetBlockId}" deferred - target block does not exist yet; it will be created automatically once the target block is added`,
+      reason: `Edge from "${sourceBlockId}" to "${targetBlockId}" deferred until the target block "${targetBlockId}" exists - if it is created later (in this or a following edit) the engine wires this edge automatically; if you did not intend to create "${targetBlockId}", fix the target id.`,
       details: { sourceHandle, targetHandle, targetId: targetBlockId },
     })
     return false

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

@@ -32,7 +32,7 @@ import { generateLoopBlocks, generateParallelBlocks } from '@/stores/workflows/w
 import { normalizeWorkflowState } from '@/stores/workflows/workflow/validation'
 import { applyOperationsToWorkflowState } from './engine'
 import { formatWorkflowLintMessage, hasWorkflowLintIssues, lintEditedWorkflowState } from './lint'
-import type { EditWorkflowParams, ValidationError } from './types'
+import { isDeferredSkippedItem, type EditWorkflowParams, type ValidationError } from './types'
 import { preValidateCredentialInputs, validateWorkflowSelectorIds } from './validation'
 
 async function getCurrentWorkflowStateFromDb(
@@ -226,9 +226,28 @@ export const editWorkflowServerTool: BaseServerTool<EditWorkflowParams, unknown>
         ? validationErrors.map((e) => `Block "${e.blockId}" (${e.blockType}): ${e.error}`)
         : undefined
 
-    // Format skipped items for LLM feedback
-    const skippedMessages =
-      skippedItems.length > 0 ? skippedItems.map((item) => item.reason) : undefined
+    // Split engine skipped items into genuine failures vs benign, self-healing
+    // deferrals. A deferred forward-reference edge (invalid_edge_target) is NOT
+    // a failure: the engine wires it automatically once its target block exists
+    // (this call or a later one) via pendingConnections. Surfacing it through
+    // the same "skipped" failure channel as real skips makes a literal model
+    // thrash (re-issuing a self-healing op). Keep them in separate result fields
+    // and preserve item.type/details so the prompt can branch on a
+    // machine-readable category instead of pattern-matching prose.
+    const mapSkippedItem = (item: (typeof skippedItems)[number]) => ({
+      type: item.type,
+      operationType: item.operationType,
+      blockId: item.blockId,
+      reason: item.reason,
+      ...(item.details && { details: item.details }),
+    })
+
+    const genuineSkippedItems = skippedItems.filter((item) => !isDeferredSkippedItem(item))
+    const deferredItems = skippedItems.filter((item) => isDeferredSkippedItem(item))
+
+    const skippedDetails =
+      genuineSkippedItems.length > 0 ? genuineSkippedItems.map(mapSkippedItem) : undefined
+    const deferredDetails = deferredItems.length > 0 ? deferredItems.map(mapSkippedItem) : undefined
 
     // Persist the workflow state to the database
     const finalWorkflowState = validation.sanitizedState || modifiedWorkflowState
@@ -320,9 +339,13 @@ export const editWorkflowServerTool: BaseServerTool<EditWorkflowParams, unknown>
         inputValidationErrors: inputErrors,
         inputValidationMessage: `${inputErrors.length} input(s) were rejected due to validation errors. The workflow was still updated with valid inputs only. Errors: ${inputErrors.join('; ')}`,
       }),
-      ...(skippedMessages && {
-        skippedItems: skippedMessages,
-        skippedItemsMessage: `${skippedItems.length} operation(s) were skipped due to invalid references. Details: ${skippedMessages.join('; ')}`,
+      ...(skippedDetails && {
+        skippedItems: skippedDetails,
+        skippedItemsMessage: `${skippedDetails.length} operation(s) were skipped (not applied) and need attention. Each item includes a machine-readable "type" (e.g. block_not_found, block_locked, duplicate_block_name, invalid_block_type, invalid_source_handle, invalid_target_handle, invalid_edge_scope). Details: ${skippedDetails.map((item) => item.reason).join('; ')}`,
+      }),
+      ...(deferredDetails && {
+        deferredConnections: deferredDetails,
+        deferredMessage: `${deferredDetails.length} edge(s) were deferred because their target block does not exist yet. This is NOT a failure and does NOT need fixing: the engine wires these edges automatically once the target block exists (in this edit or a later one). Do not re-issue them. Only act on a deferred edge if its target id was a typo or hallucination that you do not intend to create. Details: ${deferredDetails.map((item) => item.reason).join('; ')}`,
       }),
       ...(sanitizationWarnings && {
         sanitizationWarnings,

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

@@ -872,10 +872,12 @@ export function handleInsertIntoSubflowOperation(
   }
 
   if (subflowBlock.type !== 'loop' && subflowBlock.type !== 'parallel') {
-    logger.error('Subflow block has invalid type', {
-      subflowId,
-      type: subflowBlock.type,
-      block_id,
+    logSkippedItem(skippedItems, {
+      type: 'invalid_subflow_parent',
+      operationType: 'insert_into_subflow',
+      blockId: block_id,
+      reason: `Cannot insert block "${block_id}" into "${subflowId}" - the target is a "${subflowBlock.type}" block, not a loop or parallel container`,
+      details: { subflowId, subflowType: subflowBlock.type },
     })
     return
   }

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

@@ -62,6 +62,25 @@ export interface SkippedItem {
   details?: Record<string, any>
 }
 
+/**
+ * Skipped-item types that represent benign, SELF-HEALING deferrals rather than
+ * failures. A deferred forward-reference edge (`invalid_edge_target`) is
+ * recorded as a pending connection and wired automatically once its target
+ * block exists -- possibly on a later edit_workflow call. It must be surfaced to
+ * the model as informational, NOT through the "skipped/failed operation"
+ * channel; otherwise a literal model re-issues the self-healing operation in a
+ * loop. See `createValidatedEdge` (builders.ts) and `resolvePendingConnections`
+ * (engine.ts).
+ */
+export const DEFERRED_SKIPPED_ITEM_TYPES: ReadonlySet<SkippedItemType> = new Set([
+  'invalid_edge_target',
+])
+
+/** Whether a skipped item is a benign deferral (see DEFERRED_SKIPPED_ITEM_TYPES). */
+export function isDeferredSkippedItem(item: SkippedItem): boolean {
+  return DEFERRED_SKIPPED_ITEM_TYPES.has(item.type)
+}
+
 /**
  * Logs and records a skipped item
  */