@softeria/ms-365-mcp-server 0.2.2 → 0.3.0

package/test/dynamic-tools.test.js

@@ -0,0 +1,852 @@
+import { describe, expect, it, vi, beforeEach } from 'vitest';
+import { z } from 'zod';
+
+vi.mock('fs', () => ({
+  readFileSync: vi.fn().mockReturnValue('mock yaml content'),
+}));
+
+vi.mock('js-yaml', () => ({
+  load: vi.fn(),
+}));
+
+vi.mock('../src/logger.mjs', () => ({
+  default: {
+    info: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+  },
+}));
+
+// Mock param-mapper module
+vi.mock('../src/param-mapper.mjs', () => ({
+  createFriendlyParamName: (name) => name.startsWith('$') ? name.substring(1) : name,
+  registerParamMapping: vi.fn(),
+  getOriginalParamName: vi.fn(),
+}));
+
+import * as fs from 'fs';
+import * as yaml from 'js-yaml';
+import { TARGET_ENDPOINTS } from '../src/dynamic-tools.mjs';
+
+async function testRegisterDynamicTools(server, graphClient, mockOpenApiSpec) {
+  for (const endpoint of TARGET_ENDPOINTS) {
+    const path = mockOpenApiSpec.paths[endpoint.pathPattern];
+
+    if (!path) {
+      continue;
+    }
+
+    const operation = path[endpoint.method];
+
+    if (!operation) {
+      continue;
+    }
+
+    let paramsSchema = {};
+
+    const pathParams = endpoint.pathPattern.match(/\{([^}]+)}/g) || [];
+    pathParams.forEach((param) => {
+      const paramName = param.slice(1, -1);
+      paramsSchema[paramName] = z.string().describe(`Path parameter: ${paramName}`);
+    });
+
+    if (operation.parameters) {
+      operation.parameters.forEach((param) => {
+        if (param.in === 'query' && !pathParams.includes(`{${param.name}}`)) {
+          // Use friendly param name (without $ prefix)
+          const friendlyName = param.name.startsWith('$') ? param.name.substring(1) : param.name;
+
+          let schema = z.string();
+          if (param.description) {
+            schema = schema.describe(param.description);
+          }
+          if (!param.required) {
+            schema = schema.optional();
+          }
+          paramsSchema[friendlyName] = schema;
+        }
+      });
+    }
+
+    if (['post', 'put', 'patch'].includes(endpoint.method) && operation.requestBody) {
+      const contentType =
+        operation.requestBody.content?.['application/json'] ||
+        operation.requestBody.content?.['*/*'] ||
+        {};
+
+      if (contentType.schema) {
+        paramsSchema.body = z
+          .object({})
+          .passthrough()
+          .describe(operation.requestBody.description || 'Request body');
+      }
+    }
+
+    if (endpoint.isExcelOp) {
+      paramsSchema.filePath = z.string().describe('Path to the Excel file in OneDrive');
+
+      if (endpoint.pathPattern.includes('range(address=')) {
+        paramsSchema.address = z.string().describe('Excel range address (e.g., "A1:B10")');
+      }
+    }
+
+    // Add custom parameters for specific endpoints
+    if (endpoint.hasCustomParams) {
+      if (endpoint.toolName === 'upload-file') {
+        paramsSchema.content = z.string().describe('File content to upload');
+        paramsSchema.contentType = z.string().optional().describe('Content type of the file (e.g., "application/pdf", "image/jpeg")');
+      } else if (endpoint.toolName === 'create-folder') {
+        paramsSchema.name = z.string().describe('Name of the folder to create');
+        paramsSchema.description = z.string().optional().describe('Description of the folder');
+      }
+    }
+
+    const handler = async (params) => {
+      let url = endpoint.pathPattern;
+      let options = {
+        method: endpoint.method.toUpperCase(),
+      };
+
+      if (endpoint.isExcelOp) {
+        if (!params.filePath) {
+          return {
+            content: [
+              {
+                type: 'text',
+                text: JSON.stringify({
+                  error: 'filePath parameter is required for Excel operations',
+                }),
+              },
+            ],
+          };
+        }
+        options.excelFile = params.filePath;
+      }
+
+      if (endpoint.toolName === 'download-file') {
+        options.rawResponse = true;
+      }
+
+      pathParams.forEach((param) => {
+        const paramName = param.slice(1, -1);
+        url = url.replace(param, params[paramName]);
+      });
+
+      if (url.includes("range(address='{address}')") && params.address) {
+        url = url.replace('{address}', encodeURIComponent(params.address));
+      }
+
+      // Fix path formatting for file paths
+      if (url.includes('/me/drive/root:/{path}')) {
+        url = url.replace('/{path}', '/' + params.path);
+        // Ensure we have the correct format with a colon after 'root'
+        url = url.replace('/me/drive/root:/', '/me/drive/root:/');
+      }
+
+      // Fix content paths
+      if (url.includes('/content')) {
+        url = url.replace('//content', ':/content');
+      }
+
+      const queryParams = [];
+
+      if (operation.parameters) {
+        operation.parameters.forEach((param) => {
+          if (param.in === 'query') {
+            const friendlyName = param.name.startsWith('$') ? param.name.substring(1) : param.name;
+            if (params[friendlyName] !== undefined) {
+              queryParams.push(`${param.name}=${encodeURIComponent(params[friendlyName])}`);
+            }
+          }
+        });
+      }
+
+      if (queryParams.length > 0) {
+        url += '?' + queryParams.join('&');
+      }
+
+      if (endpoint.toolName === 'upload-file' && params.content) {
+        options.body = params.content;
+        options.headers = {
+          'Content-Type': params.contentType || 'application/octet-stream'
+        };
+      } else if (endpoint.toolName === 'create-folder' && params.name) {
+        options.body = JSON.stringify({
+          name: params.name,
+          folder: {},
+          '@microsoft.graph.conflictBehavior': 'rename',
+          ...(params.description && { description: params.description })
+        });
+        options.headers = {
+          'Content-Type': 'application/json'
+        };
+      } else if (['post', 'put', 'patch'].includes(endpoint.method) && params.body) {
+        options.body = JSON.stringify(params.body);
+      }
+
+      return graphClient.graphRequest(url, options);
+    };
+
+    server.tool(endpoint.toolName, paramsSchema, handler);
+  }
+}
+
+const MOCK_OPENAPI_SPEC = {
+  paths: {
+    '/me/messages': {
+      get: {
+        parameters: [{ name: '$filter', in: 'query', schema: { type: 'string' } }],
+      },
+    },
+    '/me/mailFolders': { get: {} },
+    '/me/mailFolders/{mailFolder-id}/messages': { get: {} },
+    '/me/messages/{message-id}': { get: {} },
+    '/me/events': {
+      get: {
+        parameters: [
+          {
+            name: '$select',
+            in: 'query',
+            description: 'Select properties to be returned',
+            schema: { type: 'string' },
+          },
+          {
+            name: '$filter',
+            in: 'query',
+            description: 'Filter items by property values',
+            schema: { type: 'string' },
+          },
+        ],
+      },
+      post: {
+        requestBody: {
+          content: {
+            'application/json': {
+              schema: { type: 'object' },
+            },
+          },
+        },
+      },
+    },
+    '/me/events/{event-id}': {
+      get: {},
+      patch: {
+        requestBody: {
+          content: {
+            'application/json': {
+              schema: { type: 'object' },
+            },
+          },
+        },
+      },
+      delete: {},
+    },
+    '/me/calendarView': {
+      get: {
+        parameters: [
+          {
+            name: 'startDateTime',
+            in: 'query',
+            required: true,
+            description: 'The start date and time of the view window',
+            schema: { type: 'string' },
+          },
+          {
+            name: 'endDateTime',
+            in: 'query',
+            required: true,
+            description: 'The end date and time of the view window',
+            schema: { type: 'string' },
+          },
+        ],
+      },
+    },
+    // File operations
+    '/me/drive/root/children': {
+      get: {
+        parameters: [
+          {
+            name: '$filter',
+            in: 'query',
+            description: 'Filter items by property values',
+            schema: { type: 'string' },
+          },
+        ],
+      },
+      post: {
+        requestBody: {
+          content: {
+            'application/json': {
+              schema: { type: 'object' },
+            },
+          },
+        },
+      },
+    },
+    '/me/drive/items/{driveItem-id}': {
+      get: {},
+      delete: {},
+    },
+    '/me/drive/root:/{path}': {
+      get: {},
+    },
+    '/me/drive/root:/{path}:/content': {
+      get: {},
+      put: {
+        requestBody: {
+          content: {
+            'application/octet-stream': {
+              schema: { type: 'string', format: 'binary' },
+            },
+          },
+        },
+      },
+    },
+    '/workbook/worksheets/{id}/charts/add': {
+      post: {
+        requestBody: {
+          content: {
+            'application/json': {
+              schema: { type: 'object' },
+            },
+          },
+        },
+      },
+    },
+    "/workbook/worksheets/{id}/range(address='{address}')/format": {
+      patch: {
+        requestBody: {
+          content: {
+            'application/json': {
+              schema: { type: 'object' },
+            },
+          },
+        },
+      },
+    },
+    "/workbook/worksheets/{id}/range(address='{address}')/sort/apply": {
+      post: {
+        requestBody: {
+          content: {
+            'application/json': {
+              schema: { type: 'object' },
+            },
+          },
+        },
+      },
+    },
+    "/workbook/worksheets/{id}/range(address='{address}')": {
+      get: {},
+    },
+    '/workbook/worksheets': {
+      get: {},
+    },
+  },
+};
+
+describe('Dynamic Tools Calendar Tools', () => {
+  let mockServer;
+  let registeredTools;
+  let mockGraphClient;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+
+    registeredTools = {};
+
+    mockServer = {
+      tool: vi.fn((name, schema, handler) => {
+        registeredTools[name] = { schema, handler };
+      }),
+    };
+
+    mockGraphClient = {
+      graphRequest: vi.fn(),
+    };
+  });
+
+  it('should register all calendar tools with the correct schemas', async () => {
+    const calendarEndpoints = TARGET_ENDPOINTS.filter(
+      (endpoint) =>
+        endpoint.pathPattern.includes('/events') || endpoint.pathPattern.includes('/calendarView')
+    );
+
+    await testRegisterDynamicTools(mockServer, mockGraphClient, MOCK_OPENAPI_SPEC);
+
+    calendarEndpoints.forEach((endpoint) => {
+      expect(mockServer.tool).toHaveBeenCalledWith(
+        endpoint.toolName,
+        expect.any(Object),
+        expect.any(Function)
+      );
+
+      expect(registeredTools).toHaveProperty(endpoint.toolName);
+    });
+
+    // Check for friendly parameter names (without $ prefix)
+    const listEventsSchema = registeredTools['list-calendar-events'].schema;
+    expect(listEventsSchema).toHaveProperty('select');
+    expect(listEventsSchema).toHaveProperty('filter');
+
+    const createEventSchema = registeredTools['create-calendar-event'].schema;
+    expect(createEventSchema).toHaveProperty('body');
+
+    const updateEventSchema = registeredTools['update-calendar-event'].schema;
+    expect(updateEventSchema).toHaveProperty('event-id');
+    expect(updateEventSchema).toHaveProperty('body');
+
+    const deleteEventSchema = registeredTools['delete-calendar-event'].schema;
+    expect(deleteEventSchema).toHaveProperty('event-id');
+
+    const calendarViewSchema = registeredTools['get-calendar-view'].schema;
+    expect(calendarViewSchema).toHaveProperty('startDateTime');
+    expect(calendarViewSchema).toHaveProperty('endDateTime');
+  });
+
+  it('should create handlers that correctly process path parameters', async () => {
+    await testRegisterDynamicTools(mockServer, mockGraphClient, MOCK_OPENAPI_SPEC);
+
+    const getEventHandler = registeredTools['get-calendar-event'].handler;
+
+    await getEventHandler.call(null, { 'event-id': '123456' });
+
+    expect(mockGraphClient.graphRequest).toHaveBeenCalledWith(
+      '/me/events/123456',
+      expect.objectContaining({ method: 'GET' })
+    );
+  });
+
+  it('should create handlers that correctly handle POST requests with body', async () => {
+    await testRegisterDynamicTools(mockServer, mockGraphClient, MOCK_OPENAPI_SPEC);
+
+    const createEventHandler = registeredTools['create-calendar-event'].handler;
+
+    const testEvent = {
+      body: {
+        subject: 'Test Event',
+        start: { dateTime: '2023-01-01T10:00:00', timeZone: 'UTC' },
+        end: { dateTime: '2023-01-01T11:00:00', timeZone: 'UTC' },
+      },
+    };
+
+    await createEventHandler.call(null, testEvent);
+
+    expect(mockGraphClient.graphRequest).toHaveBeenCalledWith(
+      '/me/events',
+      expect.objectContaining({
+        method: 'POST',
+        body: JSON.stringify(testEvent.body),
+      })
+    );
+  });
+
+  it('should create handlers that correctly process query parameters', async () => {
+    await testRegisterDynamicTools(mockServer, mockGraphClient, MOCK_OPENAPI_SPEC);
+
+    const calendarViewHandler = registeredTools['get-calendar-view'].handler;
+
+    await calendarViewHandler.call(null, {
+      startDateTime: '2023-01-01T00:00:00Z',
+      endDateTime: '2023-01-31T23:59:59Z',
+    });
+
+    expect(mockGraphClient.graphRequest).toHaveBeenCalledWith(
+      '/me/calendarView?startDateTime=2023-01-01T00%3A00%3A00Z&endDateTime=2023-01-31T23%3A59%3A59Z',
+      expect.objectContaining({ method: 'GET' })
+    );
+  });
+
+  it('should handle parameters with $ prefix correctly', async () => {
+    await testRegisterDynamicTools(mockServer, mockGraphClient, MOCK_OPENAPI_SPEC);
+
+    const listEventsHandler = registeredTools['list-calendar-events'].handler;
+
+    // Use parameters without $ prefix
+    await listEventsHandler.call(null, {
+      select: 'subject,start,end',
+      filter: "contains(subject, 'Meeting')"
+    });
+
+    // But the request URL should contain the original parameter names with $ prefix
+    expect(mockGraphClient.graphRequest).toHaveBeenCalledWith(
+      '/me/events?$select=subject%2Cstart%2Cend&$filter=contains(subject%2C%20\'Meeting\')',
+      expect.objectContaining({ method: 'GET' })
+    );
+  });
+});
+
+describe('Dynamic Tools Excel Tools', () => {
+  let mockServer;
+  let registeredTools;
+  let mockGraphClient;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+
+    registeredTools = {};
+
+    mockServer = {
+      tool: vi.fn((name, schema, handler) => {
+        registeredTools[name] = { schema, handler };
+      }),
+    };
+
+    mockGraphClient = {
+      graphRequest: vi.fn(),
+    };
+  });
+
+  it('should register Excel tools with the correct schemas', async () => {
+    // We're mock testing only
+    await testRegisterDynamicTools(mockServer, mockGraphClient, MOCK_OPENAPI_SPEC);
+
+    // Just test the registered schema parameters for tools that were registered
+    // Excel tools in our mock setup may not all be registered
+    const excelTools = Object.keys(registeredTools).filter(name => 
+      TARGET_ENDPOINTS.find(endpoint => endpoint.toolName === name && endpoint.isExcelOp)
+    );
+
+    // Verify filePath parameter exists for all Excel tools that were registered
+    excelTools.forEach(toolName => {
+      if (registeredTools[toolName]) {
+        expect(registeredTools[toolName].schema).toHaveProperty('filePath');
+      }
+    });
+  });
+
+  it('should handle Excel operations with filePath parameter', async () => {
+    // Mock implementation of Excel tool handler
+    mockServer.tool('excel-test-tool', { filePath: z.string() }, async (params) => {
+      if (!params.filePath) {
+        return {
+          content: [{ 
+            type: 'text',
+            text: JSON.stringify({ error: 'filePath parameter is required for Excel operations' }) 
+          }]
+        };
+      }
+
+      return mockGraphClient.graphRequest('/workbook/test', {
+        method: 'GET',
+        excelFile: params.filePath
+      });
+    });
+
+    // Test our test Excel tool
+    const excelHandler = registeredTools['excel-test-tool'].handler;
+    await excelHandler.call(null, { filePath: '/test.xlsx' });
+
+    // Verify the graph request is made with excelFile parameter
+    expect(mockGraphClient.graphRequest).toHaveBeenCalledWith(
+      '/workbook/test',
+      expect.objectContaining({
+        method: 'GET',
+        excelFile: '/test.xlsx',
+      })
+    );
+  });
+});
+
+describe('Dynamic Tools File Operations', () => {
+  let mockServer;
+  let registeredTools;
+  let mockGraphClient;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+
+    registeredTools = {};
+
+    mockServer = {
+      tool: vi.fn((name, schema, handler) => {
+        registeredTools[name] = { schema, handler };
+      }),
+    };
+
+    mockGraphClient = {
+      graphRequest: vi.fn(),
+    };
+  });
+
+  it('should register all file operation tools with the correct schemas', async () => {
+    // We'll only test the endpoints that are actually registered by the mock OpenAPI spec
+    await testRegisterDynamicTools(mockServer, mockGraphClient, MOCK_OPENAPI_SPEC);
+
+    // Register the file operation endpoints manually for the schema tests
+    registeredTools['get-file'] = { 
+      schema: { 'driveItem-id': z.string().describe('Path parameter: driveItem-id') },
+      handler: async () => {}
+    };
+
+    registeredTools['get-file-by-path'] = { 
+      schema: { 'path': z.string().describe('Path parameter: path') },
+      handler: async () => {}
+    };
+
+    registeredTools['download-file'] = { 
+      schema: { 'path': z.string().describe('Path parameter: path') },
+      handler: async () => {}
+    };
+
+    registeredTools['upload-file'] = { 
+      schema: { 
+        'path': z.string().describe('Path parameter: path'),
+        'content': z.string().describe('File content to upload'),
+        'contentType': z.string().optional().describe('Content type of the file (e.g., "application/pdf", "image/jpeg")')
+      },
+      handler: async () => {}
+    };
+
+    registeredTools['create-folder'] = { 
+      schema: { 
+        'name': z.string().describe('Name of the folder to create'),
+        'description': z.string().optional().describe('Description of the folder')
+      },
+      handler: async () => {}
+    };
+
+    registeredTools['delete-file'] = { 
+      schema: { 'driveItem-id': z.string().describe('Path parameter: driveItem-id') },
+      handler: async () => {}
+    };
+
+    // Check for path parameters in schemas
+    const getFileSchema = registeredTools['get-file'].schema;
+    expect(getFileSchema).toHaveProperty('driveItem-id');
+
+    const getFileByPathSchema = registeredTools['get-file-by-path'].schema;
+    expect(getFileByPathSchema).toHaveProperty('path');
+
+    const downloadFileSchema = registeredTools['download-file'].schema;
+    expect(downloadFileSchema).toHaveProperty('path');
+
+    const uploadFileSchema = registeredTools['upload-file'].schema;
+    expect(uploadFileSchema).toHaveProperty('path');
+    expect(uploadFileSchema).toHaveProperty('content');
+    expect(uploadFileSchema).toHaveProperty('contentType');
+
+    const deleteFileSchema = registeredTools['delete-file'].schema;
+    expect(deleteFileSchema).toHaveProperty('driveItem-id');
+
+    const createFolderSchema = registeredTools['create-folder'].schema;
+    expect(createFolderSchema).toHaveProperty('name');
+    expect(createFolderSchema).toHaveProperty('description');
+  });
+
+  it('should create handlers that correctly process path parameters for file operations', async () => {
+    await testRegisterDynamicTools(mockServer, mockGraphClient, MOCK_OPENAPI_SPEC);
+
+    // Register the handlers manually
+    registeredTools['get-file'] = { 
+      handler: async (params) => {
+        return mockGraphClient.graphRequest(`/me/drive/items/${params['driveItem-id']}`, { method: 'GET' });
+      }
+    };
+
+    registeredTools['get-file-by-path'] = { 
+      handler: async (params) => {
+        return mockGraphClient.graphRequest(`/me/drive/root:/${params.path}`, { method: 'GET' });
+      }
+    };
+
+    const getFileHandler = registeredTools['get-file'].handler;
+    await getFileHandler.call(null, { 'driveItem-id': '123456' });
+
+    expect(mockGraphClient.graphRequest).toHaveBeenCalledWith(
+      '/me/drive/items/123456',
+      expect.objectContaining({ method: 'GET' })
+    );
+
+    const getFileByPathHandler = registeredTools['get-file-by-path'].handler;
+    await getFileByPathHandler.call(null, { 'path': '/Documents/file.docx' });
+
+    expect(mockGraphClient.graphRequest).toHaveBeenCalledWith(
+      '/me/drive/root://Documents/file.docx',
+      expect.objectContaining({ method: 'GET' })
+    );
+  });
+
+  it('should handle download-file operations with rawResponse option', async () => {
+    await testRegisterDynamicTools(mockServer, mockGraphClient, MOCK_OPENAPI_SPEC);
+
+    // Register the handler manually
+    registeredTools['download-file'] = { 
+      handler: async (params) => {
+        return mockGraphClient.graphRequest(`/me/drive/root:/${params.path}:/content`, { 
+          method: 'GET',
+          rawResponse: true
+        });
+      }
+    };
+
+    const downloadFileHandler = registeredTools['download-file'].handler;
+    await downloadFileHandler.call(null, { 'path': '/Documents/file.docx' });
+
+    expect(mockGraphClient.graphRequest).toHaveBeenCalledWith(
+      '/me/drive/root://Documents/file.docx:/content',
+      expect.objectContaining({ 
+        method: 'GET',
+        rawResponse: true
+      })
+    );
+  });
+
+  it('should handle upload-file operations with content and contentType', async () => {
+    await testRegisterDynamicTools(mockServer, mockGraphClient, MOCK_OPENAPI_SPEC);
+
+    // Register the handler manually
+    registeredTools['upload-file'] = { 
+      handler: async (params) => {
+        const options = {
+          method: 'PUT',
+          body: params.content,
+          headers: {
+            'Content-Type': params.contentType || 'application/octet-stream'
+          }
+        };
+        return mockGraphClient.graphRequest(`/me/drive/root:/${params.path}:/content`, options);
+      }
+    };
+
+    const uploadFileHandler = registeredTools['upload-file'].handler;
+    await uploadFileHandler.call(null, { 
+      'path': '/Documents/file.docx',
+      'content': 'file content',
+      'contentType': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document'
+    });
+
+    expect(mockGraphClient.graphRequest).toHaveBeenCalledWith(
+      '/me/drive/root://Documents/file.docx:/content',
+      expect.objectContaining({ 
+        method: 'PUT',
+        body: 'file content',
+        headers: {
+          'Content-Type': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document'
+        }
+      })
+    );
+  });
+
+  it('should use default content type for upload-file if not specified', async () => {
+    await testRegisterDynamicTools(mockServer, mockGraphClient, MOCK_OPENAPI_SPEC);
+
+    // Register the handler manually
+    registeredTools['upload-file'] = { 
+      handler: async (params) => {
+        const options = {
+          method: 'PUT',
+          body: params.content,
+          headers: {
+            'Content-Type': params.contentType || 'application/octet-stream'
+          }
+        };
+        return mockGraphClient.graphRequest(`/me/drive/root:/${params.path}:/content`, options);
+      }
+    };
+
+    const uploadFileHandler = registeredTools['upload-file'].handler;
+    await uploadFileHandler.call(null, { 
+      'path': '/Documents/file.bin',
+      'content': 'binary content'
+    });
+
+    expect(mockGraphClient.graphRequest).toHaveBeenCalledWith(
+      '/me/drive/root://Documents/file.bin:/content',
+      expect.objectContaining({ 
+        method: 'PUT',
+        body: 'binary content',
+        headers: {
+          'Content-Type': 'application/octet-stream'
+        }
+      })
+    );
+  });
+
+  it('should handle create-folder operations with name and description', async () => {
+    await testRegisterDynamicTools(mockServer, mockGraphClient, MOCK_OPENAPI_SPEC);
+
+    // Register the handler manually
+    registeredTools['create-folder'] = { 
+      handler: async (params) => {
+        const options = {
+          method: 'POST',
+          body: JSON.stringify({
+            name: params.name,
+            folder: {},
+            '@microsoft.graph.conflictBehavior': 'rename',
+            ...(params.description && { description: params.description })
+          }),
+          headers: {
+            'Content-Type': 'application/json'
+          }
+        };
+        return mockGraphClient.graphRequest('/me/drive/root/children', options);
+      }
+    };
+
+    const createFolderHandler = registeredTools['create-folder'].handler;
+    await createFolderHandler.call(null, { 
+      'name': 'New Folder',
+      'description': 'This is a new folder'
+    });
+
+    expect(mockGraphClient.graphRequest).toHaveBeenCalledWith(
+      '/me/drive/root/children',
+      expect.objectContaining({ 
+        method: 'POST',
+        body: JSON.stringify({
+          name: 'New Folder',
+          folder: {},
+          '@microsoft.graph.conflictBehavior': 'rename',
+          description: 'This is a new folder'
+        }),
+        headers: {
+          'Content-Type': 'application/json'
+        }
+      })
+    );
+  });
+
+  it('should handle create-folder operations with name only', async () => {
+    await testRegisterDynamicTools(mockServer, mockGraphClient, MOCK_OPENAPI_SPEC);
+
+    // Register the handler manually
+    registeredTools['create-folder'] = { 
+      handler: async (params) => {
+        const options = {
+          method: 'POST',
+          body: JSON.stringify({
+            name: params.name,
+            folder: {},
+            '@microsoft.graph.conflictBehavior': 'rename',
+            ...(params.description && { description: params.description })
+          }),
+          headers: {
+            'Content-Type': 'application/json'
+          }
+        };
+        return mockGraphClient.graphRequest('/me/drive/root/children', options);
+      }
+    };
+
+    const createFolderHandler = registeredTools['create-folder'].handler;
+    await createFolderHandler.call(null, { 
+      'name': 'New Folder'
+    });
+
+    expect(mockGraphClient.graphRequest).toHaveBeenCalledWith(
+      '/me/drive/root/children',
+      expect.objectContaining({ 
+        method: 'POST',
+        body: JSON.stringify({
+          name: 'New Folder',
+          folder: {},
+          '@microsoft.graph.conflictBehavior': 'rename'
+        }),
+        headers: {
+          'Content-Type': 'application/json'
+        }
+      })
+    );
+  });
+});