diff --git a/packages/bruno-electron/src/ipc/network/index.js b/packages/bruno-electron/src/ipc/network/index.js
index 490fc2535..42f3bfaf8 100644
--- a/packages/bruno-electron/src/ipc/network/index.js
+++ b/packages/bruno-electron/src/ipc/network/index.js
@@ -398,6 +398,19 @@ const registerNetworkIpc = (mainWindow) => {
     });
   };
 
+  const notifyScriptExecution = ({
+    channel,           // 'main:run-request-event' | 'main:run-folder-event'
+    basePayload,       // request-level or runner-level identifiers
+    scriptType,        // 'pre-request' | 'post-response' | 'test'
+    error              // optional Error
+  }) => {
+    mainWindow.webContents.send(channel, {
+      type: `${scriptType}-script-execution`,
+      ...basePayload,
+      errorMessage: error ? (error.message || `An error occurred in ${scriptType.replace('-', ' ')} script`) : null
+    });
+  };
+
   const runPreRequest = async (
     request,
     requestUid,
@@ -594,9 +607,10 @@ const registerNetworkIpc = (mainWindow) => {
       request.signal = abortController.signal;
       saveCancelToken(cancelTokenUid, abortController);
 
-      
+      let preRequestScriptResult = null;
+      let preRequestError = null;
       try {
-        const preRequestScriptResult = await runPreRequest(
+        preRequestScriptResult = await runPreRequest(
           request,
           requestUid,
           envVars,
@@ -608,34 +622,29 @@ const registerNetworkIpc = (mainWindow) => {
           scriptingConfig,
           runRequestByItemPathname
         );
-
-        if (preRequestScriptResult?.results) {
-          mainWindow.webContents.send('main:run-request-event', {
-            type: 'test-results-pre-request',
-            results: preRequestScriptResult.results,
-            itemUid: item.uid,
-            requestUid,
-            collectionUid
-          });
-        }
-
-        !runInBackground && mainWindow.webContents.send('main:run-request-event', {
-          type: 'pre-request-script-execution',
-          requestUid,
-          collectionUid,
-          itemUid: item.uid,
-          errorMessage: null,
-        });
-
       } catch (error) {
-        !runInBackground && mainWindow.webContents.send('main:run-request-event', {
-          type: 'pre-request-script-execution',
-          requestUid,
-          collectionUid,
+        preRequestError = error;
+      }
+
+      if (preRequestScriptResult?.results) {
+        mainWindow.webContents.send('main:run-request-event', {
+          type: 'test-results-pre-request',
+          results: preRequestScriptResult.results,
           itemUid: item.uid,
-          errorMessage: error?.message || 'An error occurred in pre-request script',
+          requestUid,
+          collectionUid
         });
-        return Promise.reject(error);
+      }
+
+      !runInBackground && notifyScriptExecution({
+        channel: 'main:run-request-event',
+        basePayload: { requestUid, collectionUid, itemUid: item.uid },
+        scriptType: 'pre-request',
+        error: preRequestError
+      });
+
+      if (preRequestError) {
+        return Promise.reject(preRequestError);
       }
       const axiosInstance = await configureRequest(
         collectionUid,
@@ -734,8 +743,10 @@ const registerNetworkIpc = (mainWindow) => {
 
       mainWindow.webContents.send('main:cookies-update', safeParseJSON(safeStringifyJSON(domainsWithCookies)));
 
+      let postResponseScriptResult = null;
+      let postResponseError = null;
       try {
-        const postResponseScriptResult = await runPostResponse(
+        postResponseScriptResult = await runPostResponse(
           request,
           response,
           requestUid,
@@ -748,38 +759,28 @@ const registerNetworkIpc = (mainWindow) => {
           scriptingConfig,
           runRequestByItemPathname
         );
-
-        if (postResponseScriptResult?.results) {
-          mainWindow.webContents.send('main:run-request-event', {
-            type: 'test-results-post-response',
-            results: postResponseScriptResult.results,
-            itemUid: item.uid,
-            requestUid,
-            collectionUid
-          });
-        }
-        !runInBackground && mainWindow.webContents.send('main:run-request-event', {
-          type: 'post-response-script-execution',
-          requestUid,
-          collectionUid,
-          errorMessage: null,
-          itemUid: item.uid,
-        });
       } catch (error) {
         console.error('Post-response script error:', error);
-
-        // Format a more readable error message
-        const errorMessage = error?.message || 'An error occurred in post-response script';
-
-        !runInBackground && mainWindow.webContents.send('main:run-request-event', {
-          type: 'post-response-script-execution',
-          requestUid,
-          errorMessage,
-          collectionUid,
+        postResponseError = error;
+      }
+      
+      if (postResponseScriptResult?.results) {
+        mainWindow.webContents.send('main:run-request-event', {
+          type: 'test-results-post-response',
+          results: postResponseScriptResult.results,
           itemUid: item.uid,
+          requestUid,
+          collectionUid
         });
       }
 
+      !runInBackground && notifyScriptExecution({
+        channel: 'main:run-request-event',
+        basePayload: { requestUid, collectionUid, itemUid: item.uid },
+        scriptType: 'post-response',
+        error: postResponseError
+      });
+
       // run assertions
       const assertions = get(request, 'assertions');
       if (assertions) {
@@ -861,19 +862,12 @@ const registerNetworkIpc = (mainWindow) => {
 
         collection.globalEnvironmentVariables = testResults.globalEnvironmentVariables;
 
-        const testScriptExecutionEvent = {
-          type: 'test-script-execution',
-          requestUid,
-          collectionUid,
-          itemUid: item.uid,
-          errorMessage: null,
-        }
-
-        if (testError) {
-          const errorMessage = testError?.message || 'An error occurred in test script';
-          testScriptExecutionEvent.errorMessage = errorMessage;
-        }
-        !runInBackground && mainWindow.webContents.send('main:run-request-event', testScriptExecutionEvent);
+        !runInBackground && notifyScriptExecution({
+          channel: 'main:run-request-event',
+          basePayload: { requestUid, collectionUid, itemUid: item.uid },
+          scriptType: 'test',
+          error: testError
+        });
       }
 
       return {
@@ -1033,6 +1027,7 @@ const registerNetworkIpc = (mainWindow) => {
 
           try {
             let preRequestScriptResult;
+            let preRequestError = null;
             try {
               preRequestScriptResult = await runPreRequest(
                 request,
@@ -1046,34 +1041,28 @@ const registerNetworkIpc = (mainWindow) => {
                 scriptingConfig,
                 runRequestByItemPathname
               );
-
-              // Send pre-request test results if available
-              if (preRequestScriptResult?.results) {
-                mainWindow.webContents.send('main:run-folder-event', {
-                  type: 'test-results-pre-request',
-                  preRequestTestResults: preRequestScriptResult.results,
-                  ...eventData
-                });
-              }
-
-              mainWindow.webContents.send('main:run-folder-event', {
-                type: 'pre-request-script-execution',
-                ...eventData,
-                errorMessage: null,
-              });
             } catch (error) {
               console.error('Pre-request script error:', error);
+              preRequestError = error;
+            }
 
-              // Format a more readable error message
-              const errorMessage = error?.message || 'An error occurred in pre-request script';
-
+            if (preRequestScriptResult?.results) {
               mainWindow.webContents.send('main:run-folder-event', {
-                type: 'pre-request-script-execution',
-                ...eventData,
-                errorMessage: errorMessage,
+                type: 'test-results-pre-request',
+                preRequestTestResults: preRequestScriptResult.results,
+                ...eventData
               });
-              
-              throw error;
+            }
+
+            notifyScriptExecution({
+              channel: 'main:run-folder-event',
+              basePayload: eventData,
+              scriptType: 'pre-request',
+              error: preRequestError
+            });
+
+            if (preRequestError) {
+              throw preRequestError;
             }
 
             if (preRequestScriptResult?.nextRequestName !== undefined) {
@@ -1223,6 +1212,7 @@ const registerNetworkIpc = (mainWindow) => {
             }
 
             let postResponseScriptResult;
+            let postResponseError = null;
             try {
               postResponseScriptResult = await runPostResponse(
                 request,
@@ -1237,25 +1227,18 @@ const registerNetworkIpc = (mainWindow) => {
                 scriptingConfig,
                 runRequestByItemPathname
               );
-
-              mainWindow.webContents.send('main:run-folder-event', {
-                type: 'post-response-script-execution',
-                ...eventData,
-                errorMessage: null,
-              });
             } catch (error) {
               console.error('Post-response script error:', error);
-
-              // Format a more readable error message
-              const errorMessage = error?.message || 'An error occurred in post-response script';
-
-              mainWindow.webContents.send('main:run-folder-event', {
-                type: 'post-response-script-execution',
-                ...eventData,
-                errorMessage: errorMessage,
-              });
+              postResponseError = error;
             }
 
+            notifyScriptExecution({
+              channel: 'main:run-folder-event',
+              basePayload: eventData,
+              scriptType: 'post-response',
+              error: postResponseError
+            });
+
             if (postResponseScriptResult?.nextRequestName !== undefined) {
               nextRequestName = postResponseScriptResult.nextRequestName;
             }
@@ -1375,18 +1358,12 @@ const registerNetworkIpc = (mainWindow) => {
                 }
               }
 
-              const testScriptExecutionEvent = {
-                type: 'test-script-execution',
-                ...eventData,
-                errorMessage: null,
-              }
-
-              if (testError) {
-                const errorMessage = testError?.message || 'An error occurred in test script';
-                testScriptExecutionEvent.errorMessage = errorMessage;
-              }
-              
-              mainWindow.webContents.send('main:run-folder-event', testScriptExecutionEvent);
+              notifyScriptExecution({
+                channel: 'main:run-folder-event',
+                basePayload: eventData,
+                scriptType: 'test',
+                error: testError
+              });
             }
           } catch (error) {
             mainWindow.webContents.send('main:run-folder-event', {