fix(logs): surface handled errors as info in logs

apps/sim/app/workspace/[workspaceId]/logs/components/log-details/components/trace-spans/trace-spans.tsx

@@ -67,7 +67,7 @@ function parseTime(value?: string | number | null): number {
 }
 
 /**
- * Checks if a span or any of its descendants has an error
+ * Checks if a span or any of its descendants has an error (any error).
  */
 function hasErrorInTree(span: TraceSpan): boolean {
   if (span.status === 'error') return true
@@ -80,6 +80,23 @@ function hasErrorInTree(span: TraceSpan): boolean {
   return false
 }
 
+/**
+ * Checks if a span or any of its descendants has an unhandled error.
+ * Spans with errorHandled: true (including containers that propagate it)
+ * are skipped. Used only for the root workflow span to match the actual
+ * workflow status.
+ */
+function hasUnhandledErrorInTree(span: TraceSpan): boolean {
+  if (span.status === 'error' && !span.errorHandled) return true
+  if (span.children && span.children.length > 0) {
+    return span.children.some((child) => hasUnhandledErrorInTree(child))
+  }
+  if (span.toolCalls && span.toolCalls.length > 0 && !span.errorHandled) {
+    return span.toolCalls.some((tc) => tc.error)
+  }
+  return false
+}
+
 /**
  * Normalizes and sorts trace spans recursively.
  * Deduplicates children and sorts by start time.
@@ -478,14 +495,13 @@ const TraceSpanNode = memo(function TraceSpanNode({
   const duration = span.duration || spanEndTime - spanStartTime
 
   const isDirectError = span.status === 'error'
-  const hasNestedError = hasErrorInTree(span)
+  const isRootWorkflow = depth === 0
+  const isRootWorkflowSpan = isRootWorkflow && span.type?.toLowerCase() === 'workflow'
+  const hasNestedError = isRootWorkflowSpan ? hasUnhandledErrorInTree(span) : hasErrorInTree(span)
   const showErrorStyle = isDirectError || hasNestedError
 
   const { icon: BlockIcon, bgColor } = getBlockIconAndColor(span.type, span.name)
 
-  // Root workflow execution is always expanded and has no toggle
-  const isRootWorkflow = depth === 0
-
   // Build all children including tool calls
   const allChildren = useMemo(() => {
     const children: TraceSpan[] = []

apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/workflow-edge/workflow-edge.tsx

@@ -95,7 +95,6 @@ const WorkflowEdgeComponent = ({
       color = 'var(--brand-tertiary-2)'
     } else if (edgeRunStatus === 'success') {
       // Use green for preview mode, default for canvas execution
-      // This also applies to error edges that were taken (error path executed)
       color = previewExecutionStatus ? 'var(--brand-tertiary-2)' : 'var(--border-success)'
     } else if (edgeRunStatus === 'error') {
       color = 'var(--text-error)'

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

@@ -55,7 +55,7 @@ interface DebugValidationResult {
 interface BlockEventHandlerConfig {
   workflowId?: string
   executionId?: string
-  workflowEdges: Array<{ id: string; target: string }>
+  workflowEdges: Array<{ id: string; target: string; sourceHandle?: string | null }>
   activeBlocksSet: Set<string>
   accumulatedBlockLogs: BlockLog[]
   accumulatedBlockStates: Map<string, BlockState>
@@ -322,7 +322,8 @@ export function useWorkflowExecution() {
         if (!workflowId) return
         const incomingEdges = workflowEdges.filter((edge) => edge.target === blockId)
         incomingEdges.forEach((edge) => {
-          setEdgeRunStatus(workflowId, edge.id, 'success')
+          const status = edge.sourceHandle === 'error' ? 'error' : 'success'
+          setEdgeRunStatus(workflowId, edge.id, status)
         })
       }
 

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

@@ -288,6 +288,9 @@ export class BlockExecutor {
 
     const hasErrorPort = this.hasErrorPortEdge(node)
     if (hasErrorPort) {
+      if (blockLog) {
+        blockLog.errorHandled = true
+      }
       logger.info('Block has error port - returning error output instead of throwing', {
         blockId: node.id,
         error: errorMessage,

apps/sim/executor/types.ts

@@ -112,6 +112,8 @@ export interface BlockLog {
   output?: any
   input?: any
   error?: string
+  /** Whether this error was handled by an error handler path (error port) */
+  errorHandled?: boolean
   loopId?: string
   parallelId?: string
   iterationIndex?: number

apps/sim/lib/logs/execution/logger.ts

@@ -219,11 +219,12 @@ export class ExecutionLogger implements IExecutionLoggerService {
       | { traceSpans?: TraceSpan[] }
       | undefined
 
-    // Determine if workflow failed by checking trace spans for errors
+    // Determine if workflow failed by checking trace spans for unhandled errors
+    // Errors handled by error handler paths (errorHandled: true) don't count as workflow failures
     // Use the override if provided (for cost-only fallback scenarios)
     const hasErrors = traceSpans?.some((span: any) => {
       const checkSpanForErrors = (s: any): boolean => {
-        if (s.status === 'error') return true
+        if (s.status === 'error' && !s.errorHandled) return true
         if (s.children && Array.isArray(s.children)) {
           return s.children.some(checkSpanForErrors)
         }

apps/sim/lib/logs/execution/logging-session.ts

@@ -301,7 +301,7 @@ export class LoggingSession {
 
           const hasErrors = traceSpans.some((span: any) => {
             const checkForErrors = (s: any): boolean => {
-              if (s.status === 'error') return true
+              if (s.status === 'error' && !s.errorHandled) return true
               if (s.children && Array.isArray(s.children)) {
                 return s.children.some(checkForErrors)
               }