Merge pull request #3236 from nielskaspers/add-everything-server-tests

Add Vitest tests for Everything Server

package-lock.json

@@ -3806,9 +3806,11 @@
       "devDependencies": {
         "@types/cors": "^2.8.19",
         "@types/express": "^5.0.6",
+        "@vitest/coverage-v8": "^2.1.8",
         "prettier": "^2.8.8",
         "shx": "^0.3.4",
-        "typescript": "^5.6.2"
+        "typescript": "^5.6.2",
+        "vitest": "^2.1.8"
       }
     },
     "src/filesystem": {

src/everything/__tests__/prompts.test.ts

@@ -0,0 +1,179 @@
+import { describe, it, expect, vi } from 'vitest';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+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: Map<string, Function> = new Map();
+  const configs: Map<string, any> = new Map();
+
+  const mockServer = {
+    registerPrompt: vi.fn((name: string, config: any, handler: Function) => {
+      handlers.set(name, handler);
+      configs.set(name, config);
+    }),
+  } as unknown as McpServer;
+
+  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');
+    });
+  });
+});

src/everything/__tests__/registrations.test.ts

@@ -0,0 +1,152 @@
+import { describe, it, expect, vi } from 'vitest';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+
+// 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(),
+  } as unknown as McpServer;
+}
+
+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 as any).mock.calls.map(
+        (call: any[]) => 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: {},
+            sampling: {},
+          })),
+        },
+        experimental: {
+          tasks: {
+            registerToolTask: vi.fn(),
+          },
+        },
+      } as unknown as McpServer;
+
+      registerConditionalTools(mockServerWithCapabilities);
+
+      // Should register 3 conditional tools + 3 task-based tools when all capabilities present
+      expect(mockServerWithCapabilities.registerTool).toHaveBeenCalledTimes(3);
+
+      const registeredTools = (
+        mockServerWithCapabilities.registerTool as any
+      ).mock.calls.map((call: any[]) => call[0]);
+      expect(registeredTools).toContain('get-roots-list');
+      expect(registeredTools).toContain('trigger-elicitation-request');
+      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(),
+          },
+        },
+      } as unknown as McpServer;
+
+      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 as any).mock.calls.map(
+        (call: any[]) => 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 as any).mock.calls.map(
+        (call: any[]) => 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);
+    });
+  });
+});

src/everything/__tests__/resources.test.ts

@@ -0,0 +1,327 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { McpServer, 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 as any).parse).toBe('function');
+    });
+
+    it('should validate string resource types', () => {
+      // Test that valid strings pass validation
+      expect(() => (resourceTypeCompleter as any).parse('Text')).not.toThrow();
+      expect(() => (resourceTypeCompleter as any).parse('Blob')).not.toThrow();
+    });
+  });
+
+  describe('resourceIdForPromptCompleter', () => {
+    it('should be defined as a completable schema', () => {
+      expect(resourceIdForPromptCompleter).toBeDefined();
+      expect(typeof (resourceIdForPromptCompleter as any).parse).toBe('function');
+    });
+
+    it('should validate string IDs', () => {
+      // Test that valid strings pass validation
+      expect(() => (resourceIdForPromptCompleter as any).parse('1')).not.toThrow();
+      expect(() => (resourceIdForPromptCompleter as any).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: any[] = [];
+
+      const mockServer = {
+        registerResource: vi.fn((...args) => {
+          registeredResources.push(args);
+        }),
+      } as unknown as McpServer;
+
+      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: any[] = [];
+      const mockServer = {
+        registerResource: vi.fn((...args) => {
+          registrations.push(args);
+        }),
+      } as unknown as McpServer;
+
+      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(),
+      } as unknown as McpServer;
+
+      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: Function | null = null;
+      const mockServer = {
+        registerResource: vi.fn((_name, _uri, _config, handler) => {
+          capturedHandler = handler;
+        }),
+      } as unknown as McpServer;
+
+      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(),
+      } as unknown as McpServer;
+
+      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(),
+      } as unknown as McpServer;
+
+      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(),
+        },
+      } as unknown as McpServer;
+
+      // 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);
+    });
+  });
+});

src/everything/__tests__/server.test.ts

@@ -0,0 +1,41 @@
+import { describe, it, expect, vi } 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);
+    });
+  });
+});

src/everything/__tests__/tools.test.ts

@@ -0,0 +1,820 @@
+import { describe, it, expect, vi } from 'vitest';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { registerEchoTool, EchoSchema } from '../tools/echo.js';
+import { registerGetSumTool } from '../tools/get-sum.js';
+import { registerGetEnvTool } from '../tools/get-env.js';
+import { registerGetTinyImageTool, MCP_TINY_IMAGE } from '../tools/get-tiny-image.js';
+import { registerGetStructuredContentTool } from '../tools/get-structured-content.js';
+import { registerGetAnnotatedMessageTool } from '../tools/get-annotated-message.js';
+import { registerTriggerLongRunningOperationTool } from '../tools/trigger-long-running-operation.js';
+import { registerGetResourceLinksTool } from '../tools/get-resource-links.js';
+import { registerGetResourceReferenceTool } from '../tools/get-resource-reference.js';
+import { registerToggleSimulatedLoggingTool } from '../tools/toggle-simulated-logging.js';
+import { registerToggleSubscriberUpdatesTool } from '../tools/toggle-subscriber-updates.js';
+import { registerTriggerSamplingRequestTool } from '../tools/trigger-sampling-request.js';
+import { registerTriggerElicitationRequestTool } from '../tools/trigger-elicitation-request.js';
+import { registerGetRootsListTool } from '../tools/get-roots-list.js';
+import { registerGZipFileAsResourceTool } from '../tools/gzip-file-as-resource.js';
+
+// Helper to capture registered tool handlers
+function createMockServer() {
+  const handlers: Map<string, Function> = new Map();
+  const configs: Map<string, any> = new Map();
+
+  const mockServer = {
+    registerTool: vi.fn((name: string, config: any, handler: Function) => {
+      handlers.set(name, handler);
+      configs.set(name, config);
+    }),
+    server: {
+      getClientCapabilities: vi.fn(() => ({})),
+      notification: vi.fn(),
+    },
+    sendLoggingMessage: vi.fn(),
+    sendResourceUpdated: vi.fn(),
+  } as unknown as McpServer;
+
+  return { mockServer, handlers, configs };
+}
+
+describe('Tools', () => {
+  describe('echo', () => {
+    it('should echo back the message', async () => {
+      const { mockServer, handlers } = createMockServer();
+      registerEchoTool(mockServer);
+
+      const handler = handlers.get('echo')!;
+      const result = await handler({ message: 'Hello, World!' });
+
+      expect(result).toEqual({
+        content: [{ type: 'text', text: 'Echo: Hello, World!' }],
+      });
+    });
+
+    it('should handle empty message', async () => {
+      const { mockServer, handlers } = createMockServer();
+      registerEchoTool(mockServer);
+
+      const handler = handlers.get('echo')!;
+      const result = await handler({ message: '' });
+
+      expect(result).toEqual({
+        content: [{ type: 'text', text: 'Echo: ' }],
+      });
+    });
+
+    it('should reject invalid input', async () => {
+      const { mockServer, handlers } = createMockServer();
+      registerEchoTool(mockServer);
+
+      const handler = handlers.get('echo')!;
+
+      await expect(handler({})).rejects.toThrow();
+      await expect(handler({ message: 123 })).rejects.toThrow();
+    });
+  });
+
+  describe('EchoSchema', () => {
+    it('should validate correct input', () => {
+      const result = EchoSchema.parse({ message: 'test' });
+      expect(result).toEqual({ message: 'test' });
+    });
+
+    it('should reject missing message', () => {
+      expect(() => EchoSchema.parse({})).toThrow();
+    });
+
+    it('should reject non-string message', () => {
+      expect(() => EchoSchema.parse({ message: 123 })).toThrow();
+    });
+  });
+
+  describe('get-sum', () => {
+    it('should calculate sum of two positive numbers', async () => {
+      const { mockServer, handlers } = createMockServer();
+      registerGetSumTool(mockServer);
+
+      const handler = handlers.get('get-sum')!;
+      const result = await handler({ a: 5, b: 3 });
+
+      expect(result).toEqual({
+        content: [{ type: 'text', text: 'The sum of 5 and 3 is 8.' }],
+      });
+    });
+
+    it('should calculate sum with negative numbers', async () => {
+      const { mockServer, handlers } = createMockServer();
+      registerGetSumTool(mockServer);
+
+      const handler = handlers.get('get-sum')!;
+      const result = await handler({ a: -5, b: 3 });
+
+      expect(result).toEqual({
+        content: [{ type: 'text', text: 'The sum of -5 and 3 is -2.' }],
+      });
+    });
+
+    it('should calculate sum with zero', async () => {
+      const { mockServer, handlers } = createMockServer();
+      registerGetSumTool(mockServer);
+
+      const handler = handlers.get('get-sum')!;
+      const result = await handler({ a: 0, b: 0 });
+
+      expect(result).toEqual({
+        content: [{ type: 'text', text: 'The sum of 0 and 0 is 0.' }],
+      });
+    });
+
+    it('should handle floating point numbers', async () => {
+      const { mockServer, handlers } = createMockServer();
+      registerGetSumTool(mockServer);
+
+      const handler = handlers.get('get-sum')!;
+      const result = await handler({ a: 1.5, b: 2.5 });
+
+      expect(result).toEqual({
+        content: [{ type: 'text', text: 'The sum of 1.5 and 2.5 is 4.' }],
+      });
+    });
+
+    it('should reject invalid input', async () => {
+      const { mockServer, handlers } = createMockServer();
+      registerGetSumTool(mockServer);
+
+      const handler = handlers.get('get-sum')!;
+
+      await expect(handler({})).rejects.toThrow();
+      await expect(handler({ a: 'not a number', b: 5 })).rejects.toThrow();
+      await expect(handler({ a: 5 })).rejects.toThrow();
+    });
+  });
+
+  describe('get-env', () => {
+    it('should return all environment variables as JSON', async () => {
+      const { mockServer, handlers } = createMockServer();
+      registerGetEnvTool(mockServer);
+
+      const handler = handlers.get('get-env')!;
+      process.env.TEST_VAR_EVERYTHING = 'test_value';
+      const result = await handler({});
+
+      expect(result.content).toHaveLength(1);
+      expect(result.content[0].type).toBe('text');
+
+      const envJson = JSON.parse(result.content[0].text);
+      expect(envJson.TEST_VAR_EVERYTHING).toBe('test_value');
+
+      delete process.env.TEST_VAR_EVERYTHING;
+    });
+
+    it('should return valid JSON', async () => {
+      const { mockServer, handlers } = createMockServer();
+      registerGetEnvTool(mockServer);
+
+      const handler = handlers.get('get-env')!;
+      const result = await handler({});
+
+      expect(() => JSON.parse(result.content[0].text)).not.toThrow();
+    });
+  });
+
+  describe('get-tiny-image', () => {
+    it('should return image content with text descriptions', async () => {
+      const { mockServer, handlers } = createMockServer();
+      registerGetTinyImageTool(mockServer);
+
+      const handler = handlers.get('get-tiny-image')!;
+      const result = await handler({});
+
+      expect(result.content).toHaveLength(3);
+      expect(result.content[0]).toEqual({
+        type: 'text',
+        text: "Here's the image you requested:",
+      });
+      expect(result.content[1]).toEqual({
+        type: 'image',
+        data: MCP_TINY_IMAGE,
+        mimeType: 'image/png',
+      });
+      expect(result.content[2]).toEqual({
+        type: 'text',
+        text: 'The image above is the MCP logo.',
+      });
+    });
+
+    it('should return valid base64 image data', async () => {
+      const { mockServer, handlers } = createMockServer();
+      registerGetTinyImageTool(mockServer);
+
+      const handler = handlers.get('get-tiny-image')!;
+      const result = await handler({});
+
+      const imageContent = result.content[1];
+      expect(imageContent.type).toBe('image');
+      expect(imageContent.mimeType).toBe('image/png');
+      // Verify it's valid base64
+      expect(() => Buffer.from(imageContent.data, 'base64')).not.toThrow();
+    });
+  });
+
+  describe('get-structured-content', () => {
+    it('should return weather for New York', async () => {
+      const { mockServer, handlers } = createMockServer();
+      registerGetStructuredContentTool(mockServer);
+
+      const handler = handlers.get('get-structured-content')!;
+      const result = await handler({ location: 'New York' });
+
+      expect(result.structuredContent).toEqual({
+        temperature: 33,
+        conditions: 'Cloudy',
+        humidity: 82,
+      });
+      expect(result.content[0].type).toBe('text');
+      expect(JSON.parse(result.content[0].text)).toEqual(result.structuredContent);
+    });
+
+    it('should return weather for Chicago', async () => {
+      const { mockServer, handlers } = createMockServer();
+      registerGetStructuredContentTool(mockServer);
+
+      const handler = handlers.get('get-structured-content')!;
+      const result = await handler({ location: 'Chicago' });
+
+      expect(result.structuredContent).toEqual({
+        temperature: 36,
+        conditions: 'Light rain / drizzle',
+        humidity: 82,
+      });
+    });
+
+    it('should return weather for Los Angeles', async () => {
+      const { mockServer, handlers } = createMockServer();
+      registerGetStructuredContentTool(mockServer);
+
+      const handler = handlers.get('get-structured-content')!;
+      const result = await handler({ location: 'Los Angeles' });
+
+      expect(result.structuredContent).toEqual({
+        temperature: 73,
+        conditions: 'Sunny / Clear',
+        humidity: 48,
+      });
+    });
+  });
+
+  describe('get-annotated-message', () => {
+    it('should return error message with high priority', async () => {
+      const { mockServer, handlers } = createMockServer();
+      registerGetAnnotatedMessageTool(mockServer);
+
+      const handler = handlers.get('get-annotated-message')!;
+      const result = await handler({ messageType: 'error', includeImage: false });
+
+      expect(result.content).toHaveLength(1);
+      expect(result.content[0].text).toBe('Error: Operation failed');
+      expect(result.content[0].annotations).toEqual({
+        priority: 1.0,
+        audience: ['user', 'assistant'],
+      });
+    });
+
+    it('should return success message with medium priority', async () => {
+      const { mockServer, handlers } = createMockServer();
+      registerGetAnnotatedMessageTool(mockServer);
+
+      const handler = handlers.get('get-annotated-message')!;
+      const result = await handler({ messageType: 'success', includeImage: false });
+
+      expect(result.content[0].text).toBe('Operation completed successfully');
+      expect(result.content[0].annotations.priority).toBe(0.7);
+      expect(result.content[0].annotations.audience).toEqual(['user']);
+    });
+
+    it('should return debug message with low priority', async () => {
+      const { mockServer, handlers } = createMockServer();
+      registerGetAnnotatedMessageTool(mockServer);
+
+      const handler = handlers.get('get-annotated-message')!;
+      const result = await handler({ messageType: 'debug', includeImage: false });
+
+      expect(result.content[0].text).toContain('Debug:');
+      expect(result.content[0].annotations.priority).toBe(0.3);
+      expect(result.content[0].annotations.audience).toEqual(['assistant']);
+    });
+
+    it('should include annotated image when requested', async () => {
+      const { mockServer, handlers } = createMockServer();
+      registerGetAnnotatedMessageTool(mockServer);
+
+      const handler = handlers.get('get-annotated-message')!;
+      const result = await handler({ messageType: 'success', includeImage: true });
+
+      expect(result.content).toHaveLength(2);
+      expect(result.content[1].type).toBe('image');
+      expect(result.content[1].annotations).toEqual({
+        priority: 0.5,
+        audience: ['user'],
+      });
+    });
+  });
+
+  describe('trigger-long-running-operation', () => {
+    it('should complete operation and return result', async () => {
+      const { mockServer, handlers } = createMockServer();
+      registerTriggerLongRunningOperationTool(mockServer);
+
+      const handler = handlers.get('trigger-long-running-operation')!;
+      // Use very short duration for test
+      const result = await handler(
+        { duration: 0.1, steps: 2 },
+        { _meta: {}, requestId: 'test-123' }
+      );
+
+      expect(result.content[0].text).toContain('Long running operation completed');
+      expect(result.content[0].text).toContain('Duration: 0.1 seconds');
+      expect(result.content[0].text).toContain('Steps: 2');
+    }, 10000);
+
+    it('should send progress notifications when progressToken provided', async () => {
+      const { mockServer, handlers } = createMockServer();
+      registerTriggerLongRunningOperationTool(mockServer);
+
+      const handler = handlers.get('trigger-long-running-operation')!;
+      await handler(
+        { duration: 0.1, steps: 2 },
+        { _meta: { progressToken: 'token-123' }, requestId: 'test-456', sessionId: 'session-1' }
+      );
+
+      expect(mockServer.server.notification).toHaveBeenCalledTimes(2);
+      expect(mockServer.server.notification).toHaveBeenCalledWith(
+        expect.objectContaining({
+          method: 'notifications/progress',
+          params: expect.objectContaining({
+            progressToken: 'token-123',
+          }),
+        }),
+        expect.any(Object)
+      );
+    }, 10000);
+  });
+
+  describe('get-resource-links', () => {
+    it('should return specified number of resource links', async () => {
+      const { mockServer, handlers } = createMockServer();
+      registerGetResourceLinksTool(mockServer);
+
+      const handler = handlers.get('get-resource-links')!;
+      const result = await handler({ count: 3 });
+
+      // 1 intro text + 3 resource links
+      expect(result.content).toHaveLength(4);
+      expect(result.content[0].type).toBe('text');
+      expect(result.content[0].text).toContain('3 resource links');
+
+      // Check resource links
+      for (let i = 1; i < 4; i++) {
+        expect(result.content[i].type).toBe('resource_link');
+        expect(result.content[i].uri).toBeDefined();
+        expect(result.content[i].name).toBeDefined();
+      }
+    });
+
+    it('should alternate between text and blob resources', async () => {
+      const { mockServer, handlers } = createMockServer();
+      registerGetResourceLinksTool(mockServer);
+
+      const handler = handlers.get('get-resource-links')!;
+      const result = await handler({ count: 4 });
+
+      // Odd IDs (1, 3) are blob, even IDs (2, 4) are text
+      expect(result.content[1].name).toContain('Blob');
+      expect(result.content[2].name).toContain('Text');
+      expect(result.content[3].name).toContain('Blob');
+      expect(result.content[4].name).toContain('Text');
+    });
+
+    it('should use default count of 3', async () => {
+      const { mockServer, handlers } = createMockServer();
+      registerGetResourceLinksTool(mockServer);
+
+      const handler = handlers.get('get-resource-links')!;
+      const result = await handler({});
+
+      // 1 intro text + 3 resource links (default)
+      expect(result.content).toHaveLength(4);
+    });
+  });
+
+  describe('get-resource-reference', () => {
+    it('should return text resource reference', async () => {
+      const { mockServer, handlers } = createMockServer();
+      registerGetResourceReferenceTool(mockServer);
+
+      const handler = handlers.get('get-resource-reference')!;
+      const result = await handler({ resourceType: 'Text', resourceId: 1 });
+
+      expect(result.content).toHaveLength(3);
+      expect(result.content[0].text).toContain('Resource 1');
+      expect(result.content[1].type).toBe('resource');
+      expect(result.content[1].resource.uri).toContain('text/1');
+      expect(result.content[2].text).toContain('URI');
+    });
+
+    it('should return blob resource reference', async () => {
+      const { mockServer, handlers } = createMockServer();
+      registerGetResourceReferenceTool(mockServer);
+
+      const handler = handlers.get('get-resource-reference')!;
+      const result = await handler({ resourceType: 'Blob', resourceId: 5 });
+
+      expect(result.content[1].resource.uri).toContain('blob/5');
+    });
+
+    it('should reject invalid resource type', async () => {
+      const { mockServer, handlers } = createMockServer();
+      registerGetResourceReferenceTool(mockServer);
+
+      const handler = handlers.get('get-resource-reference')!;
+      await expect(handler({ resourceType: 'Invalid', resourceId: 1 })).rejects.toThrow(
+        'Invalid resourceType'
+      );
+    });
+
+    it('should reject invalid resource ID', async () => {
+      const { mockServer, handlers } = createMockServer();
+      registerGetResourceReferenceTool(mockServer);
+
+      const handler = handlers.get('get-resource-reference')!;
+      await expect(handler({ resourceType: 'Text', resourceId: -1 })).rejects.toThrow(
+        'Invalid resourceId'
+      );
+      await expect(handler({ resourceType: 'Text', resourceId: 0 })).rejects.toThrow(
+        'Invalid resourceId'
+      );
+      await expect(handler({ resourceType: 'Text', resourceId: 1.5 })).rejects.toThrow(
+        'Invalid resourceId'
+      );
+    });
+  });
+
+  describe('toggle-simulated-logging', () => {
+    it('should start logging when not active', async () => {
+      const { mockServer, handlers } = createMockServer();
+      registerToggleSimulatedLoggingTool(mockServer);
+
+      const handler = handlers.get('toggle-simulated-logging')!;
+      const result = await handler({}, { sessionId: 'test-session-1' });
+
+      expect(result.content[0].text).toContain('Started');
+      expect(result.content[0].text).toContain('test-session-1');
+    });
+
+    it('should stop logging when already active', async () => {
+      const { mockServer, handlers } = createMockServer();
+      registerToggleSimulatedLoggingTool(mockServer);
+
+      const handler = handlers.get('toggle-simulated-logging')!;
+
+      // First call starts logging
+      await handler({}, { sessionId: 'test-session-2' });
+
+      // Second call stops logging
+      const result = await handler({}, { sessionId: 'test-session-2' });
+
+      expect(result.content[0].text).toContain('Stopped');
+      expect(result.content[0].text).toContain('test-session-2');
+    });
+
+    it('should handle undefined sessionId', async () => {
+      const { mockServer, handlers } = createMockServer();
+      registerToggleSimulatedLoggingTool(mockServer);
+
+      const handler = handlers.get('toggle-simulated-logging')!;
+      const result = await handler({}, {});
+
+      expect(result.content[0].text).toContain('Started');
+    });
+  });
+
+  describe('toggle-subscriber-updates', () => {
+    it('should start updates when not active', async () => {
+      const { mockServer, handlers } = createMockServer();
+      registerToggleSubscriberUpdatesTool(mockServer);
+
+      const handler = handlers.get('toggle-subscriber-updates')!;
+      const result = await handler({}, { sessionId: 'sub-session-1' });
+
+      expect(result.content[0].text).toContain('Started');
+      expect(result.content[0].text).toContain('sub-session-1');
+    });
+
+    it('should stop updates when already active', async () => {
+      const { mockServer, handlers } = createMockServer();
+      registerToggleSubscriberUpdatesTool(mockServer);
+
+      const handler = handlers.get('toggle-subscriber-updates')!;
+
+      // First call starts updates
+      await handler({}, { sessionId: 'sub-session-2' });
+
+      // Second call stops updates
+      const result = await handler({}, { sessionId: 'sub-session-2' });
+
+      expect(result.content[0].text).toContain('Stopped');
+      expect(result.content[0].text).toContain('sub-session-2');
+    });
+  });
+
+  describe('trigger-sampling-request', () => {
+    it('should not register when client does not support sampling', () => {
+      const { mockServer } = createMockServer();
+      registerTriggerSamplingRequestTool(mockServer);
+
+      // Tool should not be registered since mock server returns empty capabilities
+      expect(mockServer.registerTool).not.toHaveBeenCalled();
+    });
+
+    it('should register when client supports sampling', () => {
+      const handlers: Map<string, Function> = new Map();
+      const mockServer = {
+        registerTool: vi.fn((name: string, config: any, handler: Function) => {
+          handlers.set(name, handler);
+        }),
+        server: {
+          getClientCapabilities: vi.fn(() => ({ sampling: {} })),
+        },
+      } as unknown as McpServer;
+
+      registerTriggerSamplingRequestTool(mockServer);
+
+      expect(mockServer.registerTool).toHaveBeenCalledWith(
+        'trigger-sampling-request',
+        expect.objectContaining({
+          title: 'Trigger Sampling Request Tool',
+          description: expect.stringContaining('Sampling'),
+        }),
+        expect.any(Function)
+      );
+    });
+
+    it('should send sampling request and return result', async () => {
+      const handlers: Map<string, Function> = new Map();
+      const mockSendRequest = vi.fn().mockResolvedValue({
+        model: 'test-model',
+        content: { type: 'text', text: 'LLM response' },
+      });
+
+      const mockServer = {
+        registerTool: vi.fn((name: string, config: any, handler: Function) => {
+          handlers.set(name, handler);
+        }),
+        server: {
+          getClientCapabilities: vi.fn(() => ({ sampling: {} })),
+        },
+      } as unknown as McpServer;
+
+      registerTriggerSamplingRequestTool(mockServer);
+
+      const handler = handlers.get('trigger-sampling-request')!;
+      const result = await handler(
+        { prompt: 'Test prompt', maxTokens: 50 },
+        { sendRequest: mockSendRequest }
+      );
+
+      expect(mockSendRequest).toHaveBeenCalledWith(
+        expect.objectContaining({
+          method: 'sampling/createMessage',
+          params: expect.objectContaining({
+            maxTokens: 50,
+          }),
+        }),
+        expect.anything()
+      );
+      expect(result.content[0].text).toContain('LLM sampling result');
+    });
+  });
+
+  describe('trigger-elicitation-request', () => {
+    it('should not register when client does not support elicitation', () => {
+      const { mockServer } = createMockServer();
+      registerTriggerElicitationRequestTool(mockServer);
+
+      expect(mockServer.registerTool).not.toHaveBeenCalled();
+    });
+
+    it('should register when client supports elicitation', () => {
+      const handlers: Map<string, Function> = new Map();
+      const mockServer = {
+        registerTool: vi.fn((name: string, config: any, handler: Function) => {
+          handlers.set(name, handler);
+        }),
+        server: {
+          getClientCapabilities: vi.fn(() => ({ elicitation: {} })),
+        },
+      } as unknown as McpServer;
+
+      registerTriggerElicitationRequestTool(mockServer);
+
+      expect(mockServer.registerTool).toHaveBeenCalledWith(
+        'trigger-elicitation-request',
+        expect.objectContaining({
+          title: 'Trigger Elicitation Request Tool',
+          description: expect.stringContaining('Elicitation'),
+        }),
+        expect.any(Function)
+      );
+    });
+
+    it('should handle accept action with user content', async () => {
+      const handlers: Map<string, Function> = new Map();
+      const mockSendRequest = vi.fn().mockResolvedValue({
+        action: 'accept',
+        content: {
+          name: 'John Doe',
+          check: true,
+          email: 'john@example.com',
+        },
+      });
+
+      const mockServer = {
+        registerTool: vi.fn((name: string, config: any, handler: Function) => {
+          handlers.set(name, handler);
+        }),
+        server: {
+          getClientCapabilities: vi.fn(() => ({ elicitation: {} })),
+        },
+      } as unknown as McpServer;
+
+      registerTriggerElicitationRequestTool(mockServer);
+
+      const handler = handlers.get('trigger-elicitation-request')!;
+      const result = await handler({}, { sendRequest: mockSendRequest });
+
+      expect(result.content[0].text).toContain('✅');
+      expect(result.content[0].text).toContain('provided');
+      expect(result.content[1].text).toContain('John Doe');
+    });
+
+    it('should handle decline action', async () => {
+      const handlers: Map<string, Function> = new Map();
+      const mockSendRequest = vi.fn().mockResolvedValue({
+        action: 'decline',
+      });
+
+      const mockServer = {
+        registerTool: vi.fn((name: string, config: any, handler: Function) => {
+          handlers.set(name, handler);
+        }),
+        server: {
+          getClientCapabilities: vi.fn(() => ({ elicitation: {} })),
+        },
+      } as unknown as McpServer;
+
+      registerTriggerElicitationRequestTool(mockServer);
+
+      const handler = handlers.get('trigger-elicitation-request')!;
+      const result = await handler({}, { sendRequest: mockSendRequest });
+
+      expect(result.content[0].text).toContain('❌');
+      expect(result.content[0].text).toContain('declined');
+    });
+
+    it('should handle cancel action', async () => {
+      const handlers: Map<string, Function> = new Map();
+      const mockSendRequest = vi.fn().mockResolvedValue({
+        action: 'cancel',
+      });
+
+      const mockServer = {
+        registerTool: vi.fn((name: string, config: any, handler: Function) => {
+          handlers.set(name, handler);
+        }),
+        server: {
+          getClientCapabilities: vi.fn(() => ({ elicitation: {} })),
+        },
+      } as unknown as McpServer;
+
+      registerTriggerElicitationRequestTool(mockServer);
+
+      const handler = handlers.get('trigger-elicitation-request')!;
+      const result = await handler({}, { sendRequest: mockSendRequest });
+
+      expect(result.content[0].text).toContain('⚠️');
+      expect(result.content[0].text).toContain('cancelled');
+    });
+  });
+
+  describe('get-roots-list', () => {
+    it('should not register when client does not support roots', () => {
+      const { mockServer } = createMockServer();
+      registerGetRootsListTool(mockServer);
+
+      expect(mockServer.registerTool).not.toHaveBeenCalled();
+    });
+
+    it('should register when client supports roots', () => {
+      const handlers: Map<string, Function> = new Map();
+      const mockServer = {
+        registerTool: vi.fn((name: string, config: any, handler: Function) => {
+          handlers.set(name, handler);
+        }),
+        server: {
+          getClientCapabilities: vi.fn(() => ({ roots: {} })),
+        },
+      } as unknown as McpServer;
+
+      registerGetRootsListTool(mockServer);
+
+      expect(mockServer.registerTool).toHaveBeenCalledWith(
+        'get-roots-list',
+        expect.objectContaining({
+          title: 'Get Roots List Tool',
+          description: expect.stringContaining('roots'),
+        }),
+        expect.any(Function)
+      );
+    });
+  });
+
+  describe('gzip-file-as-resource', () => {
+    it('should compress data URI and return resource link', async () => {
+      const registeredResources: any[] = [];
+      const mockServer = {
+        registerTool: vi.fn(),
+        registerResource: vi.fn((...args) => {
+          registeredResources.push(args);
+        }),
+      } as unknown as McpServer;
+
+      // Get the handler
+      let handler: Function | null = null;
+      (mockServer.registerTool as any).mockImplementation(
+        (name: string, config: any, h: Function) => {
+          handler = h;
+        }
+      );
+
+      registerGZipFileAsResourceTool(mockServer);
+
+      // Create a data URI with test content
+      const testContent = 'Hello, World!';
+      const dataUri = `data:text/plain;base64,${Buffer.from(testContent).toString('base64')}`;
+
+      const result = await handler!(
+        { name: 'test.txt.gz', data: dataUri, outputType: 'resourceLink' }
+      );
+
+      expect(result.content[0].type).toBe('resource_link');
+      expect(result.content[0].uri).toContain('test.txt.gz');
+    });
+
+    it('should return resource directly when outputType is resource', async () => {
+      const mockServer = {
+        registerTool: vi.fn(),
+        registerResource: vi.fn(),
+      } as unknown as McpServer;
+
+      let handler: Function | null = null;
+      (mockServer.registerTool as any).mockImplementation(
+        (name: string, config: any, h: Function) => {
+          handler = h;
+        }
+      );
+
+      registerGZipFileAsResourceTool(mockServer);
+
+      const testContent = 'Test content for compression';
+      const dataUri = `data:text/plain;base64,${Buffer.from(testContent).toString('base64')}`;
+
+      const result = await handler!(
+        { name: 'output.gz', data: dataUri, outputType: 'resource' }
+      );
+
+      expect(result.content[0].type).toBe('resource');
+      expect(result.content[0].resource.mimeType).toBe('application/gzip');
+      expect(result.content[0].resource.blob).toBeDefined();
+    });
+
+    it('should reject unsupported URL protocols', async () => {
+      const mockServer = {
+        registerTool: vi.fn(),
+        registerResource: vi.fn(),
+      } as unknown as McpServer;
+
+      let handler: Function | null = null;
+      (mockServer.registerTool as any).mockImplementation(
+        (name: string, config: any, h: Function) => {
+          handler = h;
+        }
+      );
+
+      registerGZipFileAsResourceTool(mockServer);
+
+      await expect(
+        handler!({ name: 'test.gz', data: 'ftp://example.com/file.txt', outputType: 'resource' })
+      ).rejects.toThrow('Unsupported URL protocol');
+    });
+  });
+});

src/everything/package.json

@@ -26,7 +26,8 @@
     "start:sse": "node dist/index.js sse",
     "start:streamableHttp": "node dist/index.js streamableHttp",
     "prettier:fix": "prettier --write .",
-    "prettier:check": "prettier --check ."
+    "prettier:check": "prettier --check .",
+    "test": "vitest run --coverage"
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.26.0",
@@ -39,8 +40,10 @@
   "devDependencies": {
     "@types/cors": "^2.8.19",
     "@types/express": "^5.0.6",
+    "@vitest/coverage-v8": "^2.1.8",
     "shx": "^0.3.4",
     "typescript": "^5.6.2",
-    "prettier": "^2.8.8"
+    "prettier": "^2.8.8",
+    "vitest": "^2.1.8"
   }
 }

src/everything/vitest.config.ts

@@ -0,0 +1,14 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: 'node',
+    include: ['**/__tests__/**/*.test.ts'],
+    coverage: {
+      provider: 'v8',
+      include: ['**/*.ts'],
+      exclude: ['**/__tests__/**', '**/dist/**'],
+    },
+  },
+});