feat: node-specific error tab, selection-aware grouping, and error overlay

- Remove TabError.vue; consolidate all error display into TabErrors.vue and remove the separate 'error' tab type from rightSidePanelStore - Single-node selection mode: regroup errors by message instead of class_type and render ErrorNodeCard in compact mode (hiding redundant header/message) - Container node support: detect internal errors in subgraph/group nodes by matching execution ID prefixes against selected container node IDs - SectionWidgets: show error badge and 'See Error' button for subgraph/group nodes that contain child-node errors, navigating directly to the errors tab - Add ErrorOverlay component: floating card after execution failure showing a deduplicated error summary with 'Dismiss' and 'See Errors' actions; 'See Errors' deselects all nodes and opens Errors tab in overview mode - Add isErrorOverlayOpen, showErrorOverlay, dismissErrorOverlay to executionStore; reset overlay state on execution_start
2026-04-20 14:30:41 +00:00 · 2026-02-18 17:09:04 +09:00
parent 34e21f3267
commit aa1c25f98e
14 changed files with 667 additions and 230 deletions
--- a/src/components/TopMenuSection.vue
+++ b/src/components/TopMenuSection.vue
@@ -110,6 +110,7 @@
            </Button>
          </div>
        </div>
+        <ErrorOverlay />
        <QueueProgressOverlay
          v-if="isQueueProgressOverlayEnabled"
          v-model:expanded="isQueueOverlayExpanded"
@@ -156,6 +157,7 @@ import StatusBadge from '@/components/common/StatusBadge.vue'
 import QueueInlineProgressSummary from '@/components/queue/QueueInlineProgressSummary.vue'
 import QueueNotificationBannerHost from '@/components/queue/QueueNotificationBannerHost.vue'
 import QueueProgressOverlay from '@/components/queue/QueueProgressOverlay.vue'
+import ErrorOverlay from '@/components/error/ErrorOverlay.vue'
 import ActionBarButtons from '@/components/topbar/ActionBarButtons.vue'
 import CurrentUserButton from '@/components/topbar/CurrentUserButton.vue'
 import LoginButton from '@/components/topbar/LoginButton.vue'
--- a/src/components/error/ErrorOverlay.vue
+++ b/src/components/error/ErrorOverlay.vue
@@ -0,0 +1,131 @@
+<template>
+  <Transition
+    enter-active-class="transition-all duration-300 ease-out"
+    enter-from-class="-translate-y-3 opacity-0"
+    enter-to-class="translate-y-0 opacity-100"
+  >
+    <div
+      v-if="isVisible"
+      :class="cn('flex justify-end w-full pointer-events-none')"
+    >
+      <div
+        class="pointer-events-auto flex w-80 min-w-72 flex-col overflow-hidden rounded-lg border border-interface-stroke bg-comfy-menu-bg shadow-interface transition-colors duration-200 ease-in-out"
+      >
+        <!-- Header -->
+        <div class="flex h-12 items-center gap-2 px-4">
+          <span class="flex-1 text-sm font-bold text-destructive-background">
+            {{ errorCountLabel }}
+          </span>
+          <Button
+            variant="muted-textonly"
+            size="icon-sm"
+            :aria-label="t('g.close')"
+            @click="dismiss"
+          >
+            <i class="icon-[lucide--x] block size-5 leading-none" />
+          </Button>
+        </div>
+
+        <!-- Body -->
+        <div class="px-4 pb-3">
+          <ul class="m-0 flex list-none flex-col gap-1.5 p-0">
+            <li
+              v-for="(entry, idx) in groupedErrors"
+              :key="idx"
+              class="flex items-baseline gap-2 text-sm leading-snug text-muted-foreground"
+            >
+              <span
+                class="mt-1.5 size-1 shrink-0 rounded-full bg-muted-foreground"
+              />
+              <span>{{ entry.message }}</span>
+            </li>
+          </ul>
+        </div>
+
+        <!-- Footer -->
+        <div class="flex items-center justify-end gap-4 px-4 py-3">
+          <Button variant="muted-textonly" size="unset" @click="dismiss">
+            {{ t('g.dismiss') }}
+          </Button>
+          <Button variant="secondary" size="lg" @click="seeErrors">
+            {{ t('errorOverlay.seeErrors') }}
+          </Button>
+        </div>
+      </div>
+    </div>
+  </Transition>
+</template>
+
+<script setup lang="ts">
+import { computed } from 'vue'
+import { useI18n } from 'vue-i18n'
+
+import Button from '@/components/ui/button/Button.vue'
+import type { NodeError } from '@/schemas/apiSchema'
+import { useExecutionStore } from '@/stores/executionStore'
+import { useRightSidePanelStore } from '@/stores/workspace/rightSidePanelStore'
+import { useCanvasStore } from '@/renderer/core/canvas/canvasStore'
+import { cn } from '@/utils/tailwindUtil'
+
+interface ErrorEntry {
+  message: string
+}
+
+const { t } = useI18n()
+const executionStore = useExecutionStore()
+const rightSidePanelStore = useRightSidePanelStore()
+const canvasStore = useCanvasStore()
+
+const groupedErrors = computed<ErrorEntry[]>(() => {
+  const messages = new Set<string>()
+
+  if (executionStore.lastPromptError) {
+    messages.add(executionStore.lastPromptError.message)
+  }
+
+  if (executionStore.lastNodeErrors) {
+    for (const nodeError of Object.values(
+      executionStore.lastNodeErrors
+    ) as NodeError[]) {
+      for (const err of nodeError.errors) {
+        messages.add(err.message)
+      }
+    }
+  }
+
+  if (executionStore.lastExecutionError) {
+    const e = executionStore.lastExecutionError
+    messages.add(`${e.exception_type}: ${e.exception_message}`)
+  }
+
+  return Array.from(messages).map((message) => ({ message }))
+})
+
+const totalErrorCount = computed(() => executionStore.totalErrorCount)
+
+const errorCountLabel = computed(() =>
+  t(
+    'errorOverlay.errorCount',
+    { count: totalErrorCount.value },
+    totalErrorCount.value
+  )
+)
+
+const isVisible = computed(
+  () => executionStore.isErrorOverlayOpen && totalErrorCount.value > 0
+)
+
+function dismiss() {
+  executionStore.dismissErrorOverlay()
+}
+
+function seeErrors() {
+  if (canvasStore.canvas) {
+    canvasStore.canvas.deselectAll()
+    canvasStore.updateSelectedItems()
+  }
+
+  rightSidePanelStore.openPanel('errors')
+  executionStore.dismissErrorOverlay()
+}
+</script>
--- a/src/components/rightSidePanel/RightSidePanel.vue
+++ b/src/components/rightSidePanel/RightSidePanel.vue
@@ -19,8 +19,8 @@ import { useRightSidePanelStore } from '@/stores/workspace/rightSidePanelStore'
 import type { RightSidePanelTab } from '@/stores/workspace/rightSidePanelStore'
 import { resolveNodeDisplayName } from '@/utils/nodeTitleUtil'
 import { cn } from '@/utils/tailwindUtil'
+import { isGroupNode } from '@/utils/executableGroupNodeDto'

-import TabError from './TabError.vue'
 import TabInfo from './info/TabInfo.vue'
 import TabGlobalParameters from './parameters/TabGlobalParameters.vue'
 import TabNodes from './parameters/TabNodes.vue'
@@ -96,30 +96,43 @@ type RightSidePanelTabList = Array<{
  icon?: string
 }>

-//FIXME all errors if nothing selected?
-const selectedNodeErrors = computed(() =>
-  selectedNodes.value
-    .map((node) => executionStore.getNodeErrors(`${node.id}`))
-    .filter((nodeError) => !!nodeError)
+const allErrorIds = computed<string[]>(() => {
+  const ids: string[] = []
+  if (executionStore.lastNodeErrors) {
+    ids.push(...Object.keys(executionStore.lastNodeErrors))
+  }
+  if (executionStore.lastExecutionError) {
+    ids.push(String(executionStore.lastExecutionError.node_id))
+  }
+  return ids
+})
+
+const hasDirectNodeError = computed(() =>
+  selectedNodes.value.some((node) =>
+    executionStore.activeGraphErrorNodeIds.has(String(node.id))
+  )
 )

+const hasContainerInternalError = computed(() => {
+  if (allErrorIds.value.length === 0) return false
+  return selectedNodes.value.some((node) => {
+    if (!(node instanceof SubgraphNode || isGroupNode(node))) return false
+    const prefix = `${node.id}:`
+    return allErrorIds.value.some((execId) => execId.startsWith(prefix))
+  })
+})
+
+const hasRelevantErrors = computed(() => {
+  if (!hasSelection.value) return hasAnyError.value
+  return hasDirectNodeError.value || hasContainerInternalError.value
+})
+
 const tabs = computed<RightSidePanelTabList>(() => {
  const list: RightSidePanelTabList = []
-  if (
-    selectedNodeErrors.value.length &&
-    settingStore.get('Comfy.RightSidePanel.ShowErrorsTab')
-  ) {
-    list.push({
-      label: () => t('g.error'),
-      value: 'error',
-      icon: 'icon-[lucide--octagon-alert] bg-node-stroke-error ml-1'
-    })
-  }

  if (
-    hasAnyError.value &&
-    !hasSelection.value &&
-    settingStore.get('Comfy.RightSidePanel.ShowErrorsTab')
+    settingStore.get('Comfy.RightSidePanel.ShowErrorsTab') &&
+    hasRelevantErrors.value
  ) {
    list.push({
      label: () => t('rightSidePanel.errors'),
@@ -315,9 +328,9 @@ function handleProxyWidgetsUpdate(value: ProxyWidgetsProperty) {

    <!-- Panel Content -->
    <div class="scrollbar-thin flex-1 overflow-y-auto">
-      <template v-if="!hasSelection">
-        <TabErrors v-if="activeTab === 'errors'" />
-        <TabGlobalParameters v-else-if="activeTab === 'parameters'" />
+      <TabErrors v-if="activeTab === 'errors'" />
+      <template v-else-if="!hasSelection">
+        <TabGlobalParameters v-if="activeTab === 'parameters'" />
        <TabNodes v-else-if="activeTab === 'nodes'" />
        <TabGlobalSettings v-else-if="activeTab === 'settings'" />
      </template>
@@ -326,7 +339,6 @@ function handleProxyWidgetsUpdate(value: ProxyWidgetsProperty) {
        :node="selectedSingleNode"
      />
      <template v-else>
-        <TabError v-if="activeTab === 'error'" :errors="selectedNodeErrors" />
        <TabSubgraphInputs
          v-if="activeTab === 'parameters' && isSingleSubgraphNode"
          :node="selectedSingleNode as SubgraphNode"
--- a/src/components/rightSidePanel/TabError.vue
+++ b/src/components/rightSidePanel/TabError.vue
@@ -1,30 +0,0 @@
-<script setup lang="ts">
-import { useI18n } from 'vue-i18n'
-
-import Button from '@/components/ui/button/Button.vue'
-import { useCopyToClipboard } from '@/composables/useCopyToClipboard'
-import type { NodeError } from '@/schemas/apiSchema'
-
-const { t } = useI18n()
-
-defineProps<{
-  errors: NodeError[]
-}>()
-const { copyToClipboard } = useCopyToClipboard()
-</script>
-<template>
-  <div class="m-4">
-    <Button class="w-full" @click="copyToClipboard(JSON.stringify(errors))">
-      {{ t('g.copy') }}
-      <i class="icon-[lucide--copy] size-4" />
-    </Button>
-  </div>
-  <div
-    v-for="(error, index) in errors.flatMap((ne) => ne.errors)"
-    :key="index"
-    class="px-2"
-  >
-    <h3 class="text-error" v-text="error.message" />
-    <div class="text-muted-foreground" v-text="error.details" />
-  </div>
-</template>
--- a/src/components/rightSidePanel/errors/ErrorNodeCard.vue
+++ b/src/components/rightSidePanel/errors/ErrorNodeCard.vue
@@ -1,10 +1,13 @@
 <template>
  <div class="overflow-hidden">
-    <!-- Card Header (Node ID & Actions) -->
-    <div v-if="card.nodeId" class="flex flex-wrap items-center gap-2 py-2">
+    <!-- Card Header -->
+    <div
+      v-if="card.nodeId && !compact"
+      class="flex flex-wrap items-center gap-2 py-2"
+    >
      <span
        v-if="showNodeIdBadge"
-        class="shrink-0 rounded-md bg-secondary-background-selected px-2 py-0.5 text-[10px] font-mono text-muted-foreground font-bold"
+        class="shrink-0 rounded-md bg-secondary-background-selected px-2 py-0.5 text-xs font-mono text-muted-foreground font-bold"
      >
        #{{ card.nodeId }}
      </span>
@@ -19,7 +22,7 @@
        variant="secondary"
        size="sm"
        class="rounded-lg text-sm shrink-0"
-        @click.stop="emit('enterSubgraph', card.nodeId ?? '')"
+        @click.stop="handleEnterSubgraph"
      >
        {{ t('rightSidePanel.enterSubgraph') }}
      </Button>
@@ -27,7 +30,8 @@
        variant="textonly"
        size="icon-sm"
        class="size-7 text-muted-foreground hover:text-base-foreground shrink-0"
-        @click.stop="emit('locateNode', card.nodeId ?? '')"
+        :aria-label="t('rightSidePanel.locateNode')"
+        @click.stop="handleLocateNode"
      >
        <i class="icon-[lucide--locate] size-3.5" />
      </Button>
@@ -43,7 +47,7 @@
      >
        <!-- Error Message -->
        <p
-          v-if="error.message"
+          v-if="error.message && !compact"
          class="m-0 text-sm break-words whitespace-pre-wrap leading-relaxed px-0.5"
        >
          {{ error.message }}
@@ -69,7 +73,7 @@
        <Button
          variant="secondary"
          size="sm"
-          class="w-full justify-center gap-2 h-8 text-[11px]"
+          class="w-full justify-center gap-2 h-8 text-xs"
          @click="handleCopyError(error)"
        >
          <i class="icon-[lucide--copy] size-3.5" />
@@ -88,9 +92,15 @@ import { cn } from '@/utils/tailwindUtil'

 import type { ErrorCardData, ErrorItem } from './types'

-const { card, showNodeIdBadge = false } = defineProps<{
+const {
+  card,
+  showNodeIdBadge = false,
+  compact = false
+} = defineProps<{
  card: ErrorCardData
  showNodeIdBadge?: boolean
+  /** Hide card header and error message (used in single-node selection mode) */
+  compact?: boolean
 }>()

 const emit = defineEmits<{
@@ -101,6 +111,18 @@ const emit = defineEmits<{

 const { t } = useI18n()

+function handleLocateNode() {
+  if (card.nodeId) {
+    emit('locateNode', card.nodeId)
+  }
+}
+
+function handleEnterSubgraph() {
+  if (card.nodeId) {
+    emit('enterSubgraph', card.nodeId)
+  }
+}
+
 function handleCopyError(error: ErrorItem) {
  emit(
    'copyToClipboard',
--- a/src/components/rightSidePanel/errors/TabErrors.vue
+++ b/src/components/rightSidePanel/errors/TabErrors.vue
@@ -55,8 +55,9 @@
              :key="card.id"
              :card="card"
              :show-node-id-badge="showNodeIdBadge"
-              @locate-node="focusNode"
-              @enter-subgraph="enterSubgraph"
+              :compact="isSingleNodeSelected"
+              @locate-node="handleLocateNode"
+              @enter-subgraph="handleEnterSubgraph"
              @copy-to-clipboard="copyToClipboard"
            />
          </div>
@@ -97,16 +98,16 @@
 </template>

 <script setup lang="ts">
-import { computed, reactive, ref, watch } from 'vue'
+import { computed, ref } from 'vue'
 import { useI18n } from 'vue-i18n'

 import { useCommandStore } from '@/stores/commandStore'
-import { useRightSidePanelStore } from '@/stores/workspace/rightSidePanelStore'
 import { useCopyToClipboard } from '@/composables/useCopyToClipboard'
 import { useFocusNode } from '@/composables/canvas/useFocusNode'
 import { useExternalLink } from '@/composables/useExternalLink'
 import { useSettingStore } from '@/platform/settings/settingStore'
 import { useTelemetry } from '@/platform/telemetry'
+import { useToastStore } from '@/platform/updates/common/toastStore'
 import { NodeBadgeMode } from '@/types/nodeSource'

 import PropertiesAccordionItem from '../layout/PropertiesAccordionItem.vue'
@@ -119,10 +120,9 @@ const { t } = useI18n()
 const { copyToClipboard } = useCopyToClipboard()
 const { focusNode, enterSubgraph } = useFocusNode()
 const { staticUrls } = useExternalLink()
-const rightSidePanelStore = useRightSidePanelStore()
+const settingStore = useSettingStore()

 const searchQuery = ref('')
-const settingStore = useSettingStore()

 const showNodeIdBadge = computed(
  () =>
@@ -130,24 +130,16 @@ const showNodeIdBadge = computed(
    NodeBadgeMode.None
 )

-const { filteredGroups } = useErrorGroups(searchQuery, t)
+const { filteredGroups, collapseState, isSingleNodeSelected, errorNodeCache } =
+  useErrorGroups(searchQuery, t)

-const collapseState = reactive<Record<string, boolean>>({})
+function handleLocateNode(nodeId: string) {
+  focusNode(nodeId, errorNodeCache.value)
+}

-watch(
-  () => rightSidePanelStore.focusedErrorNodeId,
-  (graphNodeId) => {
-    if (!graphNodeId) return
-    for (const group of filteredGroups.value) {
-      const hasMatch = group.cards.some(
-        (card) => card.graphNodeId === graphNodeId
-      )
-      collapseState[group.title] = !hasMatch
-    }
-    rightSidePanelStore.focusedErrorNodeId = null
-  },
-  { immediate: true }
-)
+function handleEnterSubgraph(nodeId: string) {
+  enterSubgraph(nodeId, errorNodeCache.value)
+}

 function openGitHubIssues() {
  useTelemetry()?.trackUiButtonClicked({
@@ -162,6 +154,11 @@ async function contactSupport() {
    is_external: true,
    source: 'error_dialog'
  })
-  await useCommandStore().execute('Comfy.ContactSupport')
+  try {
+    await useCommandStore().execute('Comfy.ContactSupport')
+  } catch (error) {
+    console.error(error)
+    useToastStore().addAlert(t('rightSidePanel.contactSupportFailed'))
+  }
 }
 </script>
--- a/src/components/rightSidePanel/errors/useErrorGroups.ts
+++ b/src/components/rightSidePanel/errors/useErrorGroups.ts
@@ -1,15 +1,28 @@
-import { computed } from 'vue'
+import { computed, reactive, watch } from 'vue'
 import type { Ref } from 'vue'
 import Fuse from 'fuse.js'
 import type { IFuseOptions } from 'fuse.js'

 import { useExecutionStore } from '@/stores/executionStore'
+import { useCanvasStore } from '@/renderer/core/canvas/canvasStore'
+import { useRightSidePanelStore } from '@/stores/workspace/rightSidePanelStore'
 import { app } from '@/scripts/app'
+import { SubgraphNode } from '@/lib/litegraph/src/litegraph'
+import type { LGraphNode } from '@/lib/litegraph/src/litegraph'
 import { getNodeByExecutionId } from '@/utils/graphTraversalUtil'
 import { resolveNodeDisplayName } from '@/utils/nodeTitleUtil'
+import { isLGraphNode } from '@/utils/litegraphUtil'
+import { isGroupNode } from '@/utils/executableGroupNodeDto'
 import { st } from '@/i18n'
-import type { ErrorCardData, ErrorGroup } from './types'
-import { isNodeExecutionId } from '@/types/nodeIdentification'
+import type { ErrorCardData, ErrorGroup, ErrorItem } from './types'
+import {
+  isNodeExecutionId,
+  parseNodeExecutionId
+} from '@/types/nodeIdentification'
+
+const PROMPT_CARD_ID = '__prompt__'
+const SINGLE_GROUP_KEY = '__single__'
+const KNOWN_PROMPT_ERROR_TYPES = new Set(['prompt_no_outputs', 'no_prompt'])

 interface GroupEntry {
  priority: number
@@ -25,20 +38,30 @@ interface ErrorSearchItem {
  searchableDetails: string
 }

-const KNOWN_PROMPT_ERROR_TYPES = new Set(['prompt_no_outputs', 'no_prompt'])
-
-function resolveNodeInfo(nodeId: string): {
-  title: string
-  graphNodeId: string | undefined
-} {
+/**
+ * Resolve display info for a node by its execution ID.
+ * For group node internals, resolves the parent group node's title instead.
+ */
+function resolveNodeInfo(nodeId: string) {
  const graphNode = getNodeByExecutionId(app.rootGraph, nodeId)
+
+  const parts = parseNodeExecutionId(nodeId)
+  const parentId = parts && parts.length > 1 ? String(parts[0]) : null
+  const parentNode = parentId
+    ? app.rootGraph.getNodeById(Number(parentId))
+    : null
+  const isParentGroupNode = parentNode ? isGroupNode(parentNode) : false
+
  return {
-    title: resolveNodeDisplayName(graphNode, {
-      emptyLabel: '',
-      untitledLabel: '',
-      st
-    }),
-    graphNodeId: graphNode ? String(graphNode.id) : undefined
+    title: isParentGroupNode
+      ? parentNode?.title || ''
+      : resolveNodeDisplayName(graphNode, {
+          emptyLabel: '',
+          untitledLabel: '',
+          st
+        }),
+    graphNodeId: graphNode ? String(graphNode.id) : undefined,
+    isParentGroupNode
  }
 }

@@ -55,93 +78,56 @@ function getOrCreateGroup(
  return entry.cards
 }

-function processPromptError(
-  groupsMap: Map<string, GroupEntry>,
-  executionStore: ReturnType<typeof useExecutionStore>,
-  t: (key: string) => string
-) {
-  if (!executionStore.lastPromptError) return
-
-  const error = executionStore.lastPromptError
-  const groupTitle = error.message
-  const cards = getOrCreateGroup(groupsMap, groupTitle, 0)
-  const isKnown = KNOWN_PROMPT_ERROR_TYPES.has(error.type)
-
-  cards.set('__prompt__', {
-    id: '__prompt__',
-    title: groupTitle,
-    errors: [
-      {
-        message: isKnown
-          ? t(`rightSidePanel.promptErrors.${error.type}.desc`)
-          : error.message
-      }
-    ]
-  })
-}
-
-function processNodeErrors(
-  groupsMap: Map<string, GroupEntry>,
-  executionStore: ReturnType<typeof useExecutionStore>
-) {
-  if (!executionStore.lastNodeErrors) return
-
-  for (const [nodeId, nodeError] of Object.entries(
-    executionStore.lastNodeErrors
-  )) {
-    const cards = getOrCreateGroup(groupsMap, nodeError.class_type, 1)
-    if (!cards.has(nodeId)) {
-      const nodeInfo = resolveNodeInfo(nodeId)
-      cards.set(nodeId, {
-        id: `node-${nodeId}`,
-        title: nodeError.class_type,
-        nodeId,
-        nodeTitle: nodeInfo.title,
-        graphNodeId: nodeInfo.graphNodeId,
-        isSubgraphNode: isNodeExecutionId(nodeId),
-        errors: []
-      })
-    }
-    const card = cards.get(nodeId)
-    if (!card) continue
-    card.errors.push(
-      ...nodeError.errors.map((e) => ({
-        message: e.message,
-        details: e.details ?? undefined
-      }))
-    )
+function createErrorCard(
+  nodeId: string,
+  classType: string,
+  idPrefix: string
+): ErrorCardData {
+  const nodeInfo = resolveNodeInfo(nodeId)
+  return {
+    id: `${idPrefix}-${nodeId}`,
+    title: classType,
+    nodeId,
+    nodeTitle: nodeInfo.title,
+    graphNodeId: nodeInfo.graphNodeId,
+    isSubgraphNode: isNodeExecutionId(nodeId) && !nodeInfo.isParentGroupNode,
+    errors: []
  }
 }

-function processExecutionError(
-  groupsMap: Map<string, GroupEntry>,
-  executionStore: ReturnType<typeof useExecutionStore>
-) {
-  if (!executionStore.lastExecutionError) return
+/**
+ * In single-node mode, regroup cards by error message instead of class_type.
+ * This lets the user see "what kinds of errors this node has" at a glance.
+ */
+function regroupByErrorMessage(
+  groupsMap: Map<string, GroupEntry>
+): Map<string, GroupEntry> {
+  const allCards = Array.from(groupsMap.values()).flatMap((g) =>
+    Array.from(g.cards.values())
+  )

-  const e = executionStore.lastExecutionError
-  const nodeId = String(e.node_id)
-  const cards = getOrCreateGroup(groupsMap, e.node_type, 1)
+  const cardErrorPairs = allCards.flatMap((card) =>
+    card.errors.map((error) => ({ card, error }))
+  )

-  if (!cards.has(nodeId)) {
-    const nodeInfo = resolveNodeInfo(nodeId)
-    cards.set(nodeId, {
-      id: `exec-${nodeId}`,
-      title: e.node_type,
-      nodeId,
-      nodeTitle: nodeInfo.title,
-      graphNodeId: nodeInfo.graphNodeId,
-      isSubgraphNode: isNodeExecutionId(nodeId),
-      errors: []
-    })
+  const messageMap = new Map<string, GroupEntry>()
+  for (const { card, error } of cardErrorPairs) {
+    addCardErrorToGroup(messageMap, card, error)
  }
-  const card = cards.get(nodeId)
-  if (!card) return
-  card.errors.push({
-    message: `${e.exception_type}: ${e.exception_message}`,
-    details: e.traceback.join('\n'),
-    isRuntimeError: true
-  })
+
+  return messageMap
+}
+
+function addCardErrorToGroup(
+  messageMap: Map<string, GroupEntry>,
+  card: ErrorCardData,
+  error: ErrorItem
+) {
+  const group = getOrCreateGroup(messageMap, error.message, 1)
+  if (!group.has(card.id)) {
+    group.set(card.id, { ...card, errors: [] })
+  }
+  group.get(card.id)?.errors.push(error)
 }

 function toSortedGroups(groupsMap: Map<string, GroupEntry>): ErrorGroup[] {
@@ -157,27 +143,14 @@ function toSortedGroups(groupsMap: Map<string, GroupEntry>): ErrorGroup[] {
    })
 }

-function buildErrorGroups(
-  executionStore: ReturnType<typeof useExecutionStore>,
-  t: (key: string) => string
-): ErrorGroup[] {
-  const groupsMap = new Map<string, GroupEntry>()
-
-  processPromptError(groupsMap, executionStore, t)
-  processNodeErrors(groupsMap, executionStore)
-  processExecutionError(groupsMap, executionStore)
-
-  return toSortedGroups(groupsMap)
-}
-
-function searchErrorGroups(groups: ErrorGroup[], query: string): ErrorGroup[] {
+function searchErrorGroups(groups: ErrorGroup[], query: string) {
  if (!query) return groups

  const searchableList: ErrorSearchItem[] = []
  for (let gi = 0; gi < groups.length; gi++) {
-    const group = groups[gi]!
+    const group = groups[gi]
    for (let ci = 0; ci < group.cards.length; ci++) {
-      const card = group.cards[ci]!
+      const card = group.cards[ci]
      searchableList.push({
        groupIndex: gi,
        cardIndex: ci,
@@ -219,18 +192,181 @@ export function useErrorGroups(
  t: (key: string) => string
 ) {
  const executionStore = useExecutionStore()
+  const canvasStore = useCanvasStore()
+  const rightSidePanelStore = useRightSidePanelStore()
+  const collapseState = reactive<Record<string, boolean>>({})

-  const errorGroups = computed<ErrorGroup[]>(() =>
-    buildErrorGroups(executionStore, t)
+  const selectedNodeInfo = computed(() => {
+    const items = canvasStore.selectedItems
+    const nodeIds = new Set<string>()
+    const containerIds = new Set<string>()
+
+    for (const item of items) {
+      if (!isLGraphNode(item)) continue
+      nodeIds.add(String(item.id))
+      if (item instanceof SubgraphNode || isGroupNode(item)) {
+        containerIds.add(String(item.id))
+      }
+    }
+
+    return {
+      nodeIds: nodeIds.size > 0 ? nodeIds : null,
+      containerIds
+    }
+  })
+
+  const isSingleNodeSelected = computed(
+    () =>
+      selectedNodeInfo.value.nodeIds?.size === 1 &&
+      selectedNodeInfo.value.containerIds.size === 0
  )

+  const errorNodeCache = computed(() => {
+    const map = new Map<string, LGraphNode>()
+    const allExecutionIds = [
+      ...Object.keys(executionStore.lastNodeErrors ?? {}),
+      ...(executionStore.lastExecutionError
+        ? [String(executionStore.lastExecutionError.node_id)]
+        : [])
+    ]
+    for (const execId of allExecutionIds) {
+      const node = getNodeByExecutionId(app.rootGraph, execId)
+      if (node) map.set(execId, node)
+    }
+    return map
+  })
+
+  function isErrorInSelection(executionNodeId: string): boolean {
+    const nodeIds = selectedNodeInfo.value.nodeIds
+    if (!nodeIds) return true
+
+    const graphNode = errorNodeCache.value.get(executionNodeId)
+    if (graphNode && nodeIds.has(String(graphNode.id))) return true
+
+    for (const containerId of selectedNodeInfo.value.containerIds) {
+      if (executionNodeId.startsWith(`${containerId}:`)) return true
+    }
+
+    return false
+  }
+
+  function addNodeErrorToGroup(
+    groupsMap: Map<string, GroupEntry>,
+    nodeId: string,
+    classType: string,
+    idPrefix: string,
+    errors: ErrorItem[]
+  ) {
+    if (!isErrorInSelection(nodeId)) return
+    const groupKey = isSingleNodeSelected.value ? SINGLE_GROUP_KEY : classType
+    const cards = getOrCreateGroup(groupsMap, groupKey, 1)
+    if (!cards.has(nodeId)) {
+      cards.set(nodeId, createErrorCard(nodeId, classType, idPrefix))
+    }
+    cards.get(nodeId)?.errors.push(...errors)
+  }
+
+  function processPromptError(groupsMap: Map<string, GroupEntry>) {
+    if (selectedNodeInfo.value.nodeIds || !executionStore.lastPromptError)
+      return
+
+    const error = executionStore.lastPromptError
+    const groupTitle = error.message
+    const cards = getOrCreateGroup(groupsMap, groupTitle, 0)
+    const isKnown = KNOWN_PROMPT_ERROR_TYPES.has(error.type)
+
+    // Prompt errors are not tied to a node, so they bypass addNodeErrorToGroup.
+    cards.set(PROMPT_CARD_ID, {
+      id: PROMPT_CARD_ID,
+      title: groupTitle,
+      errors: [
+        {
+          message: isKnown
+            ? t(`rightSidePanel.promptErrors.${error.type}.desc`)
+            : error.message
+        }
+      ]
+    })
+  }
+
+  function processNodeErrors(groupsMap: Map<string, GroupEntry>) {
+    if (!executionStore.lastNodeErrors) return
+
+    for (const [nodeId, nodeError] of Object.entries(
+      executionStore.lastNodeErrors
+    )) {
+      addNodeErrorToGroup(
+        groupsMap,
+        nodeId,
+        nodeError.class_type,
+        'node',
+        nodeError.errors.map((e) => ({
+          message: e.message,
+          details: e.details ?? undefined
+        }))
+      )
+    }
+  }
+
+  function processExecutionError(groupsMap: Map<string, GroupEntry>) {
+    if (!executionStore.lastExecutionError) return
+
+    const e = executionStore.lastExecutionError
+    addNodeErrorToGroup(groupsMap, String(e.node_id), e.node_type, 'exec', [
+      {
+        message: `${e.exception_type}: ${e.exception_message}`,
+        details: e.traceback.join('\n'),
+        isRuntimeError: true
+      }
+    ])
+  }
+
+  const errorGroups = computed<ErrorGroup[]>(() => {
+    const groupsMap = new Map<string, GroupEntry>()
+
+    processPromptError(groupsMap)
+    processNodeErrors(groupsMap)
+    processExecutionError(groupsMap)
+
+    return isSingleNodeSelected.value
+      ? toSortedGroups(regroupByErrorMessage(groupsMap))
+      : toSortedGroups(groupsMap)
+  })
+
  const filteredGroups = computed<ErrorGroup[]>(() => {
    const query = searchQuery.value.trim()
    return searchErrorGroups(errorGroups.value, query)
  })

+  /**
+   * When an external trigger (e.g. "See Error" button in SectionWidgets)
+   * sets focusedErrorNodeId, expand only the group containing the target
+   * node and collapse all others so the user sees the relevant errors
+   * immediately.
+   */
+  function expandFocusedErrorGroup(graphNodeId: string | null) {
+    if (!graphNodeId) return
+    const prefix = `${graphNodeId}:`
+    for (const group of filteredGroups.value) {
+      const hasMatch = group.cards.some(
+        (card) =>
+          card.graphNodeId === graphNodeId ||
+          (card.nodeId?.startsWith(prefix) ?? false)
+      )
+      collapseState[group.title] = !hasMatch
+    }
+    rightSidePanelStore.focusedErrorNodeId = null
+  }
+
+  watch(() => rightSidePanelStore.focusedErrorNodeId, expandFocusedErrorGroup, {
+    immediate: true
+  })
+
  return {
    errorGroups,
-    filteredGroups
+    filteredGroups,
+    collapseState,
+    isSingleNodeSelected,
+    errorNodeCache
  }
 }
--- a/src/components/rightSidePanel/parameters/SectionWidgets.vue
+++ b/src/components/rightSidePanel/parameters/SectionWidgets.vue
@@ -5,17 +5,15 @@ import { useI18n } from 'vue-i18n'
 import Button from '@/components/ui/button/Button.vue'
 import { isProxyWidget } from '@/core/graph/subgraph/proxyWidget'
 import { parseProxyWidgets } from '@/core/schemas/proxyWidget'
-import type {
-  LGraphGroup,
-  LGraphNode,
-  SubgraphNode
-} from '@/lib/litegraph/src/litegraph'
+import type { LGraphGroup, LGraphNode } from '@/lib/litegraph/src/litegraph'
+import { SubgraphNode } from '@/lib/litegraph/src/litegraph'
 import type { IBaseWidget } from '@/lib/litegraph/src/types/widgets'
 import { useCanvasStore } from '@/renderer/core/canvas/canvasStore'
 import { useExecutionStore } from '@/stores/executionStore'
 import { useRightSidePanelStore } from '@/stores/workspace/rightSidePanelStore'
 import { useSettingStore } from '@/platform/settings/settingStore'
 import { cn } from '@/utils/tailwindUtil'
+import { isGroupNode } from '@/utils/executableGroupNodeDto'
 import { useNodeDefStore } from '@/stores/nodeDefStore'
 import { getWidgetDefaultValue } from '@/utils/widgetUtil'
 import type { WidgetValue } from '@/utils/widgetUtil'
@@ -110,11 +108,35 @@ const targetNode = computed<LGraphNode | null>(() => {
  return allSameNode ? widgets.value[0].node : null
 })

-const nodeHasError = computed(() => {
-  if (canvasStore.selectedItems.length > 0 || !targetNode.value) return false
+const hasDirectError = computed(() => {
+  if (!targetNode.value) return false
  return executionStore.activeGraphErrorNodeIds.has(String(targetNode.value.id))
 })

+const hasContainerInternalError = computed(() => {
+  if (!targetNode.value) return false
+  const isContainer =
+    targetNode.value instanceof SubgraphNode || isGroupNode(targetNode.value)
+  if (!isContainer) return false
+
+  const errorIds: string[] = []
+  if (executionStore.lastNodeErrors) {
+    errorIds.push(...Object.keys(executionStore.lastNodeErrors))
+  }
+  if (executionStore.lastExecutionError) {
+    errorIds.push(String(executionStore.lastExecutionError.node_id))
+  }
+
+  const prefix = `${targetNode.value.id}:`
+  return errorIds.some((execId) => execId.startsWith(prefix))
+})
+
+const nodeHasError = computed(() => {
+  if (!targetNode.value) return false
+  if (canvasStore.selectedItems.length === 1) return false
+  return hasDirectError.value || hasContainerInternalError.value
+})
+
 const parentGroup = computed<LGraphGroup | null>(() => {
  if (!targetNode.value || !getNodeParentGroup) return null
  return getNodeParentGroup(targetNode.value)
--- a/src/composables/canvas/useFocusNode.ts
+++ b/src/composables/canvas/useFocusNode.ts
@@ -2,9 +2,15 @@ import { nextTick } from 'vue'

 import { useCanvasStore } from '@/renderer/core/canvas/canvasStore'
 import { app } from '@/scripts/app'
-import type { LGraph, Subgraph } from '@/lib/litegraph/src/litegraph'
+import type {
+  LGraph,
+  LGraphNode,
+  Subgraph
+} from '@/lib/litegraph/src/litegraph'
 import { getNodeByExecutionId } from '@/utils/graphTraversalUtil'
+import { isGroupNode } from '@/utils/executableGroupNodeDto'
 import { useLitegraphService } from '@/services/litegraphService'
+import { parseNodeExecutionId } from '@/types/nodeIdentification'

 async function navigateToGraph(targetGraph: LGraph) {
  const canvasStore = useCanvasStore()
@@ -29,20 +35,44 @@ async function navigateToGraph(targetGraph: LGraph) {
 export function useFocusNode() {
  const canvasStore = useCanvasStore()

-  async function focusNode(nodeId: string) {
+  /* Locate and focus a node on the canvas by its execution ID. */
+  async function focusNode(
+    nodeId: string,
+    executionIdMap?: Map<string, LGraphNode>
+  ) {
    if (!canvasStore.canvas) return

-    const graphNode = getNodeByExecutionId(app.rootGraph, nodeId)
+    // For group node internals, locate the parent group node instead
+    const parts = parseNodeExecutionId(nodeId)
+    const parentId = parts && parts.length > 1 ? String(parts[0]) : null
+    const parentNode = parentId
+      ? app.rootGraph.getNodeById(Number(parentId))
+      : null
+
+    if (parentNode && isGroupNode(parentNode) && parentNode.graph) {
+      await navigateToGraph(parentNode.graph as LGraph)
+      canvasStore.canvas?.animateToBounds(parentNode.boundingRect)
+      return
+    }
+
+    const graphNode = executionIdMap
+      ? executionIdMap.get(nodeId)
+      : getNodeByExecutionId(app.rootGraph, nodeId)
    if (!graphNode?.graph) return

    await navigateToGraph(graphNode.graph as LGraph)
    canvasStore.canvas?.animateToBounds(graphNode.boundingRect)
  }

-  async function enterSubgraph(nodeId: string) {
+  async function enterSubgraph(
+    nodeId: string,
+    executionIdMap?: Map<string, LGraphNode>
+  ) {
    if (!canvasStore.canvas) return

-    const graphNode = getNodeByExecutionId(app.rootGraph, nodeId)
+    const graphNode = executionIdMap
+      ? executionIdMap.get(nodeId)
+      : getNodeByExecutionId(app.rootGraph, nodeId)
    if (!graphNode?.graph) return

    await navigateToGraph(graphNode.graph as LGraph)
--- a/src/locales/en/main.json
+++ b/src/locales/en/main.json
@@ -1357,6 +1357,7 @@
    "Execution": "Execution",
    "PLY": "PLY",
    "Workspace": "Workspace",
+    "Error System": "Error System",
    "Other": "Other",
    "Secrets": "Secrets"
  },
@@ -2979,6 +2980,7 @@
    "hideAdvancedInputsButton": "Hide advanced inputs",
    "errors": "Errors",
    "noErrors": "No errors",
+    "executionErrorOccurred": "An error occurred during execution. Check the Errors tab for details.",
    "enterSubgraph": "Enter subgraph",
    "seeError": "See Error",
    "promptErrors": {
@@ -2992,9 +2994,14 @@
    "errorHelp": "For more help, {github} or {support}",
    "errorHelpGithub": "submit a GitHub issue",
    "errorHelpSupport": "contact our support",
+    "contactSupportFailed": "Unable to open contact support. Please try again later.",
    "resetToDefault": "Reset to default",
    "resetAllParameters": "Reset all parameters"
  },
+  "errorOverlay": {
+    "errorCount": "{count} ERRORS | {count} ERROR | {count} ERRORS",
+    "seeErrors": "See Errors"
+  },
  "help": {
    "recentReleases": "Recent releases",
    "helpCenterMenu": "Help Center Menu"
--- a/src/renderer/extensions/vueNodes/components/LGraphNode.vue
+++ b/src/renderer/extensions/vueNodes/components/LGraphNode.vue
@@ -134,11 +134,8 @@
      as-child
    >
      <button
-        v-if="hasAnyError"
-        @click.stop="
-          settingStore.get('Comfy.RightSidePanel.ShowErrorsTab') &&
-          useRightSidePanelStore().openPanel('error')
-        "
+        v-if="hasAnyError && showErrorsTabEnabled"
+        @click.stop="useRightSidePanelStore().openPanel('errors')"
      >
        <span>{{ t('g.error') }}</span>
        <i class="icon-[lucide--info] size-4" />
@@ -310,6 +307,10 @@ const hasAnyError = computed((): boolean => {
  )
 })

+const showErrorsTabEnabled = computed(() =>
+  settingStore.get('Comfy.RightSidePanel.ShowErrorsTab')
+)
+
 const displayHeader = computed(() => nodeData.titleMode !== TitleMode.NO_TITLE)

 const isCollapsed = computed(() => nodeData.flags?.collapsed ?? false)
--- a/src/scripts/app.ts
+++ b/src/scripts/app.ts
@@ -712,13 +712,11 @@ export class ComfyApp {
            isInsufficientCredits: true
          })
        }
+      } else if (useSettingStore().get('Comfy.RightSidePanel.ShowErrorsTab')) {
+        useExecutionStore().showErrorOverlay()
      } else {
        useDialogService().showExecutionErrorDialog(detail)
      }
-      if (useSettingStore().get('Comfy.RightSidePanel.ShowErrorsTab')) {
-        this.canvas.deselectAll()
-        useRightSidePanelStore().openPanel('errors')
-      }
      this.canvas.draw(true, true)
    })

@@ -1465,7 +1463,10 @@ export class ComfyApp {
                {}) as MissingNodeTypeExtraInfo
              const missingNodeType = createMissingNodeTypeFromError(extraInfo)
              this.showMissingNodesError([missingNodeType])
-            } else {
+            } else if (
+              !useSettingStore().get('Comfy.RightSidePanel.ShowErrorsTab') ||
+              !(error instanceof PromptExecutionError)
+            ) {
              useDialogService().showErrorDialog(error, {
                title: t('errorDialog.promptExecutionError'),
                reportType: 'promptExecutionError'
@@ -1500,11 +1501,8 @@ export class ComfyApp {
                }
              }

-              // Clear selection and open the error panel so the user can immediately
-              // see the error details without extra clicks.
              if (useSettingStore().get('Comfy.RightSidePanel.ShowErrorsTab')) {
-                this.canvas.deselectAll()
-                useRightSidePanelStore().openPanel('errors')
+                executionStore.showErrorOverlay()
              }
              this.canvas.draw(true, true)
            }
--- a/src/stores/executionStore.ts
+++ b/src/stores/executionStore.ts
@@ -49,6 +49,33 @@ interface QueuedPrompt {
  workflow?: ComfyWorkflow
 }

+interface CloudValidationError {
+  error?: { type?: string; message?: string; details?: string } | string
+  node_errors?: Record<NodeId, NodeError>
+}
+
+function isCloudValidationError(value: unknown): value is CloudValidationError {
+  return (
+    value !== null &&
+    typeof value === 'object' &&
+    ('error' in value || 'node_errors' in value)
+  )
+}
+
+function tryExtractValidationError(
+  exceptionMessage: string
+): CloudValidationError | null {
+  const jsonStart = exceptionMessage.indexOf('{')
+  if (jsonStart === -1) return null
+
+  try {
+    const parsed: unknown = JSON.parse(exceptionMessage.substring(jsonStart))
+    return isCloudValidationError(parsed) ? parsed : null
+  } catch {
+    return null
+  }
+}
+
 const subgraphNodeIdToSubgraph = (id: string, graph: LGraph | Subgraph) => {
  const node = graph.getNodeById(id)
  if (node?.isSubgraphNode()) return node.subgraph
@@ -291,6 +318,7 @@ export const useExecutionStore = defineStore('execution', () => {
  function handleExecutionStart(e: CustomEvent<ExecutionStartWsMessage>) {
    lastExecutionError.value = null
    lastPromptError.value = null
+    isErrorOverlayOpen.value = false
    activePromptId.value = e.detail.prompt_id
    queuedPrompts.value[activePromptId.value] ??= { nodes: {} }
    clearInitializationByPromptId(activePromptId.value)
@@ -392,7 +420,6 @@ export const useExecutionStore = defineStore('execution', () => {
  }

  function handleExecutionError(e: CustomEvent<ExecutionErrorWsMessage>) {
-    lastExecutionError.value = e.detail
    if (isCloud) {
      useTelemetry()?.trackExecutionError({
        jobId: e.detail.prompt_id,
@@ -400,11 +427,62 @@ export const useExecutionStore = defineStore('execution', () => {
        nodeType: e.detail.node_type,
        error: e.detail.exception_message
      })
+
+      // Cloud wraps validation errors (400) in exception_message as embedded JSON.
+      if (handleCloudValidationError(e.detail)) return
    }
+
+    // Service-level errors (e.g. "Job has stagnated") have no associated node.
+    // Route them as prompt errors
+    if (handleServiceLevelError(e.detail)) return
+
+    // OSS path / Cloud fallback (real runtime errors)
+    lastExecutionError.value = e.detail
    clearInitializationByPromptId(e.detail.prompt_id)
    resetExecutionState(e.detail.prompt_id)
  }

+  function handleServiceLevelError(detail: ExecutionErrorWsMessage): boolean {
+    if (!isEmpty(detail.node_id)) return false
+
+    clearInitializationByPromptId(detail.prompt_id)
+    resetExecutionState(detail.prompt_id)
+    lastPromptError.value = {
+      type: detail.exception_type ?? 'error',
+      message: `${detail.exception_type}: ${detail.exception_message}`,
+      details: detail.traceback?.join('\n') ?? ''
+    }
+    return true
+  }
+
+  function handleCloudValidationError(
+    detail: ExecutionErrorWsMessage
+  ): boolean {
+    const extracted = tryExtractValidationError(detail.exception_message)
+    if (!extracted) return false
+
+    const { error, node_errors } = extracted
+    const hasNodeErrors = node_errors && Object.keys(node_errors).length > 0
+
+    if (hasNodeErrors) {
+      lastNodeErrors.value = node_errors
+    } else if (error && typeof error === 'object') {
+      lastPromptError.value = {
+        type: error.type ?? 'error',
+        message: error.message ?? '',
+        details: error.details ?? ''
+      }
+    } else if (typeof error === 'string') {
+      lastPromptError.value = { type: 'error', message: error, details: '' }
+    } else {
+      return false
+    }
+
+    clearInitializationByPromptId(detail.prompt_id)
+    resetExecutionState(detail.prompt_id)
+    return true
+  }
+
  /**
   * Notification handler used for frontend/cloud initialization tracking.
   * Marks a prompt as initializing when cloud notifies it is waiting for a machine.
@@ -662,12 +740,30 @@ export const useExecutionStore = defineStore('execution', () => {
    () => hasExecutionError.value || hasPromptError.value || hasNodeError.value
  )

-  /** Pre-computed Set of graph node IDs (as strings) that have errors. */
+  /** Total count of all individual errors */
+  const totalErrorCount = computed(() => {
+    let count = 0
+    if (lastPromptError.value) {
+      count += 1
+    }
+    if (lastNodeErrors.value) {
+      for (const nodeError of Object.values(lastNodeErrors.value)) {
+        count += nodeError.errors.length
+      }
+    }
+    if (lastExecutionError.value) {
+      count += 1
+    }
+    return count
+  })
+
+  /** Pre-computed Set of graph node IDs (as strings) that have errors in the current graph scope. */
  const activeGraphErrorNodeIds = computed<Set<string>>(() => {
    const ids = new Set<string>()
    if (!app.rootGraph) return ids

-    const activeGraph = useCanvasStore().currentGraph ?? app.rootGraph
+    // Fall back to rootGraph when currentGraph hasn't been initialized yet
+    const activeGraph = canvasStore.currentGraph ?? app.rootGraph

    if (lastNodeErrors.value) {
      for (const executionId of Object.keys(lastNodeErrors.value)) {
@@ -689,6 +785,16 @@ export const useExecutionStore = defineStore('execution', () => {
    return ids
  })

+  const isErrorOverlayOpen = ref(false)
+
+  function showErrorOverlay() {
+    isErrorOverlayOpen.value = true
+  }
+
+  function dismissErrorOverlay() {
+    isErrorOverlayOpen.value = false
+  }
+
  return {
    isIdle,
    clientId,
@@ -698,6 +804,7 @@ export const useExecutionStore = defineStore('execution', () => {
    lastExecutionError,
    lastPromptError,
    hasAnyError,
+    totalErrorCount,
    lastExecutionErrorNodeId,
    executingNodeId,
    executingNodeIds,
@@ -730,6 +837,9 @@ export const useExecutionStore = defineStore('execution', () => {
    // Node error lookup helpers
    getNodeErrors,
    slotHasError,
-    activeGraphErrorNodeIds
+    activeGraphErrorNodeIds,
+    isErrorOverlayOpen,
+    showErrorOverlay,
+    dismissErrorOverlay
  }
 })
--- a/src/stores/workspace/rightSidePanelStore.ts
+++ b/src/stores/workspace/rightSidePanelStore.ts
@@ -4,7 +4,6 @@ import { computed, ref, watch } from 'vue'
 import { useSettingStore } from '@/platform/settings/settingStore'

 export type RightSidePanelTab =
-  | 'error'
  | 'parameters'
  | 'nodes'
  | 'settings'