fix(mcp): address review on mcp output schema snapshots

- Read the MCP target with the block's saved canonical modes in lint,
  workflows deps and effective outputs, so a dormant basic/advanced member
  never selects or drops the snapshot.
- Expand repeated bracket indices before the nested lint check, as the run
  resolves them.
- Stop expanding a schema once its node budget is spent and leave that object
  open, instead of saving an untyped node per remaining field.
- Keep every declared field name, constructor and __proto__ included.
- Snapshot only blocks the edit changed, and discover best effort, so an
  unreachable server neither slows unrelated edits nor gets marked unhealthy.

Author: waleedlatif1

apps/sim/lib/mcp/output-schema.ts

@@ -13,7 +13,6 @@ export const MCP_STRUCTURED_CONTENT_OUTPUT = 'structuredContent'
 
 const MAX_SHAPE_DEPTH = 8
 const MAX_SHAPE_NODES = 500
-const UNSAFE_PROPERTY_NAMES = new Set(['__proto__', 'constructor', 'prototype'])
 
 /**
  * The structure of a declared output schema: types, properties and array items
@@ -72,12 +71,14 @@ function reduceNode(node: unknown, depth: number, budget: { nodes: number }): Mc
         (node.additionalProperties !== undefined && node.additionalProperties !== false) ||
         node.patternProperties !== undefined
       if (open || !isRecordLike(node.properties)) return { type: 'object' }
-      const properties: Record<string, McpToolOutputShape> = {}
+      const entries: [string, McpToolOutputShape][] = []
       for (const [name, child] of Object.entries(node.properties)) {
-        if (UNSAFE_PROPERTY_NAMES.has(name)) continue
-        properties[name] = reduceNode(child, depth + 1, budget)
+        /** Past the budget the object stays open: any field resolves, none is saved. */
+        if (budget.nodes <= 0) return { type: 'object' }
+        entries.push([name, reduceNode(child, depth + 1, budget)])
       }
-      return { type: 'object', properties }
+      /** `fromEntries` keeps every declared name, `__proto__` included, as an own field. */
+      return { type: 'object', properties: Object.fromEntries(entries) }
     }
     case 'array':
       return isRecordLike(node.items)

apps/sim/lib/mothership/agent-cli/engines/deps.ts

@@ -3,6 +3,7 @@ import { MCP_STRUCTURED_CONTENT_OUTPUT } from '@/lib/mcp/output-schema'
 import { fetchWorkflowState } from '@/lib/mothership/agent-cli/engines/workflow-state'
 import { type AgentCliEngine, agentCliFail, agentCliOk } from '@/lib/mothership/agent-cli/types'
 import { getMcpStructuredContentOutputs } from '@/lib/workflows/blocks/outputs'
+import type { CanonicalModeOverrides } from '@/lib/workflows/subblocks/visibility'
 import { TriggerUtils } from '@/lib/workflows/triggers/triggers'
 import { normalizeName, SPECIAL_REFERENCE_PREFIXES } from '@/executor/constants'
 import { createEnvVarPattern, createReferencePattern } from '@/executor/utils/reference-validation'
@@ -133,7 +134,9 @@ function fillDeclaredStructuredContent(
   block: Record<string, unknown> | undefined
 ): void {
   if (block?.type !== 'mcp' || !Object.hasOwn(mock, MCP_STRUCTURED_CONTENT_OUTPUT)) return
-  const outputs = getMcpStructuredContentOutputs(toRecord(block.subBlocks))
+  // An invalid mode makes resolveMcpBlockConfig throw, which reads as no typed output.
+  const modes = toRecord(toRecord(block.data).canonicalModes) as CanonicalModeOverrides
+  const outputs = getMcpStructuredContentOutputs(toRecord(block.subBlocks), modes)
   const declared = outputs?.[MCP_STRUCTURED_CONTENT_OUTPUT]
   if (!declared) return
 

apps/sim/lib/workflows/application/apply-workflow-operations.ts

@@ -320,10 +320,14 @@ export const applyWorkflowOperations = defineAuthorizedWorkflowUseCase({
         input.blockEnabledChanges ?? [],
         skippedItems
       )
-      modifiedGraph.blocks = await snapshotMcpToolOutputSchemas(enablement.blocks, {
-        principal,
-        workspaceId: context.workspaceId,
-      })
+      modifiedGraph.blocks = await snapshotMcpToolOutputSchemas(
+        enablement.blocks,
+        asGraph(baseGraph).blocks ?? {},
+        {
+          principal,
+          workspaceId: context.workspaceId,
+        }
+      )
       input.checkAborted?.()
       const applied = appliedOperations + enablement.applied
 

apps/sim/lib/workflows/application/mcp-output-schemas.test.ts

@@ -66,6 +66,7 @@ describe('snapshotMcpToolOutputSchemas', () => {
           toolSelector: 'add_note',
         }),
       },
+      {},
       options
     )
 
@@ -76,10 +77,23 @@ describe('snapshotMcpToolOutputSchemas', () => {
     expect(discover).toHaveBeenCalledOnce()
     expect(discover.mock.calls[0]?.[0]).toMatchObject({
       principal,
-      input: { workspaceId: 'workspace-1', serverId: 'server-1' },
+      input: { workspaceId: 'workspace-1', serverId: 'server-1', bestEffort: true },
     })
   })
 
+  it('skips a block the edit did not touch, even one with no snapshot yet', async () => {
+    const untouched = mcpBlock('a', {
+      operation: 'run',
+      serverSelector: 'server-1',
+      toolSelector: 'on_call',
+    })
+    const input = { a: untouched }
+    expect(
+      await snapshotMcpToolOutputSchemas(input, { a: structuredClone(untouched) }, options)
+    ).toBe(input)
+    expect(discover).not.toHaveBeenCalled()
+  })
+
   it('rediscovers a block whose operation changed since its snapshot', async () => {
     const stale = createMcpToolOutputSnapshot('server-1', 'add_note', undefined)
     const blocks = await snapshotMcpToolOutputSchemas(
@@ -91,6 +105,7 @@ describe('snapshotMcpToolOutputSchemas', () => {
           toolOutputSchema: stale,
         }),
       },
+      {},
       options
     )
     expect(snapshotOf(blocks, 'a')).toMatchObject({ tool: 'on_call', schema: { type: 'object' } })
@@ -118,7 +133,7 @@ describe('snapshotMcpToolOutputSchemas', () => {
     ['no operation yet', { operation: 'run', serverSelector: 'server-1', toolSelector: '' }],
   ])('leaves %s alone without discovering', async (_, values) => {
     const input = { a: mcpBlock('a', values) }
-    const blocks = await snapshotMcpToolOutputSchemas(input, options)
+    const blocks = await snapshotMcpToolOutputSchemas(input, {}, options)
     expect(blocks).toBe(input)
     expect(discover).not.toHaveBeenCalled()
   })
@@ -137,6 +152,7 @@ describe('snapshotMcpToolOutputSchemas', () => {
           { tool: 'advanced' }
         ),
       },
+      {},
       options
     )
     expect(snapshotOf(blocks, 'a')).toMatchObject({ tool: 'on_call' })
@@ -147,12 +163,12 @@ describe('snapshotMcpToolOutputSchemas', () => {
     const failed = {
       a: mcpBlock('a', { operation: 'run', serverSelector: 's', toolSelector: 'x' }),
     }
-    expect(await snapshotMcpToolOutputSchemas(failed, options)).toEqual(failed)
+    expect(await snapshotMcpToolOutputSchemas(failed, {}, options)).toEqual(failed)
 
     const unlisted = {
       a: mcpBlock('a', { operation: 'run', serverSelector: 'server-1', toolSelector: 'gone' }),
     }
-    expect(await snapshotMcpToolOutputSchemas(unlisted, options)).toEqual(unlisted)
+    expect(await snapshotMcpToolOutputSchemas(unlisted, {}, options)).toEqual(unlisted)
   })
 
   it('discovers a managed connection through its own use case', async () => {
@@ -164,6 +180,7 @@ describe('snapshotMcpToolOutputSchemas', () => {
       {
         a: mcpBlock('a', { operation: 'run', serverSelector: connection, toolSelector: 'on_call' }),
       },
+      {},
       options
     )
     expect(discover).not.toHaveBeenCalled()

apps/sim/lib/workflows/application/mcp-output-schemas.ts

@@ -85,17 +85,24 @@ async function discoverTools(
       discoverMcpServerToolsUseCase,
       { mcpServerId: serverId }
     ),
-    input: { workspaceId, serverId, signal },
+    // Best effort: a failure here never marks the server unhealthy or starts its shared cooldown.
+    input: { workspaceId, serverId, signal, bestEffort: true },
   })
   return tools
 }
 
+/** The block's resolved target and fields as an edit can change them, to tell an edited block from an untouched one. */
+function editFingerprint(block: BlockState | undefined): string {
+  return JSON.stringify([block?.type, block?.subBlocks ?? {}, block?.data?.canonicalModes ?? {}])
+}
+
 /**
- * Records, on each MCP block an edit left targeting a literal server and
- * operation, the reply shape that operation declares, so the block's
+ * Records, on each MCP block this edit changed and left targeting a literal
+ * server and operation, the reply shape that operation declares, so the block's
  * `structuredContent` output is typed for lint, references, `workflows deps` and
- * the run. Blocks whose snapshot already matches their target are not
- * rediscovered; one per server is discovered, through the same authorized use
+ * the run. Blocks the edit did not touch, and blocks whose snapshot already
+ * matches their target, are not rediscovered, so an unreachable server never
+ * slows an edit that leaves its block alone; one per server is discovered, through the same authorized use
  * case the editor's tool list uses, as the editing principal.
  *
  * Best effort: a server that cannot be discovered, or an operation it does not
@@ -104,9 +111,11 @@ async function discoverTools(
  */
 export async function snapshotMcpToolOutputSchemas(
   blocks: Record<string, BlockState>,
+  baseBlocks: Record<string, BlockState>,
   options: SnapshotOptions
 ): Promise<Record<string, BlockState>> {
   const targets = Object.entries(blocks).flatMap(([blockId, block]) => {
+    if (editFingerprint(block) === editFingerprint(baseBlocks[blockId])) return []
     const target = staleSnapshotTarget(blockId, block)
     return target ? [target] : []
   })

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

@@ -14,6 +14,7 @@ import { resolveMcpBlockConfig } from '@/lib/mcp/workflow-config'
 import { getJevAnswerOutput } from '@/lib/workflows/blocks/jev-outputs'
 import { normalizeInputFormatValue } from '@/lib/workflows/input-format'
 import { containsReference } from '@/lib/workflows/sanitization/references'
+import type { CanonicalModeOverrides } from '@/lib/workflows/subblocks/visibility'
 import { classifyStartBlockType, StartBlockPath } from '@/lib/workflows/triggers/triggers'
 import { TRIGGER_TYPES } from '@/lib/workflows/triggers/types'
 import {
@@ -47,6 +48,8 @@ interface EffectiveOutputOptions {
   triggerMode?: boolean
   preferToolOutputs?: boolean
   includeHidden?: boolean
+  /** The block's saved canonical modes, which pick the active member of a basic/advanced pair. */
+  canonicalModes?: CanonicalModeOverrides
 }
 
 type ConditionValue = string | number | boolean
@@ -461,7 +464,8 @@ function toOutputNode(shape: McpToolOutputShape): DeclaredOutputNode {
  * targets now applies; anything else leaves the block's outputs as declared.
  */
 export function getMcpStructuredContentOutputs(
-  subBlocks?: Record<string, unknown>
+  subBlocks?: Record<string, unknown>,
+  canonicalModes?: CanonicalModeOverrides
 ): OutputDefinition | undefined {
   if (!subBlocks) return undefined
   const values = Object.fromEntries(
@@ -471,7 +475,7 @@ export function getMcpStructuredContentOutputs(
   if (!snapshot?.schema) return undefined
   let target: ReturnType<typeof resolveMcpBlockConfig>
   try {
-    target = resolveMcpBlockConfig(values)
+    target = resolveMcpBlockConfig(values, canonicalModes)
   } catch {
     return undefined
   }
@@ -540,7 +544,7 @@ export function getEffectiveBlockOutputs(
   }
 
   if (blockType === 'mcp' && !triggerMode) {
-    const structuredOutputs = getMcpStructuredContentOutputs(subBlocks)
+    const structuredOutputs = getMcpStructuredContentOutputs(subBlocks, options?.canonicalModes)
     if (structuredOutputs) return { ...baseOutputs, ...structuredOutputs }
   }
 

apps/sim/lib/workflows/editing/dangling-refs.test.ts

@@ -78,6 +78,7 @@ function graph(
       type?: string
       name?: string
       triggerMode?: boolean
+      data?: { canonicalModes?: Record<string, 'basic' | 'advanced'> }
       subBlocks?: Record<string, { value?: unknown }>
     }
   >
@@ -287,15 +288,21 @@ describe('collectDanglingBlockOutputReferences', () => {
       },
     }
 
-    function mcpGraph(reference: string, snapshot?: unknown) {
+    function mcpGraph(
+      reference: string,
+      snapshot?: unknown,
+      extra: { toolReference?: string; canonicalModes?: Record<string, 'basic' | 'advanced'> } = {}
+    ) {
       return graph({
         oncall: {
           type: 'mcp',
           name: 'On call',
+          ...(extra.canonicalModes ? { data: { canonicalModes: extra.canonicalModes } } : {}),
           subBlocks: {
             operation: { value: 'run' },
             serverSelector: { value: 'server-1' },
             toolSelector: { value: 'on_call' },
+            ...(extra.toolReference ? { toolReference: { value: extra.toolReference } } : {}),
             ...(snapshot === undefined ? {} : { toolOutputSchema: { value: snapshot } }),
           },
         },
@@ -340,6 +347,41 @@ describe('collectDanglingBlockOutputReferences', () => {
       expect(finding?.reason).toContain('structuredContent.person.id')
     })
 
+    it('reads the operation from the saved mode, not a dormant member', () => {
+      expect(
+        collectDanglingBlockOutputReferences(
+          mcpGraph('<oncall.structuredContent.role>', declared, {
+            toolReference: 'add_note',
+            canonicalModes: { tool: 'basic' },
+          })
+        )
+      ).toEqual([])
+    })
+
+    it('checks repeated array indices the way the run resolves them', () => {
+      const grid = createMcpToolOutputSnapshot('server-1', 'on_call', {
+        type: 'object',
+        properties: {
+          rows: {
+            type: 'array',
+            items: {
+              type: 'array',
+              items: { type: 'object', properties: { id: { type: 'string' } } },
+            },
+          },
+        },
+      })
+      expect(
+        collectDanglingBlockOutputReferences(
+          mcpGraph('<oncall.structuredContent.rows[0][1].id>', grid)
+        )
+      ).toEqual([])
+      const [finding] = collectDanglingBlockOutputReferences(
+        mcpGraph('<oncall.structuredContent.rows[0][1].nope>', grid)
+      )
+      expect(finding?.reason).toContain('Declared fields: structuredContent.rows.id')
+    })
+
     it('keeps flagging structuredContent when the operation declares no schema', () => {
       for (const snapshot of [
         undefined,

apps/sim/lib/workflows/editing/lint.ts

@@ -11,6 +11,7 @@ import {
   getMcpStructuredContentOutputs,
   getResponseFormatOutputs,
 } from '@/lib/workflows/blocks/outputs'
+import type { CanonicalModeOverrides } from '@/lib/workflows/subblocks/visibility'
 import { getBlock } from '@/blocks'
 import {
   isTriggerBlockType,
@@ -20,6 +21,7 @@ import {
 } from '@/executor/constants'
 import { isPathInSchema } from '@/executor/utils/block-reference'
 import { collectStringLeaves } from '@/executor/utils/reference-validation'
+import { splitLeadingBracketPath } from '@/executor/variables/resolvers/reference'
 import {
   collectBlockFieldIssues,
   extractBlockParams,
@@ -34,6 +36,7 @@ type BlockState = {
   name?: string
   triggerMode?: boolean
   subBlocks?: Record<string, { value?: unknown } | undefined>
+  data?: { canonicalModes?: CanonicalModeOverrides }
 }
 
 type EdgeState = {
@@ -643,6 +646,7 @@ function declaredOutputKeys(block: BlockState): string[] | undefined {
       triggerMode: false,
       preferToolOutputs: true,
       includeHidden: true,
+      canonicalModes: block.data?.canonicalModes,
     })
   )
   if (keys.length === 0) return undefined
@@ -666,10 +670,8 @@ function declaredChildPaths(outputs: Record<string, unknown>, prefix: string[]):
       node = toRecordOrNull(node?.items)
       continue
     }
-    const field = part.replace(INDEX_SUFFIX, '')
-    node = toRecordOrNull(toRecordOrNull(node?.properties)?.[field])
-    if (field !== part) node = toRecordOrNull(node?.items)
-    named.push(field)
+    node = toRecordOrNull(toRecordOrNull(node?.properties)?.[part])
+    named.push(part)
   }
   if (node?.type === 'array') node = toRecordOrNull(node.items)
   return Object.keys(toRecordOrNull(node?.properties) ?? {}).map((name) =>
@@ -689,9 +691,15 @@ function undeclaredNestedPath(
   token: string
 ): UndeclaredNestedPath | undefined {
   if (block?.type !== 'mcp') return undefined
-  const parts = token.split('.').slice(1)
+  const parts = token
+    .split('.')
+    .slice(1)
+    .flatMap((part) => {
+      const { property, pathParts } = splitLeadingBracketPath(part)
+      return [property, ...pathParts]
+    })
   if (parts[0] !== MCP_STRUCTURED_CONTENT_OUTPUT || parts.length < 2) return undefined
-  const outputs = getMcpStructuredContentOutputs(subBlockValues(block))
+  const outputs = getMcpStructuredContentOutputs(subBlockValues(block), block.data?.canonicalModes)
   if (!outputs || isPathInSchema(outputs, parts)) return undefined
   let valid = 1
   while (valid < parts.length && isPathInSchema(outputs, parts.slice(0, valid + 1))) valid++

apps/sim/serializer/mcp-output-schema.test.ts

@@ -90,6 +90,29 @@ describe('MCP block output typed from a declared output schema', () => {
     expect(resolve(declared, ['content', '0', 'text'])).toBe('{"role":"sales-ops"}')
   })
 
+  it('keeps declared fields whose names are object built-ins', () => {
+    const snapshot = createMcpToolOutputSnapshot(
+      'server-1',
+      'on_call',
+      JSON.parse(
+        '{"type":"object","properties":{"constructor":{"type":"string"},"__proto__":{"type":"number"}}}'
+      )
+    )
+    expect(Object.keys(snapshot.schema?.properties ?? {})).toEqual(['constructor', '__proto__'])
+  })
+
+  it('leaves a schema wider than the snapshot budget open instead of saving every field', () => {
+    const wide = createMcpToolOutputSnapshot('server-1', 'on_call', {
+      type: 'object',
+      properties: Object.fromEntries(
+        Array.from({ length: 2_000 }, (_, index) => [`field${index}`, { type: 'string' }])
+      ),
+    })
+    expect(wide.schema).toEqual({ type: 'object' })
+    expect(resolve(wide, ['structuredContent', 'role'])).toBe('sales-ops')
+    expect(resolve(wide, ['structuredContent', 'anything'])).toBeUndefined()
+  })
+
   it('carries the schema structure without description strings into block params', () => {
     const params = serializeMcpBlock(declared).config.params
     expect(params.toolOutputSchema).toEqual(declared)