@modelcontextprotocol/server-everything 2026.1.26 → 2026.7.4

package/README.md

@@ -31,9 +31,27 @@ Add to your `claude_desktop_config.json`:
 }
 ```
 
+On Windows, use `cmd /c` to launch `npx`:
+
+```json
+{
+  "mcpServers": {
+    "everything": {
+      "command": "cmd",
+      "args": [
+        "/c",
+        "npx",
+        "-y",
+        "@modelcontextprotocol/server-everything"
+      ]
+    }
+  }
+}
+```
+
 ## Usage with VS Code
 
-For quick installation, use of of the one-click install buttons below...
+For quick installation, use one of the one-click install buttons below...
 
 [![Install with NPX in VS Code](https://img.shields.io/badge/VS_Code-NPM-0098FF?style=flat-square&logo=visualstudiocode&logoColor=white)](https://insiders.vscode.dev/redirect/mcp/install?name=everything&config=%7B%22command%22%3A%22npx%22%2C%22args%22%3A%5B%22-y%22%2C%22%40modelcontextprotocol%2Fserver-everything%22%5D%7D) [![Install with NPX in VS Code Insiders](https://img.shields.io/badge/VS_Code_Insiders-NPM-24bfa5?style=flat-square&logo=visualstudiocode&logoColor=white)](https://insiders.vscode.dev/redirect/mcp/install?name=everything&config=%7B%22command%22%3A%22npx%22%2C%22args%22%3A%5B%22-y%22%2C%22%40modelcontextprotocol%2Fserver-everything%22%5D%7D&quality=insiders)
 
@@ -62,6 +80,19 @@ Alternatively, you can add the configuration to a file called `.vscode/mcp.json`
 }
 ```
 
+On Windows, use:
+
+```json
+{
+  "servers": {
+    "everything": {
+      "command": "cmd",
+      "args": ["/c", "npx", "-y", "@modelcontextprotocol/server-everything"]
+    }
+  }
+}
+```
+
 ## Running from source with [HTTP+SSE Transport](https://modelcontextprotocol.io/specification/2024-11-05/basic/transports#http-with-sse) (deprecated as of [2025-03-26](https://modelcontextprotocol.io/specification/2025-03-26/basic/transports))
 
 ```shell
@@ -104,3 +135,6 @@ npx @modelcontextprotocol/server-everything sse
 npx @modelcontextprotocol/server-everything streamableHttp
 ```
 
+## License
+
+This MCP server is licensed under the MIT License. This means you are free to use, modify, and distribute the software, subject to the terms and conditions of the MIT License. For more details, please see the LICENSE file in the project repository.

package/dist/__tests__/prompts.test.js

@@ -0,0 +1,131 @@
+import { describe, it, expect, vi } from 'vitest';
+import { registerSimplePrompt } from '../prompts/simple.js';
+import { registerArgumentsPrompt } from '../prompts/args.js';
+import { registerPromptWithCompletions } from '../prompts/completions.js';
+import { registerEmbeddedResourcePrompt } from '../prompts/resource.js';
+// Helper to capture registered prompt handlers
+function createMockServer() {
+    const handlers = new Map();
+    const configs = new Map();
+    const mockServer = {
+        registerPrompt: vi.fn((name, config, handler) => {
+            handlers.set(name, handler);
+            configs.set(name, config);
+        }),
+    };
+    return { mockServer, handlers, configs };
+}
+describe('Prompts', () => {
+    describe('simple-prompt', () => {
+        it('should return fixed message with no arguments', () => {
+            const { mockServer, handlers } = createMockServer();
+            registerSimplePrompt(mockServer);
+            const handler = handlers.get('simple-prompt');
+            const result = handler();
+            expect(result).toEqual({
+                messages: [
+                    {
+                        role: 'user',
+                        content: {
+                            type: 'text',
+                            text: 'This is a simple prompt without arguments.',
+                        },
+                    },
+                ],
+            });
+        });
+    });
+    describe('args-prompt', () => {
+        it('should include city in message', () => {
+            const { mockServer, handlers } = createMockServer();
+            registerArgumentsPrompt(mockServer);
+            const handler = handlers.get('args-prompt');
+            const result = handler({ city: 'San Francisco' });
+            expect(result.messages[0].content.text).toBe("What's weather in San Francisco?");
+        });
+        it('should include city and state in message', () => {
+            const { mockServer, handlers } = createMockServer();
+            registerArgumentsPrompt(mockServer);
+            const handler = handlers.get('args-prompt');
+            const result = handler({ city: 'San Francisco', state: 'California' });
+            expect(result.messages[0].content.text).toBe("What's weather in San Francisco, California?");
+        });
+        it('should handle city only (optional state omitted)', () => {
+            const { mockServer, handlers } = createMockServer();
+            registerArgumentsPrompt(mockServer);
+            const handler = handlers.get('args-prompt');
+            const result = handler({ city: 'New York' });
+            expect(result.messages[0].content.text).toBe("What's weather in New York?");
+            expect(result.messages[0].content.text).not.toContain(',');
+            expect(result.messages[0].role).toBe('user');
+            expect(result.messages[0].content.type).toBe('text');
+        });
+    });
+    describe('completable-prompt', () => {
+        it('should generate promotion message with department and name', () => {
+            const { mockServer, handlers } = createMockServer();
+            registerPromptWithCompletions(mockServer);
+            const handler = handlers.get('completable-prompt');
+            const result = handler({ department: 'Engineering', name: 'Alice' });
+            expect(result.messages[0].content.text).toBe('Please promote Alice to the head of the Engineering team.');
+        });
+        it('should work with different departments', () => {
+            const { mockServer, handlers } = createMockServer();
+            registerPromptWithCompletions(mockServer);
+            const handler = handlers.get('completable-prompt');
+            const salesResult = handler({ department: 'Sales', name: 'David' });
+            expect(salesResult.messages[0].content.text).toContain('Sales');
+            expect(salesResult.messages[0].content.text).toContain('David');
+            expect(salesResult.messages[0].role).toBe('user');
+            const marketingResult = handler({ department: 'Marketing', name: 'Grace' });
+            expect(marketingResult.messages[0].content.text).toContain('Marketing');
+            expect(marketingResult.messages[0].content.text).toContain('Grace');
+        });
+    });
+    describe('resource-prompt', () => {
+        it('should return text resource reference', () => {
+            const { mockServer, handlers } = createMockServer();
+            registerEmbeddedResourcePrompt(mockServer);
+            const handler = handlers.get('resource-prompt');
+            const result = handler({ resourceType: 'Text', resourceId: '1' });
+            expect(result.messages).toHaveLength(2);
+            expect(result.messages[0].content.text).toContain('Text');
+            expect(result.messages[0].content.text).toContain('1');
+            expect(result.messages[1].content.type).toBe('resource');
+            expect(result.messages[1].content.resource.uri).toContain('text/1');
+        });
+        it('should return blob resource reference', () => {
+            const { mockServer, handlers } = createMockServer();
+            registerEmbeddedResourcePrompt(mockServer);
+            const handler = handlers.get('resource-prompt');
+            const result = handler({ resourceType: 'Blob', resourceId: '5' });
+            expect(result.messages[0].content.text).toContain('Blob');
+            expect(result.messages[1].content.resource.uri).toContain('blob/5');
+        });
+        it('should reject invalid resource type', () => {
+            const { mockServer, handlers } = createMockServer();
+            registerEmbeddedResourcePrompt(mockServer);
+            const handler = handlers.get('resource-prompt');
+            expect(() => handler({ resourceType: 'Invalid', resourceId: '1' })).toThrow('Invalid resourceType');
+        });
+        it('should reject invalid resource ID', () => {
+            const { mockServer, handlers } = createMockServer();
+            registerEmbeddedResourcePrompt(mockServer);
+            const handler = handlers.get('resource-prompt');
+            expect(() => handler({ resourceType: 'Text', resourceId: '-1' })).toThrow('Invalid resourceId');
+            expect(() => handler({ resourceType: 'Text', resourceId: '0' })).toThrow('Invalid resourceId');
+            expect(() => handler({ resourceType: 'Text', resourceId: 'abc' })).toThrow('Invalid resourceId');
+        });
+        it('should include both intro text and resource messages', () => {
+            const { mockServer, handlers } = createMockServer();
+            registerEmbeddedResourcePrompt(mockServer);
+            const handler = handlers.get('resource-prompt');
+            const result = handler({ resourceType: 'Text', resourceId: '3' });
+            expect(result.messages).toHaveLength(2);
+            expect(result.messages[0].role).toBe('user');
+            expect(result.messages[0].content.type).toBe('text');
+            expect(result.messages[1].role).toBe('user');
+            expect(result.messages[1].content.type).toBe('resource');
+        });
+    });
+});

package/dist/__tests__/registrations.test.js

@@ -0,0 +1,121 @@
+import { describe, it, expect, vi } from 'vitest';
+// Create mock server
+function createMockServer() {
+    return {
+        registerTool: vi.fn(),
+        registerPrompt: vi.fn(),
+        registerResource: vi.fn(),
+        server: {
+            getClientCapabilities: vi.fn(() => ({})),
+            setRequestHandler: vi.fn(),
+        },
+        sendLoggingMessage: vi.fn(),
+        sendResourceUpdated: vi.fn(),
+    };
+}
+describe('Registration Index Files', () => {
+    describe('tools/index.ts', () => {
+        it('should register all standard tools', async () => {
+            const { registerTools } = await import('../tools/index.js');
+            const mockServer = createMockServer();
+            registerTools(mockServer);
+            // Should register 12 standard tools (non-conditional)
+            expect(mockServer.registerTool).toHaveBeenCalledTimes(12);
+            // Verify specific tools are registered
+            const registeredTools = mockServer.registerTool.mock.calls.map((call) => call[0]);
+            expect(registeredTools).toContain('echo');
+            expect(registeredTools).toContain('get-sum');
+            expect(registeredTools).toContain('get-env');
+            expect(registeredTools).toContain('get-tiny-image');
+            expect(registeredTools).toContain('get-structured-content');
+            expect(registeredTools).toContain('get-annotated-message');
+            expect(registeredTools).toContain('trigger-long-running-operation');
+            expect(registeredTools).toContain('get-resource-links');
+            expect(registeredTools).toContain('get-resource-reference');
+            expect(registeredTools).toContain('gzip-file-as-resource');
+            expect(registeredTools).toContain('toggle-simulated-logging');
+            expect(registeredTools).toContain('toggle-subscriber-updates');
+        });
+        it('should register conditional tools based on capabilities', async () => {
+            const { registerConditionalTools } = await import('../tools/index.js');
+            // Server with all capabilities including experimental tasks API
+            const mockServerWithCapabilities = {
+                registerTool: vi.fn(),
+                server: {
+                    getClientCapabilities: vi.fn(() => ({
+                        roots: {},
+                        elicitation: { url: {} },
+                        sampling: {},
+                    })),
+                },
+                experimental: {
+                    tasks: {
+                        registerToolTask: vi.fn(),
+                    },
+                },
+            };
+            registerConditionalTools(mockServerWithCapabilities);
+            // Should register 4 conditional tools via registerTool when all capabilities
+            // are present. Task-based tools register via registerToolTask (counted separately),
+            // so they are not included in this registerTool count.
+            expect(mockServerWithCapabilities.registerTool).toHaveBeenCalledTimes(4);
+            const registeredTools = mockServerWithCapabilities.registerTool.mock.calls.map((call) => call[0]);
+            expect(registeredTools).toContain('get-roots-list');
+            expect(registeredTools).toContain('trigger-elicitation-request');
+            expect(registeredTools).toContain('trigger-url-elicitation');
+            expect(registeredTools).toContain('trigger-sampling-request');
+            // Task-based tools are registered via experimental.tasks.registerToolTask
+            expect(mockServerWithCapabilities.experimental.tasks.registerToolTask).toHaveBeenCalled();
+        });
+        it('should not register conditional tools when capabilities missing', async () => {
+            const { registerConditionalTools } = await import('../tools/index.js');
+            const mockServerNoCapabilities = {
+                registerTool: vi.fn(),
+                server: {
+                    getClientCapabilities: vi.fn(() => ({})),
+                },
+                experimental: {
+                    tasks: {
+                        registerToolTask: vi.fn(),
+                    },
+                },
+            };
+            registerConditionalTools(mockServerNoCapabilities);
+            // Should not register any capability-gated tools when capabilities are missing
+            expect(mockServerNoCapabilities.registerTool).not.toHaveBeenCalled();
+        });
+    });
+    describe('prompts/index.ts', () => {
+        it('should register all prompts', async () => {
+            const { registerPrompts } = await import('../prompts/index.js');
+            const mockServer = createMockServer();
+            registerPrompts(mockServer);
+            // Should register 4 prompts
+            expect(mockServer.registerPrompt).toHaveBeenCalledTimes(4);
+            const registeredPrompts = mockServer.registerPrompt.mock.calls.map((call) => call[0]);
+            expect(registeredPrompts).toContain('simple-prompt');
+            expect(registeredPrompts).toContain('args-prompt');
+            expect(registeredPrompts).toContain('completable-prompt');
+            expect(registeredPrompts).toContain('resource-prompt');
+        });
+    });
+    describe('resources/index.ts', () => {
+        it('should register resource templates', async () => {
+            const { registerResources } = await import('../resources/index.js');
+            const mockServer = createMockServer();
+            registerResources(mockServer);
+            // Should register at least the 2 resource templates (text and blob) plus file resources
+            expect(mockServer.registerResource).toHaveBeenCalled();
+            const registeredResources = mockServer.registerResource.mock.calls.map((call) => call[0]);
+            expect(registeredResources).toContain('Dynamic Text Resource');
+            expect(registeredResources).toContain('Dynamic Blob Resource');
+        });
+        it('should read instructions from file', async () => {
+            const { readInstructions } = await import('../resources/index.js');
+            const instructions = readInstructions();
+            // Should return a string (either content or error message)
+            expect(typeof instructions).toBe('string');
+            expect(instructions.length).toBeGreaterThan(0);
+        });
+    });
+});

package/dist/__tests__/resources.test.js

@@ -0,0 +1,240 @@
+import { describe, it, expect, vi, afterEach } from 'vitest';
+import { ResourceTemplate } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { textResource, blobResource, textResourceUri, blobResourceUri, RESOURCE_TYPE_TEXT, RESOURCE_TYPE_BLOB, RESOURCE_TYPES, resourceTypeCompleter, resourceIdForPromptCompleter, resourceIdForResourceTemplateCompleter, registerResourceTemplates, } from '../resources/templates.js';
+import { getSessionResourceURI, registerSessionResource, } from '../resources/session.js';
+import { registerFileResources } from '../resources/files.js';
+import { setSubscriptionHandlers, beginSimulatedResourceUpdates, stopSimulatedResourceUpdates, } from '../resources/subscriptions.js';
+describe('Resource Templates', () => {
+    describe('Constants', () => {
+        it('should include both types in RESOURCE_TYPES array', () => {
+            expect(RESOURCE_TYPES).toContain(RESOURCE_TYPE_TEXT);
+            expect(RESOURCE_TYPES).toContain(RESOURCE_TYPE_BLOB);
+            expect(RESOURCE_TYPES).toHaveLength(2);
+        });
+    });
+    describe('textResourceUri', () => {
+        it('should create URL for text resource', () => {
+            const uri = textResourceUri(1);
+            expect(uri.toString()).toBe('demo://resource/dynamic/text/1');
+        });
+        it('should handle different resource IDs', () => {
+            expect(textResourceUri(5).toString()).toBe('demo://resource/dynamic/text/5');
+            expect(textResourceUri(100).toString()).toBe('demo://resource/dynamic/text/100');
+        });
+    });
+    describe('blobResourceUri', () => {
+        it('should create URL for blob resource', () => {
+            const uri = blobResourceUri(1);
+            expect(uri.toString()).toBe('demo://resource/dynamic/blob/1');
+        });
+        it('should handle different resource IDs', () => {
+            expect(blobResourceUri(5).toString()).toBe('demo://resource/dynamic/blob/5');
+            expect(blobResourceUri(100).toString()).toBe('demo://resource/dynamic/blob/100');
+        });
+    });
+    describe('textResource', () => {
+        it('should create text resource with correct structure', () => {
+            const uri = textResourceUri(1);
+            const resource = textResource(uri, 1);
+            expect(resource.uri).toBe(uri.toString());
+            expect(resource.mimeType).toBe('text/plain');
+            expect(resource.text).toContain('Resource 1');
+            expect(resource.text).toContain('plaintext');
+        });
+        it('should include timestamp in content', () => {
+            const uri = textResourceUri(2);
+            const resource = textResource(uri, 2);
+            // Timestamp format varies, just check it contains time-related content
+            expect(resource.text).toMatch(/\d/);
+        });
+    });
+    describe('blobResource', () => {
+        it('should create blob resource with correct structure', () => {
+            const uri = blobResourceUri(1);
+            const resource = blobResource(uri, 1);
+            expect(resource.uri).toBe(uri.toString());
+            expect(resource.mimeType).toBe('text/plain');
+            expect(resource.blob).toBeDefined();
+        });
+        it('should create valid base64 encoded content', () => {
+            const uri = blobResourceUri(3);
+            const resource = blobResource(uri, 3);
+            // Decode and verify content
+            const decoded = Buffer.from(resource.blob, 'base64').toString();
+            expect(decoded).toContain('Resource 3');
+            expect(decoded).toContain('base64 blob');
+        });
+    });
+    describe('resourceTypeCompleter', () => {
+        it('should be defined as a completable schema', () => {
+            // The completer is a zod schema wrapped with completable
+            expect(resourceTypeCompleter).toBeDefined();
+            // It should have the zod parse method
+            expect(typeof resourceTypeCompleter.parse).toBe('function');
+        });
+        it('should validate string resource types', () => {
+            // Test that valid strings pass validation
+            expect(() => resourceTypeCompleter.parse('Text')).not.toThrow();
+            expect(() => resourceTypeCompleter.parse('Blob')).not.toThrow();
+        });
+    });
+    describe('resourceIdForPromptCompleter', () => {
+        it('should be defined as a completable schema', () => {
+            expect(resourceIdForPromptCompleter).toBeDefined();
+            expect(typeof resourceIdForPromptCompleter.parse).toBe('function');
+        });
+        it('should validate string IDs', () => {
+            // Test that valid strings pass validation
+            expect(() => resourceIdForPromptCompleter.parse('1')).not.toThrow();
+            expect(() => resourceIdForPromptCompleter.parse('100')).not.toThrow();
+        });
+    });
+    describe('resourceIdForResourceTemplateCompleter', () => {
+        it('should validate positive integer IDs', () => {
+            expect(resourceIdForResourceTemplateCompleter('1')).toEqual(['1']);
+            expect(resourceIdForResourceTemplateCompleter('50')).toEqual(['50']);
+        });
+        it('should reject invalid IDs', () => {
+            expect(resourceIdForResourceTemplateCompleter('0')).toEqual([]);
+            expect(resourceIdForResourceTemplateCompleter('-5')).toEqual([]);
+            expect(resourceIdForResourceTemplateCompleter('not-a-number')).toEqual([]);
+        });
+    });
+    describe('registerResourceTemplates', () => {
+        it('should register text and blob resource templates', () => {
+            const registeredResources = [];
+            const mockServer = {
+                registerResource: vi.fn((...args) => {
+                    registeredResources.push(args);
+                }),
+            };
+            registerResourceTemplates(mockServer);
+            expect(mockServer.registerResource).toHaveBeenCalledTimes(2);
+            // Check text resource registration
+            const textRegistration = registeredResources.find((r) => r[0].includes('Text'));
+            expect(textRegistration).toBeDefined();
+            expect(textRegistration[1]).toBeInstanceOf(ResourceTemplate);
+            // Check blob resource registration
+            const blobRegistration = registeredResources.find((r) => r[0].includes('Blob'));
+            expect(blobRegistration).toBeDefined();
+        });
+    });
+});
+describe('Session Resources', () => {
+    describe('getSessionResourceURI', () => {
+        it('should generate correct URI for resource name', () => {
+            expect(getSessionResourceURI('test')).toBe('demo://resource/session/test');
+        });
+        it('should handle various resource names', () => {
+            expect(getSessionResourceURI('my-file')).toBe('demo://resource/session/my-file');
+            expect(getSessionResourceURI('document_123')).toBe('demo://resource/session/document_123');
+        });
+    });
+    describe('registerSessionResource', () => {
+        it('should register text resource and return resource link', () => {
+            const registrations = [];
+            const mockServer = {
+                registerResource: vi.fn((...args) => {
+                    registrations.push(args);
+                }),
+            };
+            const resource = {
+                uri: 'demo://resource/session/test-file',
+                name: 'test-file',
+                mimeType: 'text/plain',
+                description: 'A test file',
+            };
+            const result = registerSessionResource(mockServer, resource, 'text', 'Hello, World!');
+            expect(result.type).toBe('resource_link');
+            expect(result.uri).toBe(resource.uri);
+            expect(result.name).toBe(resource.name);
+            expect(mockServer.registerResource).toHaveBeenCalledWith('test-file', 'demo://resource/session/test-file', expect.objectContaining({
+                mimeType: 'text/plain',
+                description: 'A test file',
+            }), expect.any(Function));
+        });
+        it('should register blob resource correctly', () => {
+            const mockServer = {
+                registerResource: vi.fn(),
+            };
+            const resource = {
+                uri: 'demo://resource/session/binary-file',
+                name: 'binary-file',
+                mimeType: 'application/octet-stream',
+            };
+            const blobContent = Buffer.from('binary data').toString('base64');
+            const result = registerSessionResource(mockServer, resource, 'blob', blobContent);
+            expect(result.type).toBe('resource_link');
+            expect(mockServer.registerResource).toHaveBeenCalled();
+        });
+        it('should return resource handler that provides correct content', async () => {
+            let capturedHandler = null;
+            const mockServer = {
+                registerResource: vi.fn((_name, _uri, _config, handler) => {
+                    capturedHandler = handler;
+                }),
+            };
+            const resource = {
+                uri: 'demo://resource/session/content-test',
+                name: 'content-test',
+                mimeType: 'text/plain',
+            };
+            registerSessionResource(mockServer, resource, 'text', 'Test content here');
+            expect(capturedHandler).not.toBeNull();
+            const handlerResult = await capturedHandler(new URL(resource.uri));
+            expect(handlerResult.contents).toHaveLength(1);
+            expect(handlerResult.contents[0].text).toBe('Test content here');
+            expect(handlerResult.contents[0].mimeType).toBe('text/plain');
+        });
+    });
+});
+describe('File Resources', () => {
+    describe('registerFileResources', () => {
+        it('should register file resources when docs directory exists', () => {
+            const mockServer = {
+                registerResource: vi.fn(),
+            };
+            registerFileResources(mockServer);
+            // The docs folder exists in the everything server and contains files
+            // so registerResource should have been called
+            expect(mockServer.registerResource).toHaveBeenCalled();
+        });
+    });
+});
+describe('Subscriptions', () => {
+    describe('setSubscriptionHandlers', () => {
+        it('should set request handlers on server', () => {
+            const mockServer = {
+                server: {
+                    setRequestHandler: vi.fn(),
+                },
+                sendLoggingMessage: vi.fn(),
+            };
+            setSubscriptionHandlers(mockServer);
+            // Should set both subscribe and unsubscribe handlers
+            expect(mockServer.server.setRequestHandler).toHaveBeenCalledTimes(2);
+        });
+    });
+    describe('simulated resource updates lifecycle', () => {
+        afterEach(() => {
+            // Clean up any intervals
+            stopSimulatedResourceUpdates('lifecycle-test-session');
+        });
+        it('should start and stop updates without errors', () => {
+            const mockServer = {
+                server: {
+                    notification: vi.fn(),
+                },
+            };
+            // Start updates - should work for both defined and undefined sessionId
+            beginSimulatedResourceUpdates(mockServer, 'lifecycle-test-session');
+            beginSimulatedResourceUpdates(mockServer, undefined);
+            // Stop updates - should handle all cases gracefully
+            stopSimulatedResourceUpdates('lifecycle-test-session');
+            stopSimulatedResourceUpdates('non-existent-session');
+            stopSimulatedResourceUpdates(undefined);
+            // If we got here without throwing, the lifecycle works correctly
+            expect(true).toBe(true);
+        });
+    });
+});

package/dist/__tests__/server.test.js

@@ -0,0 +1,31 @@
+import { describe, it, expect } from 'vitest';
+import { createServer } from '../server/index.js';
+describe('Server Factory', () => {
+    describe('createServer', () => {
+        it('should return a ServerFactoryResponse object', () => {
+            const result = createServer();
+            expect(result).toHaveProperty('server');
+            expect(result).toHaveProperty('cleanup');
+        });
+        it('should return a cleanup function', () => {
+            const { cleanup } = createServer();
+            expect(typeof cleanup).toBe('function');
+        });
+        it('should create an McpServer instance', () => {
+            const { server } = createServer();
+            expect(server).toBeDefined();
+            expect(server.server).toBeDefined();
+        });
+        it('should have an oninitialized handler set', () => {
+            const { server } = createServer();
+            expect(server.server.oninitialized).toBeDefined();
+        });
+        it('should allow multiple servers to be created', () => {
+            const result1 = createServer();
+            const result2 = createServer();
+            expect(result1.server).toBeDefined();
+            expect(result2.server).toBeDefined();
+            expect(result1.server).not.toBe(result2.server);
+        });
+    });
+});