fix(mcp): fix cursor schema transformation issue with recursive references

Author: stainless-app[bot]

packages/mcp-server/src/compat.ts

@@ -148,7 +148,11 @@ export function removeTopLevelUnions(tool: Tool): Tool[] {
   });
 }
 
-function findUsedDefs(schema: JSONSchema, defs: Record<string, JSONSchema>): Record<string, JSONSchema> {
+function findUsedDefs(
+  schema: JSONSchema,
+  defs: Record<string, JSONSchema>,
+  visited: Set<string> = new Set(),
+): Record<string, JSONSchema> {
   const usedDefs: Record<string, JSONSchema> = {};
 
   if (typeof schema !== 'object' || schema === null) {
@@ -160,23 +164,28 @@ function findUsedDefs(schema: JSONSchema, defs: Record<string, JSONSchema>): Rec
     if (refParts[0] === '#' && refParts[1] === '$defs' && refParts[2]) {
       const defName = refParts[2];
       const def = defs[defName];
-      if (def) {
+      if (def && !visited.has(schema.$ref)) {
         usedDefs[defName] = def;
-        Object.assign(usedDefs, findUsedDefs(def, defs));
+        visited.add(schema.$ref);
+        Object.assign(usedDefs, findUsedDefs(def, defs, visited));
+        visited.delete(schema.$ref);
       }
     }
     return usedDefs;
   }
 
   for (const key in schema) {
     if (key !== '$defs' && typeof schema[key] === 'object' && schema[key] !== null) {
-      Object.assign(usedDefs, findUsedDefs(schema[key] as JSONSchema, defs));
+      Object.assign(usedDefs, findUsedDefs(schema[key] as JSONSchema, defs, visited));
     }
   }
 
   return usedDefs;
 }
 
+// Export for testing
+export { findUsedDefs };
+
 /**
  * Inlines all $refs in a schema, eliminating $defs.
  * If a circular reference is detected, the circular property is removed.

packages/mcp-server/tests/compat.test.ts

@@ -5,6 +5,7 @@ import {
   inlineRefs,
   applyCompatibilityTransformations,
   removeFormats,
+  findUsedDefs,
 } from '../src/compat';
 import { Tool } from '@modelcontextprotocol/sdk/types.js';
 import { JSONSchema } from '../src/compat';
@@ -316,6 +317,103 @@ describe('removeAnyOf', () => {
   });
 });
 
+describe('findUsedDefs', () => {
+  it('should handle circular references without stack overflow', () => {
+    const defs = {
+      person: {
+        type: 'object',
+        properties: {
+          name: { type: 'string' },
+          friend: { $ref: '#/$defs/person' }, // Circular reference
+        },
+      },
+    };
+
+    const schema = {
+      type: 'object',
+      properties: {
+        user: { $ref: '#/$defs/person' },
+      },
+    };
+
+    // This should not throw a stack overflow error
+    expect(() => {
+      const result = findUsedDefs(schema, defs);
+      expect(result).toHaveProperty('person');
+    }).not.toThrow();
+  });
+
+  it('should handle indirect circular references without stack overflow', () => {
+    const defs = {
+      node: {
+        type: 'object',
+        properties: {
+          value: { type: 'string' },
+          child: { $ref: '#/$defs/childNode' },
+        },
+      },
+      childNode: {
+        type: 'object',
+        properties: {
+          value: { type: 'string' },
+          parent: { $ref: '#/$defs/node' }, // Indirect circular reference
+        },
+      },
+    };
+
+    const schema = {
+      type: 'object',
+      properties: {
+        root: { $ref: '#/$defs/node' },
+      },
+    };
+
+    // This should not throw a stack overflow error
+    expect(() => {
+      const result = findUsedDefs(schema, defs);
+      expect(result).toHaveProperty('node');
+      expect(result).toHaveProperty('childNode');
+    }).not.toThrow();
+  });
+
+  it('should find all used definitions in non-circular schemas', () => {
+    const defs = {
+      user: {
+        type: 'object',
+        properties: {
+          name: { type: 'string' },
+          address: { $ref: '#/$defs/address' },
+        },
+      },
+      address: {
+        type: 'object',
+        properties: {
+          street: { type: 'string' },
+          city: { type: 'string' },
+        },
+      },
+      unused: {
+        type: 'object',
+        properties: {
+          data: { type: 'string' },
+        },
+      },
+    };
+
+    const schema = {
+      type: 'object',
+      properties: {
+        person: { $ref: '#/$defs/user' },
+      },
+    };
+
+    const result = findUsedDefs(schema, defs);
+    expect(result).toHaveProperty('user');
+    expect(result).toHaveProperty('address');
+    expect(result).not.toHaveProperty('unused');
+  });
+});
+
 describe('inlineRefs', () => {
   it('should return the original schema if it does not contain $refs', () => {
     const schema: JSONSchema = {