@cyanheads/pubmed-mcp-server 1.0.16 → 1.1.2

package/dist/mcp-server/transports/httpTransport.js

@@ -1,7 +1,7 @@
 /**
- * @fileoverview Handles the setup and management of the Streamable HTTP MCP transport.
+ * @fileoverview Handles the setup and management of the Streamable HTTP MCP transport using Hono.
  * Implements the MCP Specification 2025-03-26 for Streamable HTTP.
- * This includes creating an Express server, configuring middleware (CORS, Authentication),
+ * This includes creating a Hono server, configuring middleware (CORS, Authentication),
  * defining request routing for the single MCP endpoint (POST/GET/DELETE),
  * managing server-side sessions, handling Server-Sent Events (SSE) for streaming,
  * and binding to a network port with retry logic for port conflicts.
@@ -10,14 +10,18 @@
  * https://github.com/modelcontextprotocol/modelcontextprotocol/blob/main/docs/specification/2025-03-26/basic/transports.mdx#streamable-http
  * @module src/mcp-server/transports/httpTransport
  */
+import { serve } from "@hono/node-server";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 import { isInitializeRequest } from "@modelcontextprotocol/sdk/types.js";
-import express from "express";
+import { Hono } from "hono";
+import { cors } from "hono/cors";
 import http from "http";
 import { randomUUID } from "node:crypto";
 import { config } from "../../config/index.js";
-import { logger, requestContextService, } from "../../utils/index.js";
-import { mcpAuthMiddleware } from "./authentication/authMiddleware.js";
+import { BaseErrorCode, McpError } from "../../types-global/errors.js";
+import { logger, rateLimiter, requestContextService, } from "../../utils/index.js";
+import { initializeAuthMiddleware, mcpAuthMiddleware, } from "./authentication/authMiddleware.js";
+import { oauthMiddleware } from "./authentication/oauthMiddleware.js";
 /**
  * The port number for the HTTP transport, configured via `MCP_HTTP_PORT` environment variable.
  * Defaults to 3010 if not specified (default is managed by the config module).
@@ -55,44 +59,27 @@ const MAX_PORT_RETRIES = 15;
  */
 const httpTransports = {};
 /**
- * Checks if an incoming HTTP request's `Origin` header is permissible based on configuration.
- * MCP Spec Security: Servers MUST validate the `Origin` header for cross-origin requests.
- * This function checks the request's origin against the `config.mcpAllowedOrigins` list.
- * If the server is bound to localhost, requests from localhost or with no/null origin are also permitted.
- * Sets appropriate CORS headers (`Access-Control-Allow-Origin`, etc.) if the origin is allowed.
- *
- * @param req - The Express request object.
- * @param res - The Express response object.
- * @returns True if the origin is allowed, false otherwise.
+ * Stores the last activity timestamp for each session, keyed by session ID.
+ * Used for garbage collecting stale/abandoned sessions.
+ * @type {Record<string, number>}
  * @private
  */
-function isOriginAllowed(req, res) {
-    const origin = req.headers.origin;
-    const host = req.hostname;
-    const isLocalhostBinding = ["127.0.0.1", "::1", "localhost"].includes(host);
-    const allowedOrigins = config.mcpAllowedOrigins || [];
-    const context = requestContextService.createRequestContext({
-        operation: "isOriginAllowed",
-        origin,
-        host,
-        isLocalhostBinding,
-        allowedOrigins,
-    });
-    logger.debug("Checking origin allowance", context);
-    const allowed = (origin && allowedOrigins.includes(origin)) ||
-        (isLocalhostBinding && (!origin || origin === "null"));
-    if (allowed && origin) {
-        res.setHeader("Access-Control-Allow-Origin", origin);
-        res.setHeader("Access-Control-Allow-Methods", "GET, POST, DELETE, OPTIONS");
-        res.setHeader("Access-Control-Allow-Headers", "Content-Type, Mcp-Session-Id, Last-Event-ID, Authorization");
-        res.setHeader("Access-Control-Allow-Credentials", "true");
-    }
-    else if (!allowed && origin) {
-        logger.warning(`Origin denied: ${origin}`, context);
-    }
-    logger.debug(`Origin check result: ${allowed}`, { ...context, allowed });
-    return allowed;
-}
+const sessionActivity = {};
+/**
+ * The timeout period in milliseconds for inactive sessions. If a session has no
+ * activity for this duration, it will be considered stale and garbage collected.
+ * Defaults to 30 minutes.
+ * @constant {number} SESSION_TIMEOUT_MS
+ * @private
+ */
+const SESSION_TIMEOUT_MS = 30 * 60 * 1000; // 30 minutes
+/**
+ * The interval in milliseconds at which the session garbage collector runs to
+ * clean up stale sessions. Defaults to 1 minute.
+ * @constant {number} SESSION_GC_INTERVAL_MS
+ * @private
+ */
+const SESSION_GC_INTERVAL_MS = 60 * 1000; // 1 minute
 /**
  * Proactively checks if a specific network port is already in use.
  * @param port - The port number to check.
@@ -132,16 +119,16 @@ async function isPortInUse(port, host, parentContext) {
 /**
  * Attempts to start the HTTP server, retrying on incrementing ports if `EADDRINUSE` occurs.
  *
- * @param serverInstance - The Node.js HTTP server instance.
+ * @param app - The Hono application instance.
  * @param initialPort - The initial port number to try.
  * @param host - The host address to bind to.
  * @param maxRetries - Maximum number of additional ports to attempt.
  * @param parentContext - Logging context from the caller.
- * @returns A promise that resolves with the port number the server successfully bound to.
+ * @returns A promise that resolves with the Node.js `http.Server` instance the server successfully bound to.
  * @throws {Error} If binding fails after all retries or for a non-EADDRINUSE error.
  * @private
  */
-function startHttpServerWithRetry(serverInstance, initialPort, host, maxRetries, parentContext) {
+function startHttpServerWithRetry(app, initialPort, host, maxRetries, parentContext) {
     const startContext = requestContextService.createRequestContext({
         ...parentContext,
         operation: "startHttpServerWithRetry",
@@ -168,18 +155,21 @@ function startHttpServerWithRetry(serverInstance, initialPort, host, maxRetries,
                 continue;
             }
             try {
-                await new Promise((listenResolve, listenReject) => {
-                    serverInstance
-                        .listen(currentPort, host, () => {
-                        const serverAddress = `http://${host}:${currentPort}${MCP_ENDPOINT_PATH}`;
-                        logger.info(`HTTP transport successfully listening on host ${host} at ${serverAddress}`, { ...attemptContext, address: serverAddress });
-                        listenResolve();
-                    })
-                        .on("error", (err) => {
-                        listenReject(err);
-                    });
+                const serverInstance = serve({ fetch: app.fetch, port: currentPort, hostname: host }, (info) => {
+                    const serverAddress = `http://${info.address}:${info.port}${MCP_ENDPOINT_PATH}`;
+                    logger.info(`HTTP transport successfully listening on host ${host} at ${serverAddress}`, { ...attemptContext, address: serverAddress });
+                    // Display user-friendly startup message only after server is confirmed listening
+                    let serverAddressLog = serverAddress;
+                    let productionNote = "";
+                    if (config.environment === "production") {
+                        serverAddressLog = `https://${info.address}:${info.port}${MCP_ENDPOINT_PATH}`;
+                        productionNote = ` (via HTTPS, ensure reverse proxy is configured)`;
+                    }
+                    if (process.stdout.isTTY) {
+                        console.log(`\n🚀 MCP Server running in HTTP mode at: ${serverAddressLog}${productionNote}\n   (MCP Spec: 2025-03-26 Streamable HTTP Transport)\n`);
+                    }
                 });
-                resolve(currentPort);
+                resolve(serverInstance);
                 return;
             }
             catch (err) {
@@ -206,92 +196,146 @@ function startHttpServerWithRetry(serverInstance, initialPort, host, maxRetries,
  *
  * @param createServerInstanceFn - An asynchronous factory function that returns a new `McpServer` instance.
  * @param parentContext - Logging context from the main server startup process.
- * @returns A promise that resolves when the HTTP server is successfully listening.
+ * @returns A promise that resolves with the Node.js `http.Server` instance when the HTTP server is successfully listening.
  * @throws {Error} If the server fails to start after all port retries.
  */
 export async function startHttpTransport(createServerInstanceFn, parentContext) {
-    const app = express();
+    initializeAuthMiddleware(); // Explicitly initialize auth middleware config
+    const app = new Hono();
     const transportContext = requestContextService.createRequestContext({
         ...parentContext,
         transportType: "HTTP",
         component: "HttpTransportSetup",
     });
-    logger.debug("Setting up Express app for HTTP transport...", transportContext);
-    app.use(express.json());
-    app.options(MCP_ENDPOINT_PATH, (req, res) => {
-        const optionsContext = requestContextService.createRequestContext({
-            ...transportContext,
-            operation: "handleOptions",
-            origin: req.headers.origin,
-            method: req.method,
-            path: req.path,
+    logger.debug("Setting up Hono app for HTTP transport...", transportContext);
+    // Start the session garbage collector
+    setInterval(() => {
+        const now = Date.now();
+        const gcContext = requestContextService.createRequestContext({
+            operation: "SessionGarbageCollector",
         });
-        logger.debug(`Received OPTIONS request for ${MCP_ENDPOINT_PATH}`, optionsContext);
-        if (isOriginAllowed(req, res)) {
-            logger.debug("OPTIONS request origin allowed, sending 204.", optionsContext);
-            res.sendStatus(204);
-        }
-        else {
-            logger.debug("OPTIONS request origin denied, sending 403.", optionsContext);
-            res.status(403).send("Forbidden: Invalid Origin");
+        logger.debug("Running session garbage collector...", gcContext);
+        for (const sessionId in sessionActivity) {
+            if (now - sessionActivity[sessionId] > SESSION_TIMEOUT_MS) {
+                logger.info(`Session ${sessionId} timed out due to inactivity. Cleaning up.`, { ...gcContext, sessionId });
+                const transport = httpTransports[sessionId];
+                if (transport) {
+                    transport.close(); // This will trigger the onclose handler to delete it from httpTransports
+                }
+                delete sessionActivity[sessionId];
+            }
         }
-    });
-    app.use((req, res, next) => {
+    }, SESSION_GC_INTERVAL_MS);
+    app.use("*", cors({
+        origin: config.mcpAllowedOrigins || [],
+        allowMethods: ["GET", "POST", "DELETE", "OPTIONS"],
+        allowHeaders: [
+            "Content-Type",
+            "Mcp-Session-Id",
+            "Last-Event-ID",
+            "Authorization",
+        ],
+        credentials: true,
+    }));
+    app.use("*", async (c, next) => {
         const securityContext = requestContextService.createRequestContext({
             ...transportContext,
             operation: "securityMiddleware",
-            path: req.path,
-            method: req.method,
-            origin: req.headers.origin,
+            path: c.req.path,
+            method: c.req.method,
+            origin: c.req.header("origin"),
         });
         logger.debug(`Applying security middleware...`, securityContext);
-        if (!isOriginAllowed(req, res)) {
-            logger.debug("Origin check failed, sending 403.", securityContext);
-            res.status(403).send("Forbidden: Invalid Origin");
-            return;
-        }
-        res.setHeader("X-Content-Type-Options", "nosniff");
-        res.setHeader("Referrer-Policy", "strict-origin-when-cross-origin");
-        res.setHeader("Content-Security-Policy", "default-src 'self'; script-src 'self'; object-src 'none'; style-src 'self'; img-src 'self'; media-src 'self'; frame-src 'none'; font-src 'self'; connect-src 'self'");
+        c.res.headers.set("X-Content-Type-Options", "nosniff");
+        c.res.headers.set("Referrer-Policy", "strict-origin-when-cross-origin");
+        c.res.headers.set("Content-Security-Policy", "default-src 'self'; script-src 'self'; object-src 'none'; style-src 'self'; img-src 'self'; media-src 'self'; frame-src 'none'; font-src 'self'; connect-src 'self'");
         logger.debug("Security middleware passed.", securityContext);
-        next();
+        await next();
     });
-    app.use(mcpAuthMiddleware);
-    app.post(MCP_ENDPOINT_PATH, async (req, res) => {
+    app.use(MCP_ENDPOINT_PATH, async (c, next) => {
+        const xff = c.req.header("x-forwarded-for");
+        const clientIp = xff ? xff.split(",")[0].trim() : "unknown_ip";
+        const rateLimitKey = clientIp || c.req.header("host") || "unknown_ip_for_rate_limit";
+        const context = requestContextService.createRequestContext({
+            operation: "httpRateLimitCheck",
+            ipAddress: rateLimitKey,
+            method: c.req.method,
+            path: c.req.path,
+        });
+        try {
+            rateLimiter.check(rateLimitKey, context);
+            logger.debug("Rate limit check passed.", context);
+            await next();
+        }
+        catch (error) {
+            if (error instanceof McpError &&
+                error.code === BaseErrorCode.RATE_LIMITED) {
+                logger.warning(`Rate limit exceeded for IP: ${rateLimitKey}`, {
+                    ...context,
+                    errorMessage: error.message,
+                    details: error.details,
+                });
+                return c.json({
+                    jsonrpc: "2.0",
+                    error: { code: -32000, message: "Too Many Requests" },
+                    id: (await c.req.json().catch(() => ({})))?.id || null,
+                }, 429);
+            }
+            else {
+                logger.error("Unexpected error in rate limit middleware", {
+                    ...context,
+                    error: error instanceof Error ? error.message : String(error),
+                });
+                throw error;
+            }
+        }
+    });
+    // Use the appropriate authentication middleware based on config
+    if (config.mcpAuthMode === "oauth") {
+        app.use(MCP_ENDPOINT_PATH, oauthMiddleware);
+    }
+    else {
+        app.use(MCP_ENDPOINT_PATH, mcpAuthMiddleware);
+    }
+    app.post(MCP_ENDPOINT_PATH, async (c) => {
         const basePostContext = requestContextService.createRequestContext({
             ...transportContext,
             operation: "handlePost",
             method: "POST",
-            path: req.path,
-            origin: req.headers.origin,
+            path: c.req.path,
+            origin: c.req.header("origin"),
         });
+        const body = await c.req.json();
         logger.debug(`Received POST request on ${MCP_ENDPOINT_PATH}`, {
             ...basePostContext,
-            headers: req.headers,
-            bodyPreview: JSON.stringify(req.body).substring(0, 100),
+            headers: c.req.header(),
+            bodyPreview: JSON.stringify(body).substring(0, 100),
         });
-        const sessionId = req.headers["mcp-session-id"];
+        const sessionId = c.req.header("mcp-session-id");
         logger.debug(`Extracted session ID: ${sessionId}`, {
             ...basePostContext,
             sessionId,
         });
         let transport = sessionId ? httpTransports[sessionId] : undefined;
+        if (transport && sessionId) {
+            sessionActivity[sessionId] = Date.now(); // Update activity timestamp
+        }
         logger.debug(`Found existing transport for session ID: ${!!transport}`, {
             ...basePostContext,
             sessionId,
         });
-        const isInitReq = isInitializeRequest(req.body);
+        const isInitReq = isInitializeRequest(body);
         logger.debug(`Is InitializeRequest: ${isInitReq}`, {
             ...basePostContext,
             sessionId,
         });
-        const requestId = req.body?.id || null;
+        const requestId = body?.id || null;
         try {
             if (isInitReq) {
                 if (transport) {
                     logger.warning("Received InitializeRequest on an existing session ID. Closing old session and creating new.", { ...basePostContext, sessionId });
                     await transport.close();
-                    delete httpTransports[sessionId];
+                    // onclose handler will delete from httpTransports and sessionActivity
                 }
                 logger.info("Handling Initialize Request: Creating new session...", {
                     ...basePostContext,
@@ -306,6 +350,7 @@ export async function startHttpTransport(createServerInstanceFn, parentContext)
                     onsessioninitialized: (newId) => {
                         logger.debug(`Session initialized callback triggered for ID: ${newId}`, { ...basePostContext, newSessionId: newId });
                         httpTransports[newId] = transport;
+                        sessionActivity[newId] = Date.now(); // Initialize activity timestamp
                         logger.info(`HTTP Session created: ${newId}`, {
                             ...basePostContext,
                             newSessionId: newId,
@@ -317,6 +362,7 @@ export async function startHttpTransport(createServerInstanceFn, parentContext)
                     if (closedSessionId) {
                         logger.debug(`onclose handler triggered for session ID: ${closedSessionId}`, { ...basePostContext, closedSessionId });
                         delete httpTransports[closedSessionId];
+                        delete sessionActivity[closedSessionId]; // Clean up activity tracker
                         logger.info(`HTTP Session closed: ${closedSessionId}`, {
                             ...basePostContext,
                             closedSessionId,
@@ -334,17 +380,17 @@ export async function startHttpTransport(createServerInstanceFn, parentContext)
             }
             else if (!transport) {
                 logger.warning("Invalid or missing session ID for non-initialize POST request.", { ...basePostContext, sessionId });
-                res.status(404).json({
+                return c.json({
                     jsonrpc: "2.0",
                     error: { code: -32004, message: "Invalid or expired session ID" },
                     id: requestId,
-                });
-                return;
+                }, 404);
             }
             const currentSessionId = transport.sessionId;
             logger.debug(`Processing POST request content for session ${currentSessionId}...`, { ...basePostContext, sessionId: currentSessionId, isInitReq });
-            await transport.handleRequest(req, res, req.body);
+            const response = await transport.handleRequest(c.env.incoming, c.env.outgoing, body);
             logger.debug(`Finished processing POST request content for session ${currentSessionId}.`, { ...basePostContext, sessionId: currentSessionId });
+            return response;
         }
         catch (err) {
             const errorSessionId = transport?.sessionId || sessionId;
@@ -355,16 +401,6 @@ export async function startHttpTransport(createServerInstanceFn, parentContext)
                 error: err instanceof Error ? err.message : String(err),
                 stack: err instanceof Error ? err.stack : undefined,
             });
-            if (!res.headersSent) {
-                res.status(500).json({
-                    jsonrpc: "2.0",
-                    error: {
-                        code: -32603,
-                        message: "Internal server error during POST handling",
-                    },
-                    id: requestId,
-                });
-            }
             if (isInitReq && transport && !transport.sessionId) {
                 logger.debug("Cleaning up transport after initialization failure.", {
                     ...basePostContext,
@@ -376,27 +412,38 @@ export async function startHttpTransport(createServerInstanceFn, parentContext)
                     closeError: closeErr,
                 }));
             }
+            return c.json({
+                jsonrpc: "2.0",
+                error: {
+                    code: -32603,
+                    message: "Internal server error during POST handling",
+                },
+                id: requestId,
+            }, 500);
         }
     });
-    const handleSessionReq = async (req, res) => {
-        const method = req.method;
+    const handleSessionReq = async (c) => {
+        const method = c.req.method;
         const baseSessionReqContext = requestContextService.createRequestContext({
             ...transportContext,
             operation: `handle${method}`,
             method,
-            path: req.path,
-            origin: req.headers.origin,
+            path: c.req.path,
+            origin: c.req.header("origin"),
         });
         logger.debug(`Received ${method} request on ${MCP_ENDPOINT_PATH}`, {
             ...baseSessionReqContext,
-            headers: req.headers,
+            headers: c.req.header(),
         });
-        const sessionId = req.headers["mcp-session-id"];
+        const sessionId = c.req.header("mcp-session-id");
         logger.debug(`Extracted session ID: ${sessionId}`, {
             ...baseSessionReqContext,
             sessionId,
         });
         const transport = sessionId ? httpTransports[sessionId] : undefined;
+        if (transport && sessionId) {
+            sessionActivity[sessionId] = Date.now(); // Update activity timestamp
+        }
         logger.debug(`Found existing transport for session ID: ${!!transport}`, {
             ...baseSessionReqContext,
             sessionId,
@@ -406,17 +453,17 @@ export async function startHttpTransport(createServerInstanceFn, parentContext)
                 ...baseSessionReqContext,
                 sessionId,
             });
-            res.status(404).json({
+            return c.json({
                 jsonrpc: "2.0",
                 error: { code: -32004, message: "Session not found or expired" },
-                id: null, // Or a relevant request identifier if available from context
-            });
-            return;
+                id: null,
+            }, 404);
         }
         try {
             logger.debug(`Delegating ${method} request to transport for session ${sessionId}...`, { ...baseSessionReqContext, sessionId });
-            await transport.handleRequest(req, res);
+            const response = await transport.handleRequest(c.env.incoming, c.env.outgoing);
             logger.info(`Successfully handled ${method} request for session ${sessionId}`, { ...baseSessionReqContext, sessionId });
+            return response;
         }
         catch (err) {
             logger.error(`Error handling ${method} request for session ${sessionId}`, {
@@ -425,33 +472,20 @@ export async function startHttpTransport(createServerInstanceFn, parentContext)
                 error: err instanceof Error ? err.message : String(err),
                 stack: err instanceof Error ? err.stack : undefined,
             });
-            if (!res.headersSent) {
-                res.status(500).json({
-                    jsonrpc: "2.0",
-                    error: { code: -32603, message: "Internal Server Error" },
-                    id: null, // Or a relevant request identifier
-                });
-            }
+            return c.json({
+                jsonrpc: "2.0",
+                error: { code: -32603, message: "Internal Server Error" },
+                id: null,
+            }, 500);
         }
     };
     app.get(MCP_ENDPOINT_PATH, handleSessionReq);
     app.delete(MCP_ENDPOINT_PATH, handleSessionReq);
     logger.debug("Creating HTTP server instance...", transportContext);
-    const serverInstance = http.createServer(app);
     try {
         logger.debug("Attempting to start HTTP server with retry logic...", transportContext);
-        const actualPort = await startHttpServerWithRetry(serverInstance, config.mcpHttpPort, config.mcpHttpHost, MAX_PORT_RETRIES, transportContext);
-        let serverAddressLog = `http://${config.mcpHttpHost}:${actualPort}${MCP_ENDPOINT_PATH}`;
-        let productionNote = "";
-        if (config.environment === "production") {
-            // The server itself runs HTTP, but it's expected to be behind an HTTPS proxy in production.
-            // The log reflects the effective public-facing URL.
-            serverAddressLog = `https://${config.mcpHttpHost}:${actualPort}${MCP_ENDPOINT_PATH}`;
-            productionNote = ` (via HTTPS, ensure reverse proxy is configured)`;
-        }
-        if (process.stdout.isTTY) {
-            console.log(`\n🚀 MCP Server running in HTTP mode at: ${serverAddressLog}${productionNote}\n   (MCP Spec: 2025-03-26 Streamable HTTP Transport)\n`);
-        }
+        const serverInstance = await startHttpServerWithRetry(app, config.mcpHttpPort, config.mcpHttpHost, MAX_PORT_RETRIES, transportContext);
+        return serverInstance;
     }
     catch (err) {
         logger.fatal("HTTP server failed to start after multiple port retries.", {

package/dist/services/NCBI/ncbiCoreApiClient.js

@@ -13,11 +13,6 @@ export class NcbiCoreApiClient {
         this.axiosInstance = axios.create({
             timeout: 30000, // 30 seconds timeout for NCBI requests
         });
-        logger.debug("NcbiCoreApiClient initialized", requestContextService.createRequestContext({
-            service: "NcbiCoreApiClient",
-            ncbiBaseUrl: NCBI_EUTILS_BASE_URL,
-            maxRetries: config.ncbiMaxRetries,
-        }));
     }
     /**
      * Makes an HTTP request to the specified NCBI E-utility endpoint.

package/dist/services/NCBI/ncbiRequestQueueManager.js

@@ -9,10 +9,8 @@ export class NcbiRequestQueueManager {
         this.requestQueue = [];
         this.isProcessingQueue = false;
         this.lastRequestTime = 0;
-        logger.debug("NcbiRequestQueueManager initialized", requestContextService.createRequestContext({
-            service: "NcbiRequestQueueManager",
-            requestDelay: config.ncbiRequestDelayMs,
-        }));
+        // Constructor should not have side-effects like logging.
+        // The service that uses this manager can log its creation if needed.
     }
     /**
      * Processes the request queue, ensuring delays between requests to respect NCBI rate limits.

package/dist/services/NCBI/ncbiResponseHandler.js

@@ -32,9 +32,6 @@ export class NcbiResponseHandler {
                 return arrayTags.includes(jpath);
             },
         });
-        logger.debug("NcbiResponseHandler initialized", requestContextService.createRequestContext({
-            service: "NcbiResponseHandler",
-        }));
     }
     extractNcbiErrorMessages(parsedXml) {
         const messages = [];

package/dist/services/NCBI/ncbiService.d.ts

@@ -21,4 +21,4 @@ export declare class NcbiService {
     eLink(params: NcbiRequestParams, context: RequestContext): Promise<any>;
     eInfo(params: NcbiRequestParams, context: RequestContext): Promise<any>;
 }
-export declare const ncbiService: NcbiService;
+export declare function getNcbiService(): NcbiService;

package/dist/services/NCBI/ncbiService.js

@@ -16,9 +16,6 @@ export class NcbiService {
         this.queueManager = new NcbiRequestQueueManager();
         this.apiClient = new NcbiCoreApiClient();
         this.responseHandler = new NcbiResponseHandler();
-        logger.debug("NcbiService initialized with new modular architecture", requestContextService.createRequestContext({
-            service: "NcbiService",
-        }));
     }
     async performNcbiRequest(endpoint, params, context, options = {}) {
         const task = async () => {
@@ -54,4 +51,14 @@ export class NcbiService {
         });
     }
 }
-export const ncbiService = new NcbiService();
+let ncbiServiceInstance;
+export function getNcbiService() {
+    if (!ncbiServiceInstance) {
+        ncbiServiceInstance = new NcbiService();
+        logger.debug("NcbiService lazily initialized.", requestContextService.createRequestContext({
+            service: "NcbiService",
+            operation: "getNcbiServiceInstance",
+        }));
+    }
+    return ncbiServiceInstance;
+}