fix(agent): resolve canonical resource id when building unique tool ids

Multi-instance agent tools (table, knowledge base, workflow) get a unique
id by suffixing the resource id (e.g. table_query_rows_<tableId>). The
suffix code read the canonical param key (tableId/knowledgeBaseId) directly
from stored params, but selector subblocks persist their value under the
subblock id (tableSelector/knowledgeBaseSelector). Tools stored in that
state never got a suffix, so two of them collapsed to the same name.

Resolve the canonical resource id from the source subblock first — mirroring
the execution-time paramsTransform — so the unique id is derived the same
way the tool actually runs. Non-destructive; no-op when the canonical key is
already present.

Author: waleedlatif1

apps/sim/providers/utils.test.ts

@@ -38,6 +38,7 @@ import {
   supportsThinking,
   supportsToolUsageControl,
   supportsVerbosity,
+  transformBlockTool,
   updateOllamaProviderModels,
 } from '@/providers/utils'
 
@@ -1514,3 +1515,64 @@ describe('Provider/Model Blacklist', () => {
     })
   })
 })
+
+describe('transformBlockTool multi-instance unique IDs', () => {
+  const tableBlockDef = {
+    type: 'table',
+    inputs: {},
+    subBlocks: [
+      { id: 'operation', type: 'dropdown' },
+      { id: 'tableSelector', type: 'table-selector', canonicalParamId: 'tableId', mode: 'basic' },
+      {
+        id: 'manualTableId',
+        type: 'short-input',
+        canonicalParamId: 'tableId',
+        mode: 'advanced',
+      },
+    ],
+    tools: {
+      access: ['table_query_rows', 'table_insert_row'],
+      config: { tool: () => 'table_query_rows' },
+    },
+  }
+
+  const getAllBlocks = () => [tableBlockDef]
+  const getTool = (id: string) => ({
+    id,
+    name: 'Query Rows',
+    description: 'Query table rows',
+    params: {},
+  })
+
+  const transformTable = (
+    params: Record<string, unknown>,
+    canonicalModes?: Record<string, 'basic' | 'advanced'>
+  ) =>
+    transformBlockTool(
+      { type: 'table', operation: 'query_rows', params },
+      { selectedOperation: 'query_rows', getAllBlocks, getTool, canonicalModes }
+    )
+
+  it('appends the table id when stored under the basic selector subblock key', async () => {
+    const result = await transformTable({ tableSelector: 'tbl_abc' })
+    expect(result?.id).toBe('table_query_rows_tbl_abc')
+  })
+
+  it('appends the table id resolved from the advanced manual input', async () => {
+    const result = await transformTable(
+      { manualTableId: 'tbl_xyz' },
+      { 'table:tableId': 'advanced' }
+    )
+    expect(result?.id).toBe('table_query_rows_tbl_xyz')
+  })
+
+  it('appends the canonical table id when already present in params', async () => {
+    const result = await transformTable({ tableId: 'tbl_direct' })
+    expect(result?.id).toBe('table_query_rows_tbl_direct')
+  })
+
+  it('falls back to the base tool id when no table is selected', async () => {
+    const result = await transformTable({})
+    expect(result?.id).toBe('table_query_rows')
+  })
+})

apps/sim/providers/utils.ts

@@ -473,6 +473,39 @@ export function extractAndParseJSON(content: string): any {
   }
 }
 
+/**
+ * Resolves canonical pair ids (e.g. `tableId`, `knowledgeBaseId`) from a tool's
+ * raw params, filling them in from their basic/advanced selector subblock source
+ * values when the canonical key isn't already present.
+ *
+ * Selector subblocks persist their value under the subblock id (e.g.
+ * `tableSelector`), not the canonical id, so any lookup that keys off the
+ * canonical id — like the unique-tool-id suffix below — must resolve it first.
+ * Mode selection mirrors {@link transformBlockTool}'s execution-time
+ * `paramsTransform` so the resolved id matches the params the tool actually runs
+ * with.
+ *
+ * @returns The params with canonical resource ids resolved (non-destructive)
+ */
+function resolveCanonicalResourceParams(
+  params: Record<string, any>,
+  canonicalGroups: CanonicalGroup[],
+  blockType: string,
+  canonicalModes?: Record<string, 'basic' | 'advanced'>
+): Record<string, any> {
+  if (canonicalGroups.length === 0) return params
+  const resolved = { ...params }
+  for (const group of canonicalGroups) {
+    const existing = resolved[group.canonicalId]
+    if (existing !== undefined && existing !== null && existing !== '') continue
+    const { basicValue, advancedValue } = getCanonicalValues(group, params)
+    const pairMode = canonicalModes?.[`${blockType}:${group.canonicalId}`] ?? 'basic'
+    const chosen = pairMode === 'advanced' ? advancedValue : basicValue
+    if (chosen !== undefined) resolved[group.canonicalId] = chosen
+  }
+  return resolved
+}
+
 /**
  * Transforms a block tool into a provider tool config with operation selection
  *
@@ -549,14 +582,25 @@ export async function transformBlockTool(
     userProvidedParams
   )
 
+  const canonicalGroups: CanonicalGroup[] = blockDef?.subBlocks
+    ? Object.values(buildCanonicalIndex(blockDef.subBlocks).groupsById).filter(isCanonicalPair)
+    : []
+
+  const resolvedResourceParams = resolveCanonicalResourceParams(
+    userProvidedParams,
+    canonicalGroups,
+    block.type,
+    canonicalModes
+  )
+
   let uniqueToolId = toolConfig.id
   let toolName = toolConfig.name
   let toolDescription = enrichedDescription || toolConfig.description
 
-  if (toolId === 'workflow_executor' && userProvidedParams.workflowId) {
-    uniqueToolId = `${toolConfig.id}_${userProvidedParams.workflowId}`
+  if (toolId === 'workflow_executor' && resolvedResourceParams.workflowId) {
+    uniqueToolId = `${toolConfig.id}_${resolvedResourceParams.workflowId}`
 
-    const workflowMetadata = await fetchWorkflowMetadata(userProvidedParams.workflowId)
+    const workflowMetadata = await fetchWorkflowMetadata(resolvedResourceParams.workflowId)
     if (workflowMetadata) {
       toolName = workflowMetadata.name || toolConfig.name
       if (
@@ -566,21 +610,17 @@ export async function transformBlockTool(
         toolDescription = workflowMetadata.description
       }
     }
-  } else if (toolId.startsWith('knowledge_') && userProvidedParams.knowledgeBaseId) {
-    uniqueToolId = `${toolConfig.id}_${userProvidedParams.knowledgeBaseId}`
-  } else if (toolId.startsWith('table_') && userProvidedParams.tableId) {
-    uniqueToolId = `${toolConfig.id}_${userProvidedParams.tableId}`
+  } else if (toolId.startsWith('knowledge_') && resolvedResourceParams.knowledgeBaseId) {
+    uniqueToolId = `${toolConfig.id}_${resolvedResourceParams.knowledgeBaseId}`
+  } else if (toolId.startsWith('table_') && resolvedResourceParams.tableId) {
+    uniqueToolId = `${toolConfig.id}_${resolvedResourceParams.tableId}`
   }
 
   const blockParamsFn = blockDef?.tools?.config?.params as
     | ((p: Record<string, any>) => Record<string, any>)
     | undefined
   const blockInputDefs = blockDef?.inputs as Record<string, any> | undefined
 
-  const canonicalGroups: CanonicalGroup[] = blockDef?.subBlocks
-    ? Object.values(buildCanonicalIndex(blockDef.subBlocks).groupsById).filter(isCanonicalPair)
-    : []
-
   const needsTransform = blockParamsFn || blockInputDefs || canonicalGroups.length > 0
   const paramsTransform = needsTransform
     ? (params: Record<string, any>): Record<string, any> => {