perf(tools): read tool metadata instead of the registry on client paths

Cuts the last four edges that pulled `@/tools/registry` into the workspace
shell. Every workspace route drops ~4,700 modules:

  route                before   after
  /w (canvas)           6,592   1,908   -71%
  /logs                 6,227   1,543   -75%
  /tables               5,903   1,217   -79%
  /files                5,996   1,310   -78%
  workspace layout      5,751   1,063   -82%

Dev cold compile of the canvas, n=3, cache cleared between runs:

  before   32.3s / 31.4s / 30.1s   RSS 9.0-12.5 GB
  after    22.4s / 22.2s / 21.6s   RSS 7.8-9.2 GB

That lands where the `dev:minimal` escape hatch measured (20.0s / 6.7 GB)
without its downside — `dev:minimal` swaps in curated registries that drop ~250
services, whereas this keeps every tool working.

Rewired:
  - `block-outputs`  -> `getToolOutputsMetadata` (needed `outputs`)
  - `serializer`     -> `getToolParams`          (needed `params`)
  - `validation`     -> `hasToolId`              (needed existence only)
  - `tools/params`   -> `getToolMetadata`        (needed `params`, `oauth`, `name`)

`tools/params.ts` was the stubborn one: `mcp-dynamic-args.tsx` imports only
`formatParameterLabel` from it, so the whole registry rode in behind a string
helper — the same shape as the `mergeToolParameters` edge cut earlier.

Adds a third generated artifact, `tool-ids.ts` (~110 KB). Resolution needs only
the key set, so `@/tools/metadata` and `@/tools/metadata-outputs` both resolve
through it and stay independent of each other, and an existence check costs
~110 KB instead of ~4 MB.

Behaviour preservation was the risk here: `getTool` resolves an unversioned name
onto its newest version, and a plain key lookup would have silently reported 246
versioned tools as missing. `resolveToolId` is reproduced against the id set and
differentially tested — 4,404 probes (every id, every stripped base name, and an
unknown) comparing old vs new resolution and existence: 0 mismatches.

`ToolWithParameters.toolConfig` and `SubBlocksForToolInput.toolConfig` narrow
from `ToolConfig` to `ToolMetadata`. The only external reader is
`tool-input.tsx`, which uses `.name`.

Author: waleedlatif1

apps/sim/lib/workflows/blocks/block-outputs.ts

@@ -22,7 +22,7 @@ import {
   type OutputCondition,
   type OutputFieldDefinition,
 } from '@/blocks/types'
-import { getTool } from '@/tools/utils'
+import { getToolOutputsMetadata } from '@/tools/metadata-outputs'
 import { getTrigger, isTriggerValid } from '@/triggers'
 
 const logger = createLogger('BlockOutputs')
@@ -681,13 +681,13 @@ export function getToolOutputs(
     const toolId = blockConfig.tools.config.tool(params)
     if (!toolId) return {}
 
-    const toolConfig = getTool(toolId)
-    if (!toolConfig?.outputs) return {}
+    const toolOutputs = getToolOutputsMetadata(toolId)
+    if (!toolOutputs) return {}
     if (includeHidden) {
-      return toolConfig.outputs
+      return toolOutputs
     }
     return Object.fromEntries(
-      Object.entries(toolConfig.outputs).filter(([_, def]) => !isHiddenFromDisplay(def))
+      Object.entries(toolOutputs).filter(([_, def]) => !isHiddenFromDisplay(def))
     )
   } catch (error) {
     logger.warn('Failed to get tool outputs', { error })

apps/sim/lib/workflows/sanitization/validation.ts

@@ -4,7 +4,7 @@ import { isRecordLike } from '@sim/utils/object'
 import { getBlock } from '@/blocks/registry'
 import { isCustomTool, isMcpTool } from '@/executor/constants'
 import type { BlockState, WorkflowState } from '@/stores/workflows/workflow/types'
-import { getTool } from '@/tools/utils'
+import { hasToolId } from '@/tools/tool-ids'
 
 const logger = createLogger('WorkflowValidation')
 
@@ -305,8 +305,7 @@ export function validateToolReference(
 
   if (!isCustomTool(toolId) && !isMcpTool(toolId)) {
     // For built-in tools, verify they exist
-    const tool = getTool(toolId)
-    if (!tool) {
+    if (!hasToolId(toolId)) {
       return `Block ${blockName || 'unknown'} (${blockType}): references non-existent tool '${toolId}'`
     }
   }

apps/sim/serializer/index.ts

@@ -21,7 +21,7 @@ import type { SubBlockConfig } from '@/blocks/types'
 import type { SerializedBlock, SerializedWorkflow } from '@/serializer/types'
 import type { BlockState, Loop, Parallel } from '@/stores/workflows/workflow/types'
 import { generateLoopBlocks, generateParallelBlocks } from '@/stores/workflows/workflow/utils'
-import { getTool } from '@/tools/utils'
+import { getToolParams } from '@/tools/metadata'
 
 const logger = createLogger('Serializer')
 
@@ -637,13 +637,13 @@ export function collectBlockFieldIssues(
   // Get the tool configuration to check parameter visibility
   const toolAccess = blockConfig.tools?.access
   const currentToolId = toolAccess?.length > 0 ? selectToolId(blockConfig, params) : null
-  const currentTool = currentToolId ? getTool(currentToolId) : null
+  const currentToolParams = currentToolId ? getToolParams(currentToolId) : undefined
 
   // Validate tool parameters (for blocks with tools).
   // Lookup contract: a tool param's value lives under its own paramId in `params`.
   // Block subBlocks align via either `id === paramId` or `canonicalParamId === paramId`.
-  if (currentTool) {
-    Object.entries(currentTool.params || {}).forEach(([paramId, paramConfig]: [string, any]) => {
+  if (currentToolParams) {
+    Object.entries(currentToolParams).forEach(([paramId, paramConfig]: [string, any]) => {
       if (paramConfig.required && paramConfig.visibility === 'user-only') {
         const matchingConfigs =
           blockConfig.subBlocks?.filter(
@@ -699,7 +699,7 @@ export function collectBlockFieldIssues(
   }
 
   // Validate required subBlocks not covered by tool params (e.g., blocks with empty tools.access)
-  const validatedByTool = new Set(currentTool ? Object.keys(currentTool.params || {}) : [])
+  const validatedByTool = new Set(currentToolParams ? Object.keys(currentToolParams) : [])
 
   blockConfig.subBlocks?.forEach((subBlockConfig: SubBlockConfig) => {
     if (validatedByTool.has(subBlockConfig.id)) {

apps/sim/tools/generated/tool-ids.ts

@@ -1,4 +1,5 @@
 import rawOutputs from '@/tools/generated/tool-outputs'
+import { resolveToolId } from '@/tools/tool-ids'
 import type { ToolConfig } from '@/tools/types'
 
 /**
@@ -28,5 +29,6 @@ const outputs: Record<string, ToolOutputs> = rawOutputs as Record<string, ToolOu
  * `Object.hasOwn` rather than a bare lookup — see `getToolMetadata` for why.
  */
 export function getToolOutputsMetadata(toolId: string): ToolOutputs | undefined {
-  return Object.hasOwn(outputs, toolId) ? outputs[toolId] : undefined
+  const resolved = resolveToolId(toolId)
+  return Object.hasOwn(outputs, resolved) ? outputs[resolved] : undefined
 }

apps/sim/tools/metadata-outputs.ts

@@ -2,8 +2,9 @@
  * @vitest-environment node
  */
 import { describe, expect, it } from 'vitest'
-import { getToolIds, getToolMetadata, getToolParams, hasToolMetadata } from '@/tools/metadata'
+import { getToolMetadata, getToolParams } from '@/tools/metadata'
 import { getToolOutputsMetadata } from '@/tools/metadata-outputs'
+import { getToolIds, hasToolId, resolveToolId } from '@/tools/tool-ids'
 
 /**
  * Guards the properties the generated artifacts are relied on for. The
@@ -22,7 +23,7 @@ describe('generated tool metadata', () => {
   })
 
   it('reports unknown tools as absent without throwing', () => {
-    expect(hasToolMetadata('definitely_not_a_tool')).toBe(false)
+    expect(hasToolId('definitely_not_a_tool')).toBe(false)
     expect(getToolMetadata('definitely_not_a_tool')).toBeUndefined()
     expect(getToolParams('definitely_not_a_tool')).toBeUndefined()
     expect(getToolOutputsMetadata('definitely_not_a_tool')).toBeUndefined()
@@ -43,10 +44,44 @@ describe('generated tool metadata', () => {
       expect(getToolMetadata(key)).toBeUndefined()
       expect(getToolParams(key)).toBeUndefined()
       expect(getToolOutputsMetadata(key)).toBeUndefined()
-      expect(hasToolMetadata(key)).toBe(false)
+      expect(hasToolId(key)).toBe(false)
     }
   )
 
+  /**
+   * `getTool` resolves an unversioned name onto the newest version, and callers
+   * migrated off it depend on that. A plain key lookup would silently report
+   * versioned tools as missing.
+   */
+  describe('version resolution', () => {
+    /**
+     * Only a versioned id whose base name is *not* itself registered exercises
+     * resolution — where both exist, the base name resolves to itself.
+     */
+    const versionedId = getToolIds().find(
+      (id) => /_v[2-9]\d*$/.test(id) && !getToolIds().includes(id.replace(/_v\d+$/, ''))
+    )
+
+    it('has at least one versioned tool to exercise', () => {
+      expect(versionedId).toBeDefined()
+    })
+
+    it('maps an unversioned name onto the newest version', () => {
+      const baseName = (versionedId as string).replace(/_v\d+$/, '')
+      expect(getToolIds()).not.toContain(baseName)
+      expect(resolveToolId(baseName)).toBe(versionedId)
+      expect(hasToolId(baseName)).toBe(true)
+      expect(getToolMetadata(baseName)?.id).toBe(getToolMetadata(versionedId as string)?.id)
+      expect(getToolOutputsMetadata(baseName)).toEqual(
+        getToolOutputsMetadata(versionedId as string)
+      )
+    })
+
+    it('returns an unknown name unchanged', () => {
+      expect(resolveToolId('definitely_not_a_tool')).toBe('definitely_not_a_tool')
+    })
+  })
+
   /**
    * The registry contains a null param entry (`stt_deepgram_v2`), which crashes
    * any consumer that iterates params unguarded. The generator strips those, so

apps/sim/tools/metadata.test.ts

@@ -1,4 +1,5 @@
 import rawMetadata from '@/tools/generated/tool-metadata'
+import { resolveToolId } from '@/tools/tool-ids'
 import type { OAuthConfig, ToolConfig } from '@/tools/types'
 
 /**
@@ -15,7 +16,10 @@ import type { OAuthConfig, ToolConfig } from '@/tools/types'
  *
  * Outputs live in `@/tools/metadata-outputs`, not here: they are the larger half
  * of the data and have a single consumer, so keeping them in a separate module
- * means callers that only need params don't pay for them.
+ * means callers that only need params don't pay for them. Callers that need
+ * neither should use `@/tools/tool-ids`, which is ~40x smaller again.
+ *
+ * Lookups resolve unversioned names the same way `getTool` does.
  */
 export interface ToolMetadata {
   id: string
@@ -33,16 +37,6 @@ export interface ToolMetadata {
  */
 const metadata: Record<string, ToolMetadata> = rawMetadata as Record<string, ToolMetadata>
 
-/** Every registered tool id, including versioned variants. */
-export function getToolIds(): string[] {
-  return Object.keys(metadata)
-}
-
-/** Whether `toolId` names a built-in tool. Cheaper than resolving its metadata. */
-export function hasToolMetadata(toolId: string): boolean {
-  return Object.hasOwn(metadata, toolId)
-}
-
 /**
  * Serializable metadata for a built-in tool, or `undefined` if unknown.
  *
@@ -52,7 +46,8 @@ export function hasToolMetadata(toolId: string): boolean {
  * metadata.
  */
 export function getToolMetadata(toolId: string): ToolMetadata | undefined {
-  return Object.hasOwn(metadata, toolId) ? metadata[toolId] : undefined
+  const resolved = resolveToolId(toolId)
+  return Object.hasOwn(metadata, resolved) ? metadata[resolved] : undefined
 }
 
 /** Declared parameters for a built-in tool, or `undefined` if unknown. */

apps/sim/tools/metadata.ts

@@ -1,5 +1,6 @@
 import { afterAll, describe, expect, it, vi } from 'vitest'
 import { mergeToolParameters } from '@/tools/merge-params'
+import * as toolMetadata from '@/tools/metadata'
 import {
   createExecutionToolSchema,
   createLLMToolSchema,
@@ -15,7 +16,6 @@ import {
   validateToolParameters,
 } from '@/tools/params'
 import type { HttpMethod, ParameterVisibility } from '@/tools/types'
-import * as toolsUtils from '@/tools/utils'
 
 const mockToolConfig = {
   id: 'test_tool',
@@ -58,11 +58,13 @@ const mockToolConfig = {
 
 /**
  * Spy on the real module namespace instead of vi.mock: under `isolate: false`
- * `@/tools/params` may already be cached bound to the real `@/tools/utils`
+ * `@/tools/params` may already be cached bound to the real `@/tools/metadata`
  * module, so patching the shared namespace is the only wiring that always
  * applies.
  */
-const getToolSpy = vi.spyOn(toolsUtils, 'getTool').mockImplementation(((toolId: string) => {
+const getToolSpy = vi.spyOn(toolMetadata, 'getToolMetadata').mockImplementation(((
+  toolId: string
+) => {
   if (toolId === 'test_tool') {
     return mockToolConfig
   }
@@ -76,7 +78,7 @@ const getToolSpy = vi.spyOn(toolsUtils, 'getTool').mockImplementation(((toolId:
     }
   }
   return null
-}) as unknown as typeof toolsUtils.getTool)
+}) as unknown as typeof toolMetadata.getToolMetadata)
 
 afterAll(() => {
   getToolSpy.mockRestore()

apps/sim/tools/params.test.ts

@@ -18,14 +18,14 @@ import type {
   GenerationType,
 } from '@/blocks/types'
 import { isNonEmpty } from '@/tools/merge-params'
+import { getToolMetadata, type ToolMetadata } from '@/tools/metadata'
 import { safeAssign } from '@/tools/safe-assign'
 import type {
   OAuthConfig,
   ParameterVisibility,
   ToolConfig,
   ToolParameterItemSchema,
 } from '@/tools/types'
-import { getTool } from '@/tools/utils'
 
 const logger = createLogger('ToolsParams')
 type ToolParamDefinition = ToolConfig['params'][string]
@@ -173,7 +173,7 @@ export interface ToolParameterConfig {
 }
 
 export interface ToolWithParameters {
-  toolConfig: ToolConfig
+  toolConfig: ToolMetadata
   allParameters: ToolParameterConfig[]
   userInputParameters: ToolParameterConfig[] // Parameters shown to user
   requiredParameters: ToolParameterConfig[] // Must be filled by user or LLM
@@ -301,7 +301,7 @@ export function getToolParametersConfig(
   blockConfigOverride?: Pick<ToolInputBlockConfig, 'subBlocks'>
 ): ToolWithParameters | null {
   try {
-    const toolConfig = getTool(toolId)
+    const toolConfig = getToolMetadata(toolId)
     if (!toolConfig) {
       logger.warn(`Tool not found: ${toolId}`)
       return null
@@ -971,7 +971,7 @@ const EXCLUDED_SUBBLOCK_TYPES = new Set([
 ])
 
 export interface SubBlocksForToolInput {
-  toolConfig: ToolConfig
+  toolConfig: ToolMetadata
   subBlocks: BlockSubBlockConfig[]
   oauthConfig?: OAuthConfig
 }
@@ -992,7 +992,7 @@ export function getSubBlocksForToolInput(
   blockConfigOverride?: Pick<ToolInputBlockConfig, 'subBlocks'>
 ): SubBlocksForToolInput | null {
   try {
-    const toolConfig = getTool(toolId)
+    const toolConfig = getToolMetadata(toolId)
     if (!toolConfig) {
       logger.warn(`Tool not found: ${toolId}`)
       return null

apps/sim/tools/params.ts

@@ -0,0 +1,69 @@
+import { stripVersionSuffix } from '@sim/utils/string'
+import rawToolIds from '@/tools/generated/tool-ids'
+
+/**
+ * Tool id resolution, without importing the executable registry.
+ *
+ * Resolving a tool name and checking whether one exists need only the registry's
+ * key set — never a `ToolConfig` — so this module carries just the ids (~100 KB
+ * versus ~4 MB for params or outputs). `@/tools/metadata` and
+ * `@/tools/metadata-outputs` both resolve through here, which is what keeps them
+ * independent of each other.
+ *
+ * Semantics mirror `resolveToolId`/`getTool` in `@/tools/utils` exactly,
+ * including returning the input unchanged when nothing matches. See
+ * `.agents/skills/tool-registry-boundary/SKILL.md`.
+ */
+const toolIds: string[] = rawToolIds
+
+const toolIdSet = new Set(toolIds)
+
+/**
+ * Base name -> newest versioned id, built once.
+ *
+ * `@/tools/utils` rebuilds this on every unresolved lookup; the id set is static
+ * at runtime, so caching it is behaviour-identical and drops the repeated O(n)
+ * scan.
+ */
+let latestByBaseName: Map<string, string> | null = null
+
+function getLatestByBaseName(): Map<string, string> {
+  if (latestByBaseName) return latestByBaseName
+
+  const versions = new Map<string, { toolId: string; version: number }>()
+  for (const toolId of toolIds) {
+    const baseName = stripVersionSuffix(toolId)
+    const versionMatch = toolId.match(/_v(\d+)$/)
+    const version = versionMatch ? Number.parseInt(versionMatch[1], 10) : 1
+    const previous = versions.get(baseName)
+    if (!previous || version > previous.version) {
+      versions.set(baseName, { toolId, version })
+    }
+  }
+
+  latestByBaseName = new Map()
+  for (const [baseName, { toolId }] of versions) {
+    latestByBaseName.set(baseName, toolId)
+  }
+  return latestByBaseName
+}
+
+/** Every registered tool id, including versioned variants. */
+export function getToolIds(): string[] {
+  return toolIds
+}
+
+/**
+ * Resolves a tool name to its registered id, mapping an unversioned name onto
+ * the newest version (`notion_search` -> `notion_search_v2`). Returns the input
+ * unchanged when nothing matches, matching `@/tools/utils`.
+ */
+export function resolveToolId(toolName: string): string {
+  if (toolIdSet.has(toolName)) return toolName
+  return getLatestByBaseName().get(toolName) ?? toolName
+}
+
+/** Whether `toolId` names a built-in tool, resolving unversioned names. */
+export function hasToolId(toolId: string): boolean {
+  return toolIdSet.has(resolveToolId(toolId))
+}