Merge pull request #113 from QuantGeekDev/fix/tool-schema

fix: http transport uses same tool loading

Author: QuantGeekDev

src/core/MCPServer.ts

@@ -138,53 +138,6 @@ export class MCPServer {
         logger.debug(`Creating HttpStreamTransport. response mode: ${httpConfig.responseMode}`);
         transport = new HttpStreamTransport(httpConfig);
 
-        const serverConfig = {
-          name: this.serverName,
-          version: this.serverVersion,
-        };
-
-        const setupCallback = async (server: any) => {
-          for (const [name, tool] of this.toolsMap.entries()) {
-            let zodSchema: any;
-            if ((tool as any).schema && typeof (tool as any).schema === 'object') {
-              zodSchema = (tool as any).schema;
-            } else {
-              zodSchema = {};
-            }
-
-            server.tool(name, zodSchema, async (input: any) => {
-              try {
-                logger.debug(`Executing tool ${name} with input: ${JSON.stringify(input)}`);
-                const result = await (tool as any).execute(input);
-
-                if (result && typeof result === 'object' && 'content' in result) {
-                  return result;
-                } else {
-                  return {
-                    content: [
-                      {
-                        type: 'text',
-                        text: typeof result === 'string' ? result : JSON.stringify(result),
-                      },
-                    ],
-                  };
-                }
-              } catch (error) {
-                logger.error(`Tool execution failed for ${name}: ${error}`);
-                return {
-                  content: [
-                    {
-                      type: 'text',
-                      text: `Error: ${error instanceof Error ? error.message : String(error)}`,
-                    },
-                  ],
-                };
-              }
-            });
-          }
-        };
-
-        (transport as HttpStreamTransport).setServerConfig(serverConfig, setupCallback);
         break;
       }
       case 'stdio':

src/transports/http/server.ts

@@ -3,7 +3,6 @@ import { IncomingMessage, ServerResponse, createServer, Server as HttpServer } f
 import { AbstractTransport } from '../base.js';
 import { JSONRPCMessage, isInitializeRequest } from '@modelcontextprotocol/sdk/types.js';
 import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { HttpStreamTransportConfig } from './types.js';
 import { logger } from '../../core/Logger.js';
 
@@ -17,9 +16,6 @@ export class HttpStreamTransport extends AbstractTransport {
 
   private _transports: { [sessionId: string]: StreamableHTTPServerTransport } = {};
 
-  private _serverConfig: any;
-  private _serverSetupCallback?: (server: McpServer) => Promise<void>;
-
   constructor(config: HttpStreamTransportConfig = {}) {
     super();
 
@@ -40,11 +36,6 @@ export class HttpStreamTransport extends AbstractTransport {
     );
   }
 
-  setServerConfig(serverConfig: any, setupCallback: (server: McpServer) => Promise<void>): void {
-    this._serverConfig = serverConfig;
-    this._serverSetupCallback = setupCallback;
-  }
-
   async start(): Promise<void> {
     if (this._isRunning) {
       throw new Error('HttpStreamTransport already started');
@@ -126,17 +117,11 @@ export class HttpStreamTransport extends AbstractTransport {
           }
         };
 
-        if (this._serverSetupCallback && this._serverConfig) {
-          const server = new McpServer(this._serverConfig);
-          await this._serverSetupCallback(server);
-          await server.connect(transport);
-        } else {
-          transport.onmessage = async (message: JSONRPCMessage) => {
-            if (this._onmessage) {
-              await this._onmessage(message);
-            }
-          };
-        }
+        transport.onmessage = async (message: JSONRPCMessage) => {
+          if (this._onmessage) {
+            await this._onmessage(message);
+          }
+        };
 
         await transport.handleRequest(req, res, body);
         return;

tests/transports/http/server.test.ts

@@ -41,16 +41,6 @@ describe('HttpStreamTransport', () => {
     });
   });
 
-  describe('Server Configuration', () => {
-    it('should set server configuration and setup callback', () => {
-      const serverConfig = { name: 'test-server', version: '1.0.0' };
-      const setupCallback = async () => {};
-
-      // Should not throw when setting configuration
-      expect(() => transport.setServerConfig(serverConfig, setupCallback)).not.toThrow();
-    });
-  });
-
   describe('Transport Management', () => {
     it('should start and stop successfully', async () => {
       expect(transport.isRunning()).toBe(false);
@@ -138,20 +128,7 @@ describe('HttpStreamTransport', () => {
       expect(transport.isRunning()).toBe(false);
     });
 
-    it('should support proper session management structure', () => {
-      const serverConfig = { name: 'multi-client-server', version: '1.0.0' };
-      const setupCallback = async () => {};
-
-      // Should accept configuration for multi-client support
-      expect(() => transport.setServerConfig(serverConfig, setupCallback)).not.toThrow();
-    });
-
     it('should handle server lifecycle correctly', async () => {
-      // Set up server configuration first
-      const serverConfig = { name: 'test-server', version: '1.0.0' };
-      const setupCallback = async () => {};
-      transport.setServerConfig(serverConfig, setupCallback);
-
       // Start and verify state
       await transport.start();
       expect(transport.isRunning()).toBe(true);
@@ -193,33 +170,32 @@ describe('HttpStreamTransport', () => {
     });
   });
 
-  describe('Integration with Framework Pattern', () => {
-    it('should follow the multi-session architecture', () => {
-      const serverConfig = {
-        name: 'http-stream-server',
-        version: '1.0.0',
-      };
-
-      const setupCallback = async () => {};
-
-      // Should accept the configuration pattern used by working examples
-      expect(() => transport.setServerConfig(serverConfig, setupCallback)).not.toThrow();
-
-      // Should maintain the http-stream transport type
+  describe('Unified Transport Architecture', () => {
+    it('should use standard MCP protocol flow like other transports', () => {
+      // HTTP transport now uses the same unified architecture as SSE and stdio
+      expect(transport).toBeDefined();
       expect(transport.type).toBe('http-stream');
-    });
-
-    it('should support the official MCP pattern for session management', () => {
-      // Verify the transport supports the pattern:
-      // 1. Each session gets its own transport instance (handled by our implementation)
-      // 2. Each session gets its own McpServer instance (handled by setServerConfig)
-      // 3. Server connects to transport (handled by our implementation)
-      // 4. Transport stores sessions in a map (our _transports map)
 
-      expect(transport).toBeDefined();
-      expect(typeof transport.setServerConfig).toBe('function');
+      // Should have standard transport interface methods
       expect(typeof transport.send).toBe('function');
       expect(typeof transport.close).toBe('function');
+      expect(typeof transport.start).toBe('function');
+      expect(typeof transport.isRunning).toBe('function');
+    });
+
+    it('should support message handling through onmessage handler', () => {
+      // HTTP transport now uses standard onmessage handler like other transports
+      let messageReceived: JSONRPCMessage | undefined;
+
+      // Setting onmessage should not throw
+      expect(() => {
+        transport.onmessage = async (message: JSONRPCMessage) => {
+          messageReceived = message;
+        };
+      }).not.toThrow();
+
+      // Verify the transport has the onmessage property in its interface
+      expect('onmessage' in transport).toBe(true);
     });
   });
 });