format ms as whole nums,round secs to 2 decimal places and compute all started/ended times on server and passback to clinet

Author: waleedlatif1

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

@@ -616,6 +616,8 @@ export async function POST(req: NextRequest, { params }: { params: Promise<{ id:
                   input: callbackData.input,
                   error: callbackData.output.error,
                   durationMs: callbackData.executionTime || 0,
+                  startedAt: callbackData.startedAt,
+                  endedAt: callbackData.endedAt,
                   ...(iterationContext && {
                     iterationCurrent: iterationContext.iterationCurrent,
                     iterationTotal: iterationContext.iterationTotal,
@@ -641,6 +643,8 @@ export async function POST(req: NextRequest, { params }: { params: Promise<{ id:
                   input: callbackData.input,
                   output: callbackData.output,
                   durationMs: callbackData.executionTime || 0,
+                  startedAt: callbackData.startedAt,
+                  endedAt: callbackData.endedAt,
                   ...(iterationContext && {
                     iterationCurrent: iterationContext.iterationCurrent,
                     iterationTotal: iterationContext.iterationTotal,

apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/terminal/utils.ts

@@ -58,7 +58,9 @@ export function getBlockColor(blockType: string): string {
  */
 export function formatDuration(ms?: number): string {
   if (ms === undefined || ms === null) return '-'
-  if (ms < 1000) return `${ms}ms`
+  if (ms < 1000) {
+    return `${Math.round(ms)}ms`
+  }
   return `${(ms / 1000).toFixed(2)}s`
 }
 

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

@@ -964,8 +964,8 @@ export function useWorkflowExecution() {
               const isContainerBlock = data.blockType === 'loop' || data.blockType === 'parallel'
               if (isContainerBlock) return
 
-              const startedAt = new Date(Date.now() - data.durationMs).toISOString()
-              const endedAt = new Date().toISOString()
+              const startedAt = data.startedAt
+              const endedAt = data.endedAt
 
               accumulatedBlockLogs.push({
                 blockId: data.blockId,
@@ -1013,8 +1013,8 @@ export function useWorkflowExecution() {
               // Track failed block execution in run path
               setBlockRunStatus(data.blockId, 'error')
 
-              const startedAt = new Date(Date.now() - data.durationMs).toISOString()
-              const endedAt = new Date().toISOString()
+              const startedAt = data.startedAt
+              const endedAt = data.endedAt
 
               // Accumulate block error log for the execution result
               accumulatedBlockLogs.push({
@@ -1603,8 +1603,8 @@ export function useWorkflowExecution() {
               const isContainerBlock = data.blockType === 'loop' || data.blockType === 'parallel'
               if (isContainerBlock) return
 
-              const startedAt = new Date(Date.now() - data.durationMs).toISOString()
-              const endedAt = new Date().toISOString()
+              const startedAt = data.startedAt
+              const endedAt = data.endedAt
 
               accumulatedBlockLogs.push({
                 blockId: data.blockId,
@@ -1642,8 +1642,8 @@ export function useWorkflowExecution() {
 
               setBlockRunStatus(data.blockId, 'error')
 
-              const startedAt = new Date(Date.now() - data.durationMs).toISOString()
-              const endedAt = new Date().toISOString()
+              const startedAt = data.startedAt
+              const endedAt = data.endedAt
 
               accumulatedBlockLogs.push({
                 blockId: data.blockId,

apps/sim/executor/execution/block-executor.ts

@@ -169,7 +169,9 @@ export class BlockExecutor {
           block,
           this.sanitizeInputsForLog(resolvedInputs),
           displayOutput,
-          duration
+          duration,
+          blockLog!.startedAt,
+          blockLog!.endedAt
         )
       }
 
@@ -274,7 +276,9 @@ export class BlockExecutor {
         block,
         this.sanitizeInputsForLog(input),
         displayOutput,
-        duration
+        duration,
+        blockLog!.startedAt,
+        blockLog!.endedAt
       )
     }
 
@@ -423,7 +427,9 @@ export class BlockExecutor {
     block: SerializedBlock,
     input: Record<string, any>,
     output: NormalizedBlockOutput,
-    duration: number
+    duration: number,
+    startedAt: string,
+    endedAt: string
   ): void {
     const blockId = node.id
     const blockName = block.metadata?.name ?? blockId
@@ -440,6 +446,8 @@ export class BlockExecutor {
           input,
           output,
           executionTime: duration,
+          startedAt,
+          endedAt,
         },
         iterationContext
       )

apps/sim/executor/execution/types.ts

@@ -103,7 +103,13 @@ export interface ContextExtensions {
     blockId: string,
     blockName: string,
     blockType: string,
-    output: { input?: any; output: NormalizedBlockOutput; executionTime: number },
+    output: {
+      input?: any
+      output: NormalizedBlockOutput
+      executionTime: number
+      startedAt: string
+      endedAt: string
+    },
     iterationContext?: IterationContext
   ) => Promise<void>
 

apps/sim/executor/orchestrators/loop.ts

@@ -281,9 +281,12 @@ export class LoopOrchestrator {
 
     // Emit onBlockComplete for the loop container so the UI can track it
     if (this.contextExtensions?.onBlockComplete) {
+      const now = new Date().toISOString()
       this.contextExtensions.onBlockComplete(loopId, 'Loop', 'loop', {
         output,
         executionTime: DEFAULTS.EXECUTION_TIME,
+        startedAt: now,
+        endedAt: now,
       })
     }
 

apps/sim/executor/orchestrators/parallel.ts

@@ -265,9 +265,12 @@ export class ParallelOrchestrator {
 
     // Emit onBlockComplete for the parallel container so the UI can track it
     if (this.contextExtensions?.onBlockComplete) {
+      const now = new Date().toISOString()
       this.contextExtensions.onBlockComplete(parallelId, 'Parallel', 'parallel', {
         output,
         executionTime: 0,
+        startedAt: now,
+        endedAt: now,
       })
     }
 

apps/sim/executor/utils/subflow-utils.ts

@@ -232,6 +232,8 @@ export function addSubflowErrorLog(
       input: inputData,
       output: { error: errorMessage },
       executionTime: 0,
+      startedAt: now,
+      endedAt: now,
     })
   }
 }

apps/sim/hooks/use-execution-stream.ts

@@ -1,8 +1,18 @@
 import { useCallback, useRef } from 'react'
 import { createLogger } from '@sim/logger'
-import type { ExecutionEvent } from '@/lib/workflows/executor/execution-events'
+import type {
+  BlockCompletedData,
+  BlockErrorData,
+  BlockStartedData,
+  ExecutionCancelledData,
+  ExecutionCompletedData,
+  ExecutionErrorData,
+  ExecutionEvent,
+  ExecutionStartedData,
+  StreamChunkData,
+  StreamDoneData,
+} from '@/lib/workflows/executor/execution-events'
 import type { SerializableExecutionState } from '@/executor/execution/types'
-import type { SubflowType } from '@/stores/workflows/workflow/types'
 
 const logger = createLogger('useExecutionStream')
 
@@ -81,48 +91,15 @@ async function processSSEStream(
 }
 
 export interface ExecutionStreamCallbacks {
-  onExecutionStarted?: (data: { startTime: string }) => void
-  onExecutionCompleted?: (data: {
-    success: boolean
-    output: any
-    duration: number
-    startTime: string
-    endTime: string
-  }) => void
-  onExecutionError?: (data: { error: string; duration: number }) => void
-  onExecutionCancelled?: (data: { duration: number }) => void
-  onBlockStarted?: (data: {
-    blockId: string
-    blockName: string
-    blockType: string
-    iterationCurrent?: number
-    iterationTotal?: number
-    iterationType?: SubflowType
-  }) => void
-  onBlockCompleted?: (data: {
-    blockId: string
-    blockName: string
-    blockType: string
-    input?: any
-    output: any
-    durationMs: number
-    iterationCurrent?: number
-    iterationTotal?: number
-    iterationType?: SubflowType
-  }) => void
-  onBlockError?: (data: {
-    blockId: string
-    blockName: string
-    blockType: string
-    input?: any
-    error: string
-    durationMs: number
-    iterationCurrent?: number
-    iterationTotal?: number
-    iterationType?: SubflowType
-  }) => void
-  onStreamChunk?: (data: { blockId: string; chunk: string }) => void
-  onStreamDone?: (data: { blockId: string }) => void
+  onExecutionStarted?: (data: ExecutionStartedData) => void
+  onExecutionCompleted?: (data: ExecutionCompletedData) => void
+  onExecutionError?: (data: ExecutionErrorData) => void
+  onExecutionCancelled?: (data: ExecutionCancelledData) => void
+  onBlockStarted?: (data: BlockStartedData) => void
+  onBlockCompleted?: (data: BlockCompletedData) => void
+  onBlockError?: (data: BlockErrorData) => void
+  onStreamChunk?: (data: StreamChunkData) => void
+  onStreamDone?: (data: StreamDoneData) => void
 }
 
 export interface ExecuteStreamOptions {

apps/sim/lib/workflows/executor/execution-core.ts

@@ -283,7 +283,13 @@ export async function executeWorkflowCore(
       blockId: string,
       blockName: string,
       blockType: string,
-      output: { input?: unknown; output: NormalizedBlockOutput; executionTime: number },
+      output: {
+        input?: unknown
+        output: NormalizedBlockOutput
+        executionTime: number
+        startedAt: string
+        endedAt: string
+      },
       iterationContext?: IterationContext
     ) => {
       await loggingSession.onBlockComplete(blockId, blockName, blockType, output)