Fix run workflow

Author: Sg312

apps/sim/app/api/workflows/[id]/execute/route.ts

@@ -62,20 +62,23 @@ const ExecuteWorkflowSchema = z.object({
   runFromBlock: z
     .object({
       startBlockId: z.string().min(1, 'Start block ID is required'),
-      sourceSnapshot: z.object({
-        blockStates: z.record(z.any()),
-        executedBlocks: z.array(z.string()),
-        blockLogs: z.array(z.any()),
-        decisions: z.object({
-          router: z.record(z.string()),
-          condition: z.record(z.string()),
-        }),
-        completedLoops: z.array(z.string()),
-        loopExecutions: z.record(z.any()).optional(),
-        parallelExecutions: z.record(z.any()).optional(),
-        parallelBlockMapping: z.record(z.any()).optional(),
-        activeExecutionPath: z.array(z.string()),
-      }),
+      sourceSnapshot: z
+        .object({
+          blockStates: z.record(z.any()),
+          executedBlocks: z.array(z.string()),
+          blockLogs: z.array(z.any()),
+          decisions: z.object({
+            router: z.record(z.string()),
+            condition: z.record(z.string()),
+          }),
+          completedLoops: z.array(z.string()),
+          loopExecutions: z.record(z.any()).optional(),
+          parallelExecutions: z.record(z.any()).optional(),
+          parallelBlockMapping: z.record(z.any()).optional(),
+          activeExecutionPath: z.array(z.string()),
+        })
+        .optional(),
+      executionId: z.string().optional(),
     })
     .optional(),
 })
@@ -269,9 +272,30 @@ export async function POST(req: NextRequest, { params }: { params: Promise<{ id:
       base64MaxBytes,
       workflowStateOverride,
       stopAfterBlockId,
-      runFromBlock,
+      runFromBlock: rawRunFromBlock,
     } = validation.data
 
+    // Resolve runFromBlock snapshot from executionId if needed
+    let runFromBlock = rawRunFromBlock
+    if (runFromBlock && !runFromBlock.sourceSnapshot && runFromBlock.executionId) {
+      const {
+        getExecutionState,
+        getLatestExecutionState,
+      } = await import('@/lib/workflows/executor/execution-state')
+      const snapshot = runFromBlock.executionId === 'latest'
+        ? await getLatestExecutionState(id)
+        : await getExecutionState(runFromBlock.executionId)
+      if (!snapshot) {
+        return NextResponse.json(
+          {
+            error: `No execution state found for ${runFromBlock.executionId === 'latest' ? 'workflow' : `execution ${runFromBlock.executionId}`}. Run the full workflow first.`,
+          },
+          { status: 400 }
+        )
+      }
+      runFromBlock = { startBlockId: runFromBlock.startBlockId, sourceSnapshot: snapshot }
+    }
+
     // For API key and internal JWT auth, the entire body is the input (except for our control fields)
     // For session auth, the input is explicitly provided in the input field
     const input =

apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/copilot/components/tool-call/tool-call.tsx

@@ -18,6 +18,10 @@ import { LoopTool } from '@/app/workspace/[workspaceId]/w/[workflowId]/component
 import { ParallelTool } from '@/app/workspace/[workspaceId]/w/[workflowId]/components/subflows/parallel/parallel-config'
 import { getDisplayValue } from '@/app/workspace/[workspaceId]/w/[workflowId]/components/workflow-block/workflow-block'
 import { getBlock } from '@/blocks/registry'
+import {
+  CLIENT_EXECUTABLE_RUN_TOOLS,
+  executeRunToolOnClient,
+} from '@/lib/copilot/client-sse/run-tool-execution'
 import type { CopilotToolCall } from '@/stores/panel'
 import { useCopilotStore } from '@/stores/panel'
 import type { SubAgentContentBlock } from '@/stores/panel/copilot/types'
@@ -1277,6 +1281,14 @@ async function handleRun(
   setToolCallState(toolCall, 'executing', editedParams ? { params: editedParams } : undefined)
   onStateChange?.('executing')
   await sendToolDecision(toolCall.id, 'accepted')
+
+  // Client-executable run tools: execute on the client for real-time feedback
+  // (block pulsing, console logs, stop button). The server defers execution
+  // for these tools; the client reports back via mark-complete.
+  if (CLIENT_EXECUTABLE_RUN_TOOLS.has(toolCall.name)) {
+    const params = editedParams || toolCall.params || {}
+    executeRunToolOnClient(toolCall.id, toolCall.name, params)
+  }
 }
 
 async function handleSkip(toolCall: CopilotToolCall, setToolCallState: any, onStateChange?: any) {

apps/sim/app/workspace/[workspaceId]/w/[workflowId]/utils/workflow-execution-utils.ts

@@ -11,6 +11,12 @@ export interface WorkflowExecutionOptions {
   executionId?: string
   onBlockComplete?: (blockId: string, output: any) => Promise<void>
   overrideTriggerType?: 'chat' | 'manual' | 'api'
+  stopAfterBlockId?: string
+  /** For run_from_block / run_block: start from a specific block using cached state */
+  runFromBlock?: {
+    startBlockId: string
+    executionId?: string
+  }
 }
 
 /**
@@ -39,6 +45,15 @@ export async function executeWorkflowWithFullLogging(
     triggerType: options.overrideTriggerType || 'manual',
     useDraftState: true,
     isClientSession: true,
+    ...(options.stopAfterBlockId ? { stopAfterBlockId: options.stopAfterBlockId } : {}),
+    ...(options.runFromBlock
+      ? {
+          runFromBlock: {
+            startBlockId: options.runFromBlock.startBlockId,
+            executionId: options.runFromBlock.executionId || 'latest',
+          },
+        }
+      : {}),
   }
 
   const response = await fetch(`/api/workflows/${activeWorkflowId}/execute`, {

apps/sim/lib/copilot/client-sse/handlers.ts

@@ -16,10 +16,15 @@ import { useWorkflowDiffStore } from '@/stores/workflow-diff/store'
 import { useWorkflowRegistry } from '@/stores/workflows/registry/store'
 import type { WorkflowState } from '@/stores/workflows/workflow/types'
 import { appendTextBlock, beginThinkingBlock, finalizeThinkingBlock } from './content-blocks'
+import {
+  CLIENT_EXECUTABLE_RUN_TOOLS,
+  executeRunToolOnClient,
+} from './run-tool-execution'
 import type { ClientContentBlock, ClientStreamingContext } from './types'
 
 const logger = createLogger('CopilotClientSseHandlers')
 const TEXT_BLOCK_TYPE = 'text'
+
 const MAX_BATCH_INTERVAL = 50
 const MIN_BATCH_INTERVAL = 16
 const MAX_QUEUE_SIZE = 5
@@ -408,6 +413,39 @@ export const sseHandlers: Record<string, SSEHandler> = {
             })
           }
         }
+
+        // Generate API key: update deployment status with the new key
+        if (targetState === ClientToolCallState.success && current.name === 'generate_api_key') {
+          try {
+            const resultPayload = asRecord(
+              data?.result || eventData.result || eventData.data || data?.data
+            )
+            const input = asRecord(current.params)
+            const workflowId =
+              (input?.workflowId as string) || useWorkflowRegistry.getState().activeWorkflowId
+            const apiKey = (resultPayload?.apiKey || resultPayload?.key) as string | undefined
+            if (workflowId) {
+              const existingStatus =
+                useWorkflowRegistry.getState().getWorkflowDeploymentStatus(workflowId)
+              useWorkflowRegistry
+                .getState()
+                .setDeploymentStatus(
+                  workflowId,
+                  existingStatus?.isDeployed ?? false,
+                  existingStatus?.deployedAt,
+                  apiKey
+                )
+              logger.info('[SSE] Updated deployment status with API key', {
+                workflowId,
+                hasKey: !!apiKey,
+              })
+            }
+          } catch (err) {
+            logger.warn('[SSE] Failed to hydrate API key status', {
+              error: err instanceof Error ? err.message : String(err),
+            })
+          }
+        }
       }
 
       for (let i = 0; i < context.contentBlocks.length; i++) {
@@ -588,6 +626,16 @@ export const sseHandlers: Record<string, SSEHandler> = {
       sendAutoAcceptConfirmation(id)
     }
 
+    // Client-executable run tools: execute on the client for real-time feedback
+    // (block pulsing, console logs, stop button). The server defers execution
+    // for these tools in interactive mode; the client reports back via mark-complete.
+    if (
+      CLIENT_EXECUTABLE_RUN_TOOLS.has(toolName) &&
+      initialState === ClientToolCallState.executing
+    ) {
+      executeRunToolOnClient(id, toolName, args || existing?.params || {})
+    }
+
     // OAuth: dispatch event to open the OAuth connect modal
     if (toolName === 'oauth_request_access' && args && typeof window !== 'undefined') {
       try {