fix: recursive loading

Author: QuantGeekDev

src/core/MCPServer.ts

@@ -137,27 +137,6 @@ export class MCPServer {
         };
         logger.debug(`Creating HttpStreamTransport. response mode: ${httpConfig.responseMode}`);
         transport = new HttpStreamTransport(httpConfig);
-
-        (transport as HttpStreamTransport).setServerConfig(
-          { name: this.serverName, version: this.serverVersion },
-          async (mcpServer) => {
-            for (const [toolName, tool] of this.toolsMap.entries()) {
-              (mcpServer as any).tool(
-                toolName,
-                tool.inputSchema.properties || {},
-                async (params: any) => {
-                  const result = await tool.toolCall({
-                    params: {
-                      name: toolName,
-                      arguments: params,
-                    },
-                  });
-                  return result;
-                }
-              );
-            }
-          }
-        );
         break;
       }
       case 'stdio':

src/loaders/BaseLoader.ts

@@ -1,4 +1,5 @@
 import { join, dirname } from 'path';
+import { pathToFileURL } from 'url';
 import { existsSync } from 'fs';
 import { logger } from '../core/Logger.js';
 import { discoverFilesRecursively, hasValidFiles } from '../utils/fileDiscovery.js';
@@ -85,7 +86,7 @@ export abstract class BaseLoader<T> {
             `Attempting to load ${this.config.subdirectory.slice(0, -1)} from: ${fullPath}`
           );
 
-          const importPath = `file://${fullPath}`;
+          const importPath = pathToFileURL(fullPath).href;
           const module = await import(importPath);
 
           let ItemClass = null;

src/transports/http/server.ts

@@ -15,10 +15,8 @@ export class HttpStreamTransport extends AbstractTransport {
   private _endpoint: string;
   private _enableJsonResponse: boolean = false;
 
-
   private _transports: Map<string, StreamableHTTPServerTransport> = new Map();
 
-
   private _serverConfig: any;
   private _serverSetupCallback?: (server: McpServer) => Promise<void>;
 
@@ -54,7 +52,6 @@ export class HttpStreamTransport extends AbstractTransport {
     );
   }
 
-
   setServerConfig(serverConfig: any, setupCallback: (server: McpServer) => Promise<void>): void {
     this._serverConfig = serverConfig;
     this._serverSetupCallback = setupCallback;
@@ -120,13 +117,30 @@ export class HttpStreamTransport extends AbstractTransport {
         logger.info('Creating new session for initialization request');
 
         if (!this._serverSetupCallback || !this._serverConfig) {
-          logger.error('No server configuration available');
-          this.sendError(
-            res,
-            500,
-            -32603,
-            'Internal server error: No server configuration available'
-          );
+          logger.debug('No server configuration available, using standard transport behavior');
+          transport = new StreamableHTTPServerTransport({
+            sessionIdGenerator: () => randomUUID(),
+            onsessioninitialized: (sessionId: string) => {
+              logger.info(`Session initialized: ${sessionId}`);
+              this._transports.set(sessionId, transport);
+            },
+            enableJsonResponse: this._enableJsonResponse,
+          });
+
+          transport.onclose = () => {
+            if (transport.sessionId) {
+              logger.info(`Transport closed for session: ${transport.sessionId}`);
+              this._transports.delete(transport.sessionId);
+            }
+          };
+
+          transport.onmessage = async (message: JSONRPCMessage) => {
+            if (this._onmessage) {
+              await this._onmessage(message);
+            }
+          };
+
+          await transport.handleRequest(req, res, body);
           return;
         }
 
@@ -135,7 +149,6 @@ export class HttpStreamTransport extends AbstractTransport {
             sessionIdGenerator: () => randomUUID(),
             onsessioninitialized: (sessionId: string) => {
               logger.info(`Session initialized: ${sessionId}`);
-              // Store the transport by session ID
               this._transports.set(sessionId, transport);
             },
             enableJsonResponse: this._enableJsonResponse,