fix(copilot): edit workflow race condition (#1036)

* Fixes

* Updates

* Build workflow names

* Refactor icons

* Lint

* Update build tool name

Author: Sg312

apps/sim/app/api/copilot/chat/route.ts

@@ -13,6 +13,8 @@ import {
 import { getCopilotModel } from '@/lib/copilot/config'
 import { TITLE_GENERATION_SYSTEM_PROMPT, TITLE_GENERATION_USER_PROMPT } from '@/lib/copilot/prompts'
 import { getBlocksAndToolsTool } from '@/lib/copilot/tools/server-tools/blocks/get-blocks-and-tools'
+import { getEnvironmentVariablesTool } from '@/lib/copilot/tools/server-tools/user/get-environment-variables'
+import { getOAuthCredentialsTool } from '@/lib/copilot/tools/server-tools/user/get-oauth-credentials'
 import { env } from '@/lib/env'
 import { createLogger } from '@/lib/logs/console/logger'
 import { SIM_AGENT_API_URL_DEFAULT } from '@/lib/sim-agent'
@@ -90,6 +92,7 @@ const ChatMessageSchema = z.object({
   fileAttachments: z.array(FileAttachmentSchema).optional(),
   provider: z.string().optional().default('openai'),
   conversationId: z.string().optional(),
+  userWorkflow: z.string().optional(),
 })
 
 /**
@@ -207,6 +210,7 @@ export async function POST(req: NextRequest) {
       fileAttachments,
       provider,
       conversationId,
+      userWorkflow,
     } = ChatMessageSchema.parse(body)
 
     // Derive request origin for downstream service
@@ -244,6 +248,7 @@ export async function POST(req: NextRequest) {
       depth,
       prefetch,
       origin: requestOrigin,
+      hasUserWorkflow: !!userWorkflow,
     })
 
     // Handle chat context
@@ -414,17 +419,54 @@ export async function POST(req: NextRequest) {
     let prefetchResults: Record<string, any> | undefined
     if (effectivePrefetch === true) {
       try {
-        const prefetchResp = await getBlocksAndToolsTool.execute({})
-        if (prefetchResp.success) {
-          prefetchResults = { get_blocks_and_tools: prefetchResp.data }
-          logger.info(`[${tracker.requestId}] Prepared prefetchResults for streaming payload`, {
-            hasBlocksAndTools: !!prefetchResp.data,
-          })
+        const [blocksAndToolsResp, envVarsResp, oauthResp] = await Promise.all([
+          getBlocksAndToolsTool.execute({}),
+          getEnvironmentVariablesTool.execute({ userId: authenticatedUserId, workflowId }),
+          getOAuthCredentialsTool.execute({ userId: authenticatedUserId }),
+        ])
+
+        prefetchResults = {}
+
+        if (blocksAndToolsResp.success) {
+          prefetchResults.get_blocks_and_tools = blocksAndToolsResp.data
         } else {
           logger.warn(`[${tracker.requestId}] Failed to prefetch get_blocks_and_tools`, {
-            error: prefetchResp.error,
+            error: blocksAndToolsResp.error,
+          })
+        }
+
+        if (envVarsResp.success) {
+          prefetchResults.get_environment_variables = envVarsResp.data
+        } else {
+          logger.warn(`[${tracker.requestId}] Failed to prefetch get_environment_variables`, {
+            error: envVarsResp.error,
+          })
+        }
+
+        if (oauthResp.success) {
+          prefetchResults.get_oauth_credentials = oauthResp.data
+        } else {
+          logger.warn(`[${tracker.requestId}] Failed to prefetch get_oauth_credentials`, {
+            error: oauthResp.error,
+          })
+        }
+
+        if (userWorkflow && typeof userWorkflow === 'string' && userWorkflow.trim().length > 0) {
+          prefetchResults.get_user_workflow = userWorkflow
+          const uwLength = userWorkflow.length
+          const uwPreview = userWorkflow.substring(0, 10000)
+          logger.info(`[${tracker.requestId}] Included client-provided userWorkflow in prefetch`, {
+            length: uwLength,
+            preview: `${uwPreview}${uwLength > 10000 ? '...' : ''}`,
           })
         }
+
+        logger.info(`[${tracker.requestId}] Prepared prefetchResults for streaming payload`, {
+          hasBlocksAndTools: !!prefetchResults.get_blocks_and_tools,
+          hasEnvVars: !!prefetchResults.get_environment_variables,
+          hasOAuthCreds: !!prefetchResults.get_oauth_credentials,
+          hasUserWorkflow: !!prefetchResults.get_user_workflow,
+        })
       } catch (e) {
         logger.error(`[${tracker.requestId}] Error while preparing prefetchResults`, e)
       }

apps/sim/app/api/copilot/tools/complete/route.ts

@@ -0,0 +1,63 @@
+import { type NextRequest, NextResponse } from 'next/server'
+import { z } from 'zod'
+import { authenticateCopilotRequestSessionOnly } from '@/lib/copilot/auth'
+import { createLogger } from '@/lib/logs/console/logger'
+import { simAgentClient } from '@/lib/sim-agent'
+
+const logger = createLogger('CopilotToolsCompleteAPI')
+
+const Schema = z.object({
+  toolId: z.string().min(1),
+  methodId: z.string().min(1),
+  success: z.boolean(),
+  data: z.any().optional(),
+  error: z.string().optional(),
+})
+
+export async function POST(req: NextRequest) {
+  const requestId = crypto.randomUUID()
+  const start = Date.now()
+
+  try {
+    const sessionAuth = await authenticateCopilotRequestSessionOnly()
+    if (!sessionAuth.isAuthenticated) {
+      return NextResponse.json({ success: false, error: 'Unauthorized' }, { status: 401 })
+    }
+
+    const body = await req.json()
+    const { toolId, methodId, success, data, error } = Schema.parse(body)
+
+    logger.info(`[${requestId}] Forwarding tool completion to sim-agent`, {
+      toolId,
+      methodId,
+      success,
+      hasData: data !== undefined,
+      hasError: !!error,
+    })
+
+    const resp = await simAgentClient.makeRequest('/api/complete-tool', {
+      method: 'POST',
+      body: { toolId, methodId, success, ...(success ? { data } : { error: error || 'Unknown' }) },
+    })
+
+    const duration = Date.now() - start
+    logger.info(`[${requestId}] Sim-agent completion response`, {
+      status: resp.status,
+      success: resp.success,
+      duration,
+    })
+
+    return NextResponse.json(resp)
+  } catch (e) {
+    logger.error('Failed to forward tool completion', {
+      error: e instanceof Error ? e.message : 'Unknown error',
+    })
+    if (e instanceof z.ZodError) {
+      return NextResponse.json(
+        { success: false, error: e.errors.map((er) => er.message).join(', ') },
+        { status: 400 }
+      )
+    }
+    return NextResponse.json({ success: false, error: 'Internal server error' }, { status: 500 })
+  }
+}

apps/sim/app/api/copilot/workflows/edit/execute/route.ts

@@ -0,0 +1,56 @@
+import { type NextRequest, NextResponse } from 'next/server'
+import { z } from 'zod'
+import { authenticateCopilotRequestSessionOnly } from '@/lib/copilot/auth'
+import { copilotToolRegistry } from '@/lib/copilot/tools/server-tools/registry'
+import { createLogger } from '@/lib/logs/console/logger'
+
+const logger = createLogger('CopilotWorkflowsEditExecuteAPI')
+
+const Schema = z.object({
+  operations: z.array(z.object({}).passthrough()),
+  workflowId: z.string().min(1),
+  currentUserWorkflow: z.string().optional(),
+})
+
+export async function POST(req: NextRequest) {
+  const requestId = crypto.randomUUID()
+  const start = Date.now()
+
+  try {
+    const sessionAuth = await authenticateCopilotRequestSessionOnly()
+    if (!sessionAuth.isAuthenticated) {
+      return NextResponse.json({ success: false, error: 'Unauthorized' }, { status: 401 })
+    }
+
+    const body = await req.json()
+    const params = Schema.parse(body)
+
+    logger.info(`[${requestId}] Executing edit_workflow (logic-only)`, {
+      workflowId: params.workflowId,
+      operationCount: params.operations.length,
+      hasCurrentUserWorkflow: !!params.currentUserWorkflow,
+    })
+
+    // Execute the server tool WITHOUT emitting completion to sim-agent
+    const result = await copilotToolRegistry.execute('edit_workflow', params)
+
+    const duration = Date.now() - start
+    logger.info(`[${requestId}] edit_workflow (logic-only) completed`, {
+      success: result.success,
+      duration,
+    })
+
+    return NextResponse.json(result, { status: result.success ? 200 : 400 })
+  } catch (error) {
+    logger.error('Logic execution failed for edit_workflow', {
+      error: error instanceof Error ? error.message : 'Unknown error',
+    })
+    if (error instanceof z.ZodError) {
+      return NextResponse.json(
+        { success: false, error: error.errors.map((e) => e.message).join(', ') },
+        { status: 400 }
+      )
+    }
+    return NextResponse.json({ success: false, error: 'Internal server error' }, { status: 500 })
+  }
+}

apps/sim/app/api/yaml/diff/create/route.ts

@@ -201,6 +201,22 @@ export async function POST(request: NextRequest) {
     const finalResult = result
 
     if (result.success && result.diff?.proposedState) {
+      // Remove invalid blocks that are missing required properties to avoid canvas warnings
+      try {
+        const rawBlocks = result.diff.proposedState.blocks || {}
+        const sanitizedBlocks: Record<string, any> = {}
+        Object.entries(rawBlocks).forEach(([id, block]: [string, any]) => {
+          if (block && typeof block === 'object' && block.type && block.name) {
+            sanitizedBlocks[id] = block
+          } else {
+            logger.warn(`[${requestId}] Dropping invalid proposed block`, { id, block })
+          }
+        })
+        result.diff.proposedState.blocks = sanitizedBlocks
+      } catch (e) {
+        logger.warn(`[${requestId}] Failed to sanitize proposed blocks`, e)
+      }
+
       // First, fix parent-child relationships based on edges
       const blocks = result.diff.proposedState.blocks
       const edges = result.diff.proposedState.edges || []
@@ -274,6 +290,21 @@ export async function POST(request: NextRequest) {
       const blocks = result.blocks
       const edges = result.edges || []
 
+      // Remove invalid blocks prior to transformation
+      try {
+        const sanitized: Record<string, any> = {}
+        Object.entries(blocks).forEach(([id, block]: [string, any]) => {
+          if (block && typeof block === 'object' && block.type && block.name) {
+            sanitized[id] = block
+          } else {
+            logger.warn(`[${requestId}] Dropping invalid block in auto-layout response`, { id })
+          }
+        })
+        ;(result as any).blocks = sanitized
+      } catch (e) {
+        logger.warn(`[${requestId}] Failed to sanitize auto-layout blocks`, e)
+      }
+
       // Find all loop and parallel blocks
       const containerBlocks = Object.values(blocks).filter(
         (block: any) => block.type === 'loop' || block.type === 'parallel'

apps/sim/lib/copilot/api.ts

@@ -57,13 +57,14 @@ export interface SendMessageRequest {
   chatId?: string
   workflowId?: string
   mode?: 'ask' | 'agent'
-  depth?: -2 | -1 | 0 | 1 | 2 | 3
+  depth?: 0 | 1 | 2 | 3
   prefetch?: boolean
   createNewChat?: boolean
   stream?: boolean
   implicitFeedback?: string
   fileAttachments?: MessageFileAttachment[]
   abortSignal?: AbortSignal
+  userWorkflow?: string
 }
 
 /**
@@ -103,13 +104,27 @@ export async function sendStreamingMessage(
 ): Promise<StreamingResponse> {
   try {
     const { abortSignal, ...requestBody } = request
-    const response = await fetch('/api/copilot/chat', {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ ...requestBody, stream: true }),
-      signal: abortSignal,
-      credentials: 'include', // Include cookies for session authentication
-    })
+
+    // Simple, single retry for transient failures
+    const attempt = async (): Promise<Response> => {
+      return fetch('/api/copilot/chat', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ ...requestBody, stream: true }),
+        signal: abortSignal,
+        credentials: 'include', // Include cookies for session authentication
+      })
+    }
+
+    let response = await attempt()
+
+    // Retry once on likely transient server/network issues (5xx)
+    if (!response.ok && response.status >= 500 && response.status < 600) {
+      try {
+        await new Promise((r) => setTimeout(r, 200))
+      } catch {}
+      response = await attempt()
+    }
 
     if (!response.ok) {
       const errorMessage = await handleApiError(response, 'Failed to send streaming message')

apps/sim/lib/copilot/tools/client-tools/build-workflow.ts

@@ -19,12 +19,13 @@ export class BuildWorkflowClientTool extends BaseTool {
     id: BuildWorkflowClientTool.id,
     displayConfig: {
       states: {
-        executing: { displayName: 'Building workflow from YAML', icon: 'spinner' },
+        executing: { displayName: 'Building workflow', icon: 'spinner' },
         success: { displayName: 'Built workflow', icon: 'grid2x2Check' },
         ready_for_review: { displayName: 'Ready for review', icon: 'grid2x2' },
-        rejected: { displayName: 'Skipped building workflow', icon: 'skip' },
+        rejected: { displayName: 'Skipped building workflow', icon: 'circle-slash' },
         errored: { displayName: 'Failed to build workflow', icon: 'error' },
         aborted: { displayName: 'Aborted building workflow', icon: 'abort' },
+        accepted: { displayName: 'Built workflow', icon: 'grid2x2Check' },
       },
     },
     schema: {
@@ -74,13 +75,25 @@ export class BuildWorkflowClientTool extends BaseTool {
         return { success: false, error: 'yamlContent is required' }
       }
 
-      // Do not call /api/copilot/methods for build_workflow. Succeed locally and pass through data.
-      logger.info('build_workflow: performing local success without server call', {
-        hasDescription: !!description,
-        yamlLength: yamlContent.length,
+      // 1) Call logic-only execute route to get build result without emitting completion
+      const execResp = await fetch('/api/copilot/workflows/build/execute', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        credentials: 'include',
+        body: JSON.stringify({ yamlContent, ...(description ? { description } : {}) }),
       })
+      if (!execResp.ok) {
+        const e = await execResp.json().catch(() => ({}))
+        options?.onStateChange?.('errored')
+        return { success: false, error: e?.error || 'Failed to build workflow' }
+      }
+      const execResult = await execResp.json()
+      if (!execResult.success) {
+        options?.onStateChange?.('errored')
+        return { success: false, error: execResult.error || 'Server method failed' }
+      }
 
-      // Trigger diff directly
+      // 2) Update diff from YAML
       try {
         await useWorkflowDiffStore.getState().setProposedChanges(yamlContent)
         logger.info('Diff store updated from build_workflow YAML')
@@ -90,6 +103,21 @@ export class BuildWorkflowClientTool extends BaseTool {
         })
       }
 
+      // 3) Notify completion to agent without re-executing logic
+      try {
+        await fetch('/api/copilot/tools/complete', {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          credentials: 'include',
+          body: JSON.stringify({
+            toolId: toolCall.id,
+            methodId: 'build_workflow',
+            success: true,
+            data: execResult.data,
+          }),
+        })
+      } catch {}
+
       // Transition to ready_for_review for store compatibility
       options?.onStateChange?.('success')
       options?.onStateChange?.('ready_for_review')
@@ -99,7 +127,7 @@ export class BuildWorkflowClientTool extends BaseTool {
         data: {
           yamlContent,
           ...(description ? { description } : {}),
-          note: 'Build workflow handled on client without server call',
+          ...(execResult?.data ? { data: execResult.data } : {}),
         },
       }
     } catch (error: any) {