fix(agent): scope nested tool canonical-mode overrides by instance, not type

Two tool entries of the same type inside an Agent block's tool-input array
(e.g. two Table tools) shared a single canonical-mode override keyed by
${toolType}:${canonicalId}, so switching basic/advanced mode on one field
silently switched it on every other instance of the same tool type -
including at execution time, where the wrong basic/advanced value could be
resolved for the second tool.

Rescope the override key to the tool's position in its tool-input array
(${toolIndex}:${canonicalId}) instead of its type, and thread that index
through every consumer: the editor (read + write), execution
(agent-handler/providers), search-index, and fork/promote remapping.

Author: waleedlatif1

apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/editor/components/sub-block/components/tool-input/tool-input.test.ts

@@ -1,12 +1,13 @@
 /**
  * @vitest-environment node
  */
-import { describe, expect, it } from 'vitest'
+import { describe, expect, it, vi } from 'vitest'
 import type { StoredTool } from '@/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/editor/components/sub-block/components/tool-input/types'
 import {
   isCustomToolAlreadySelected,
   isMcpToolAlreadySelected,
   isWorkflowAlreadySelected,
+  reindexToolCanonicalModes,
 } from '@/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/editor/components/sub-block/components/tool-input/utils'
 
 describe('isMcpToolAlreadySelected', () => {
@@ -416,3 +417,76 @@ describe('duplicate prevention integration scenarios', () => {
     })
   })
 })
+
+describe('reindexToolCanonicalModes', () => {
+  const table = (title: string): StoredTool => ({ type: 'table', title, params: {} })
+
+  it.concurrent('does nothing when there are no overrides', () => {
+    const applyMode = vi.fn()
+    reindexToolCanonicalModes([table('a')], [table('a')], undefined, applyMode)
+    expect(applyMode).not.toHaveBeenCalled()
+  })
+
+  it.concurrent('does nothing when a tool keeps its index', () => {
+    const a = table('a')
+    const b = table('b')
+    const applyMode = vi.fn()
+    reindexToolCanonicalModes([a, b], [a, b], { '0:tableId': 'advanced' }, applyMode)
+    expect(applyMode).not.toHaveBeenCalled()
+  })
+
+  it.concurrent('re-keys a surviving tool overrides to its new index after a removal', () => {
+    const a = table('a')
+    const b = table('b')
+    const c = table('c')
+    const applyMode = vi.fn()
+    // Remove `a` (index 0): b shifts 1->0, c shifts 2->1.
+    reindexToolCanonicalModes(
+      [a, b, c],
+      [b, c],
+      { '1:tableId': 'advanced', '2:tableId': 'basic' },
+      applyMode
+    )
+    expect(applyMode).toHaveBeenCalledWith('0:tableId', 'advanced')
+    expect(applyMode).toHaveBeenCalledWith('1:tableId', 'basic')
+    expect(applyMode).toHaveBeenCalledTimes(2)
+  })
+
+  it.concurrent('re-keys overrides after a drag reorder', () => {
+    const a = table('a')
+    const b = table('b')
+    const applyMode = vi.fn()
+    // Swap a and b: a moves 0->1, b moves 1->0.
+    reindexToolCanonicalModes(
+      [a, b],
+      [b, a],
+      { '0:tableId': 'advanced', '1:tableId': 'basic' },
+      applyMode
+    )
+    expect(applyMode).toHaveBeenCalledWith('1:tableId', 'advanced')
+    expect(applyMode).toHaveBeenCalledWith('0:tableId', 'basic')
+    expect(applyMode).toHaveBeenCalledTimes(2)
+  })
+
+  it.concurrent('leaves a removed tool old key untouched (no applyMode call for it)', () => {
+    const a = table('a')
+    const b = table('b')
+    const applyMode = vi.fn()
+    // Remove `b` (index 1): nothing survives at index 1, so no call is made for its key.
+    reindexToolCanonicalModes([a, b], [a], { '1:tableId': 'advanced' }, applyMode)
+    expect(applyMode).not.toHaveBeenCalled()
+  })
+
+  it.concurrent('ignores falsy override values', () => {
+    const a = table('a')
+    const b = table('b')
+    const applyMode = vi.fn()
+    reindexToolCanonicalModes(
+      [a, b],
+      [b, a],
+      { '0:tableId': undefined as unknown as 'advanced' },
+      applyMode
+    )
+    expect(applyMode).not.toHaveBeenCalled()
+  })
+})

apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/editor/components/sub-block/components/tool-input/tool-input.tsx

@@ -49,6 +49,7 @@ import {
   isCustomToolAlreadySelected,
   isMcpToolAlreadySelected,
   isWorkflowAlreadySelected,
+  reindexToolCanonicalModes,
 } from '@/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/editor/components/sub-block/components/tool-input/utils'
 import {
   getActiveWorkflowSearchHighlight,
@@ -489,6 +490,11 @@ export const ToolInput = memo(function ToolInput({
     )
   )
   const { collaborativeSetBlockCanonicalMode } = useCollaborativeWorkflow()
+  const applyCanonicalModeReindex = useCallback(
+    (key: string, mode: 'basic' | 'advanced') =>
+      collaborativeSetBlockCanonicalMode(blockId, key, mode),
+    [collaborativeSetBlockCanonicalMode, blockId]
+  )
 
   const value = isPreview ? previewValue : storeValue
 
@@ -514,11 +520,15 @@ export const ToolInput = memo(function ToolInput({
   // Uses canonical resolution so the active field (basic vs advanced) is respected.
   const toolCredentialId = useMemo(() => {
     const allBlocks = getAllBlocks()
-    for (const tool of selectedTools) {
+    for (const [toolIndex, tool] of selectedTools.entries()) {
       const blockConfig = allBlocks.find((b: { type: string }) => b.type === tool.type)
       if (!blockConfig?.subBlocks) continue
       const toolCanonical = buildCanonicalIndex(blockConfig.subBlocks)
-      const scopedOverrides = scopeCanonicalModesForTool(canonicalModeOverrides, tool.type)
+      const scopedOverrides = scopeCanonicalModesForTool(
+        canonicalModeOverrides,
+        toolIndex,
+        tool.type
+      )
       const reactiveSubBlock = blockConfig.subBlocks.find(
         (sb: { reactiveCondition?: unknown }) => sb.reactiveCondition
       )
@@ -909,19 +919,47 @@ export const ToolInput = memo(function ToolInput({
   const handleRemoveTool = useCallback(
     (toolIndex: number) => {
       if (isPreview || disabled) return
-      setStoreValue(selectedTools.filter((_, index) => index !== toolIndex))
+      const updatedTools = selectedTools.filter((_, index) => index !== toolIndex)
+      reindexToolCanonicalModes(
+        selectedTools,
+        updatedTools,
+        canonicalModeOverrides,
+        applyCanonicalModeReindex
+      )
+      setStoreValue(updatedTools)
     },
-    [isPreview, disabled, selectedTools, setStoreValue]
+    [
+      isPreview,
+      disabled,
+      selectedTools,
+      canonicalModeOverrides,
+      applyCanonicalModeReindex,
+      setStoreValue,
+    ]
   )
 
   const handleRemoveAllFromServer = useCallback(
     (serverId: string | undefined) => {
       if (isPreview || disabled || !serverId) return
-      setStoreValue(
-        selectedTools.filter((t) => !(t.type === 'mcp' && t.params?.serverId === serverId))
+      const updatedTools = selectedTools.filter(
+        (t) => !(t.type === 'mcp' && t.params?.serverId === serverId)
+      )
+      reindexToolCanonicalModes(
+        selectedTools,
+        updatedTools,
+        canonicalModeOverrides,
+        applyCanonicalModeReindex
       )
+      setStoreValue(updatedTools)
     },
-    [isPreview, disabled, selectedTools, setStoreValue]
+    [
+      isPreview,
+      disabled,
+      selectedTools,
+      canonicalModeOverrides,
+      applyCanonicalModeReindex,
+      setStoreValue,
+    ]
   )
 
   const handleDeleteTool = useCallback(
@@ -949,10 +987,16 @@ export const ToolInput = memo(function ToolInput({
       })
 
       if (updatedTools.length !== selectedTools.length) {
+        reindexToolCanonicalModes(
+          selectedTools,
+          updatedTools,
+          canonicalModeOverrides,
+          applyCanonicalModeReindex
+        )
         setStoreValue(updatedTools)
       }
     },
-    [selectedTools, customTools, setStoreValue]
+    [selectedTools, customTools, canonicalModeOverrides, applyCanonicalModeReindex, setStoreValue]
   )
 
   const handleParamChange = useCallback(
@@ -1121,6 +1165,12 @@ export const ToolInput = memo(function ToolInput({
       newTools.splice(adjustedDropIndex, 0, draggedTool)
     }
 
+    reindexToolCanonicalModes(
+      selectedTools,
+      newTools,
+      canonicalModeOverrides,
+      applyCanonicalModeReindex
+    )
     setStoreValue(newTools)
     setDraggedIndex(null)
     setDragOverIndex(null)
@@ -1420,6 +1470,15 @@ export const ToolInput = memo(function ToolInput({
                 description: mcpTool.description,
               },
             }))
+            // Diff against `filteredTools` (pre-spread, same refs as `selectedTools`) - the
+            // spread copy below preserves the same relative order, so this correctly reflects
+            // each surviving tool's new position.
+            reindexToolCanonicalModes(
+              selectedTools,
+              filteredTools,
+              canonicalModeOverrides,
+              applyCanonicalModeReindex
+            )
             setStoreValue([...filteredTools.map((t) => ({ ...t, isExpanded: false })), ...newTools])
             setMcpServerDrilldown(null)
             setOpen(false)
@@ -1650,6 +1709,8 @@ export const ToolInput = memo(function ToolInput({
     customUnsupported,
     availableWorkflows,
     isToolAlreadySelected,
+    canonicalModeOverrides,
+    applyCanonicalModeReindex,
   ])
 
   return (
@@ -1692,7 +1753,11 @@ export const ToolInput = memo(function ToolInput({
                 })
               : null
 
-          const toolScopedOverrides = scopeCanonicalModesForTool(canonicalModeOverrides, tool.type)
+          const toolScopedOverrides = scopeCanonicalModesForTool(
+            canonicalModeOverrides,
+            toolIndex,
+            tool.type
+          )
 
           const subBlocksResult: SubBlocksForToolInput | null =
             !isCustomTool && !isMcpTool && currentToolId
@@ -2086,7 +2151,7 @@ export const ToolInput = memo(function ToolInput({
                                 const nextMode = canonicalMode === 'advanced' ? 'basic' : 'advanced'
                                 collaborativeSetBlockCanonicalMode(
                                   blockId,
-                                  `${tool.type}:${canonicalId}`,
+                                  `${toolIndex}:${canonicalId}`,
                                   nextMode
                                 )
                               },

apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/editor/components/sub-block/components/tool-input/utils.ts

@@ -1,3 +1,4 @@
+import type { CanonicalModeOverrides } from '@/lib/workflows/subblocks/visibility'
 import type { StoredTool } from '@/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/editor/components/sub-block/components/tool-input/types'
 
 /**
@@ -30,3 +31,32 @@ export function isWorkflowAlreadySelected(
     (tool) => tool.type === 'workflow_input' && tool.params?.workflowId === workflowId
   )
 }
+
+/**
+ * Canonical-mode overrides are keyed by a tool's position in the `tool-input` array
+ * (`${toolIndex}:${canonicalId}`), so removing or reordering tools must carry each surviving
+ * tool's overrides to its new position - otherwise a saved basic/advanced choice attaches to
+ * whichever tool now sits at that old index. Diffs `oldTools` against `newTools` by object
+ * identity (safe here: every mutation site filters/splices the existing array without cloning
+ * the tool objects it keeps) and re-emits each surviving key under its new index via `applyMode`.
+ * A removed tool's old key is left in place, unused - harmless, since nothing queries a
+ * `toolIndex` no tool occupies anymore.
+ */
+export function reindexToolCanonicalModes(
+  oldTools: StoredTool[],
+  newTools: StoredTool[],
+  overrides: CanonicalModeOverrides | undefined,
+  applyMode: (key: string, mode: 'basic' | 'advanced') => void
+): void {
+  if (!overrides) return
+  const newIndexByRef = new Map(newTools.map((tool, index) => [tool, index]))
+  oldTools.forEach((tool, oldIndex) => {
+    const newIndex = newIndexByRef.get(tool)
+    if (newIndex === undefined || newIndex === oldIndex) return
+    const prefix = `${oldIndex}:`
+    for (const [key, mode] of Object.entries(overrides)) {
+      if (!key.startsWith(prefix) || !mode) continue
+      applyMode(`${newIndex}:${key.slice(prefix.length)}`, mode)
+    }
+  })
+}