@dangao/bun-server 2.1.0 → 2.3.0

package/dist/index.js

@@ -1769,6 +1769,88 @@ var init_types = __esm(() => {
   })(Lifecycle ||= {});
 });
 
+// src/di/lifecycle.ts
+function hasOnModuleInit(instance) {
+  return instance !== null && instance !== undefined && typeof instance === "object" && "onModuleInit" in instance && typeof instance.onModuleInit === "function";
+}
+function hasOnModuleDestroy(instance) {
+  return instance !== null && instance !== undefined && typeof instance === "object" && "onModuleDestroy" in instance && typeof instance.onModuleDestroy === "function";
+}
+function hasOnApplicationBootstrap(instance) {
+  return instance !== null && instance !== undefined && typeof instance === "object" && "onApplicationBootstrap" in instance && typeof instance.onApplicationBootstrap === "function";
+}
+function hasOnApplicationShutdown(instance) {
+  return instance !== null && instance !== undefined && typeof instance === "object" && "onApplicationShutdown" in instance && typeof instance.onApplicationShutdown === "function";
+}
+function hasComponentBeforeCreate(target) {
+  return target !== null && target !== undefined && typeof target === "function" && "onBeforeCreate" in target && typeof target.onBeforeCreate === "function";
+}
+function hasOnAfterCreate(instance) {
+  return instance !== null && instance !== undefined && typeof instance === "object" && "onAfterCreate" in instance && typeof instance.onAfterCreate === "function";
+}
+function hasOnBeforeDestroy(instance) {
+  return instance !== null && instance !== undefined && typeof instance === "object" && "onBeforeDestroy" in instance && typeof instance.onBeforeDestroy === "function";
+}
+function hasOnAfterDestroy(instance) {
+  return instance !== null && instance !== undefined && typeof instance === "object" && "onAfterDestroy" in instance && typeof instance.onAfterDestroy === "function";
+}
+function callComponentBeforeCreate(target) {
+  if (hasComponentBeforeCreate(target)) {
+    target.onBeforeCreate();
+  }
+}
+function callOnAfterCreate(instance) {
+  if (hasOnAfterCreate(instance)) {
+    instance.onAfterCreate();
+  }
+}
+async function callOnModuleInit(instances) {
+  for (const instance of instances) {
+    if (hasOnModuleInit(instance)) {
+      await instance.onModuleInit();
+    }
+  }
+}
+async function callOnApplicationBootstrap(instances) {
+  for (const instance of instances) {
+    if (hasOnApplicationBootstrap(instance)) {
+      await instance.onApplicationBootstrap();
+    }
+  }
+}
+async function callOnModuleDestroy(instances) {
+  for (let i = instances.length - 1;i >= 0; i--) {
+    const instance = instances[i];
+    if (hasOnModuleDestroy(instance)) {
+      await instance.onModuleDestroy();
+    }
+  }
+}
+async function callOnApplicationShutdown(instances, signal) {
+  for (let i = instances.length - 1;i >= 0; i--) {
+    const instance = instances[i];
+    if (hasOnApplicationShutdown(instance)) {
+      await instance.onApplicationShutdown(signal);
+    }
+  }
+}
+async function callOnBeforeDestroy(instances) {
+  for (let i = instances.length - 1;i >= 0; i--) {
+    const instance = instances[i];
+    if (hasOnBeforeDestroy(instance)) {
+      await instance.onBeforeDestroy();
+    }
+  }
+}
+async function callOnAfterDestroy(instances) {
+  for (let i = instances.length - 1;i >= 0; i--) {
+    const instance = instances[i];
+    if (hasOnAfterDestroy(instance)) {
+      await instance.onAfterDestroy();
+    }
+  }
+}
+
 // src/di/container.ts
 import"reflect-metadata";
 import { LoggerManager as LoggerManager5 } from "@dangao/logsmith";
@@ -1951,6 +2033,7 @@ class Container {
     throw new Error(`Invalid token type: ${tokenType}. Token: ${String(token)}`);
   }
   instantiate(constructor) {
+    callComponentBeforeCreate(constructor);
     const plan = this.getDependencyPlan(constructor);
     let instance;
     if (plan.paramLength === 0) {
@@ -1962,7 +2045,9 @@ class Container {
       }
       instance = new constructor(...dependencies);
     }
-    return this.applyPostProcessors(instance, constructor);
+    const processed = this.applyPostProcessors(instance, constructor);
+    callOnAfterCreate(processed);
+    return processed;
   }
   getTokenKey(token) {
     if (typeof token === "function") {
@@ -1977,6 +2062,34 @@ class Container {
     this.dependencyPlans.clear();
     this.postProcessors.length = 0;
   }
+  getScopedInstances(context) {
+    const scopedMap = this.scopedInstances.get(context);
+    if (!scopedMap || scopedMap.size === 0) {
+      return [];
+    }
+    const seen = new Set;
+    const instances = [];
+    for (const instance of scopedMap.values()) {
+      if (!seen.has(instance)) {
+        seen.add(instance);
+        instances.push(instance);
+      }
+    }
+    return instances;
+  }
+  clearScopedInstances(context) {
+    this.scopedInstances.delete(context);
+  }
+  async disposeScopedInstances(context) {
+    const instances = this.getScopedInstances(context);
+    if (instances.length === 0) {
+      return;
+    }
+    await callOnBeforeDestroy(instances);
+    await callOnModuleDestroy(instances);
+    await callOnAfterDestroy(instances);
+    this.clearScopedInstances(context);
+  }
   isRegistered(token) {
     const tokenKey = this.getTokenKey(token);
     return this.providers.has(tokenKey);
@@ -4041,6 +4154,7 @@ class Context {
   files = [];
   _body;
   _bodyParsed = false;
+  signal;
   constructor(request) {
     this.request = request;
     this.url = new URL2(request.url);
@@ -4049,6 +4163,7 @@ class Context {
     this.query = this.url.searchParams;
     this.headers = request.headers;
     this.responseHeaders = new Headers;
+    this.signal = request.signal;
   }
   async getBody() {
     if (!this._bodyParsed) {
@@ -4194,7 +4309,27 @@ class BunServer {
     this.isShuttingDown = false;
     this.shutdownPromise = undefined;
     this.shutdownResolve = undefined;
-    const fetchHandler = (request, server) => {
+    const sseKeepAlive = this.options.sseKeepAlive;
+    const sseHeartbeatEnabled = sseKeepAlive?.enabled !== false;
+    const sseHeartbeatIntervalMs = sseKeepAlive?.intervalMs ?? 15000;
+    const postProcessSse = (response, request, bunServer) => {
+      const ct = response.headers.get("content-type");
+      if (!ct?.includes("text/event-stream")) {
+        return response;
+      }
+      bunServer.timeout(request, 0);
+      if (sseHeartbeatEnabled && response.body) {
+        return BunServer.wrapSseWithHeartbeat(response, sseHeartbeatIntervalMs, request.signal);
+      }
+      return response;
+    };
+    const decrementAndMaybeShutdown = () => {
+      this.activeRequests--;
+      if (this.isShuttingDown && this.activeRequests === 0 && this.shutdownResolve) {
+        this.shutdownResolve();
+      }
+    };
+    const fetchHandler = (request, bunServer) => {
       if (this.isShuttingDown) {
         return new Response("Server is shutting down", { status: 503 });
       }
@@ -4206,7 +4341,7 @@ class BunServer {
         }
         const context2 = new Context(request);
         const queryParams = new URLSearchParams(url.searchParams);
-        const upgraded = server.upgrade(request, {
+        const upgraded = bunServer.upgrade(request, {
           data: {
             path: url.pathname,
             query: queryParams,
@@ -4222,19 +4357,12 @@ class BunServer {
       const context = new Context(request);
       const responsePromise = this.options.fetch(context);
       if (responsePromise instanceof Promise) {
-        responsePromise.finally(() => {
-          this.activeRequests--;
-          if (this.isShuttingDown && this.activeRequests === 0 && this.shutdownResolve) {
-            this.shutdownResolve();
-          }
-        }).catch(() => {});
-      } else {
-        this.activeRequests--;
-        if (this.isShuttingDown && this.activeRequests === 0 && this.shutdownResolve) {
-          this.shutdownResolve();
-        }
+        const processed = responsePromise.then((response) => postProcessSse(response, request, bunServer));
+        processed.finally(decrementAndMaybeShutdown).catch(() => {});
+        return processed;
       }
-      return responsePromise;
+      decrementAndMaybeShutdown();
+      return postProcessSse(responsePromise, request, bunServer);
     };
     const websocketHandlers = {
       open: async (ws) => {
@@ -4332,6 +4460,68 @@ class BunServer {
   getHostname() {
     return this.options.hostname;
   }
+  static wrapSseWithHeartbeat(original, intervalMs, signal) {
+    const encoder = new TextEncoder;
+    const keepaliveChunk = encoder.encode(`: keepalive
+
+`);
+    const originalBody = original.body;
+    let heartbeat;
+    let reader;
+    const wrapped = new ReadableStream({
+      start(controller) {
+        reader = originalBody.getReader();
+        heartbeat = setInterval(() => {
+          try {
+            controller.enqueue(keepaliveChunk);
+          } catch {
+            clearInterval(heartbeat);
+            heartbeat = undefined;
+          }
+        }, intervalMs);
+        const onAbort = () => {
+          if (heartbeat) {
+            clearInterval(heartbeat);
+            heartbeat = undefined;
+          }
+        };
+        signal.addEventListener("abort", onAbort, { once: true });
+        const pump = async () => {
+          try {
+            while (true) {
+              const { done, value } = await reader.read();
+              if (done)
+                break;
+              controller.enqueue(value);
+            }
+            controller.close();
+          } catch (err) {
+            try {
+              controller.error(err);
+            } catch {}
+          } finally {
+            if (heartbeat) {
+              clearInterval(heartbeat);
+              heartbeat = undefined;
+            }
+            signal.removeEventListener("abort", onAbort);
+          }
+        };
+        pump();
+      },
+      cancel() {
+        if (heartbeat) {
+          clearInterval(heartbeat);
+          heartbeat = undefined;
+        }
+        reader?.cancel();
+      }
+    });
+    return new Response(wrapped, {
+      status: original.status,
+      headers: original.headers
+    });
+  }
 }
 
 // src/core/application.ts
@@ -4570,51 +4760,6 @@ init_types();
 init_module();
 init_decorators();
 
-// src/di/lifecycle.ts
-function hasOnModuleInit(instance) {
-  return instance !== null && instance !== undefined && typeof instance === "object" && "onModuleInit" in instance && typeof instance.onModuleInit === "function";
-}
-function hasOnModuleDestroy(instance) {
-  return instance !== null && instance !== undefined && typeof instance === "object" && "onModuleDestroy" in instance && typeof instance.onModuleDestroy === "function";
-}
-function hasOnApplicationBootstrap(instance) {
-  return instance !== null && instance !== undefined && typeof instance === "object" && "onApplicationBootstrap" in instance && typeof instance.onApplicationBootstrap === "function";
-}
-function hasOnApplicationShutdown(instance) {
-  return instance !== null && instance !== undefined && typeof instance === "object" && "onApplicationShutdown" in instance && typeof instance.onApplicationShutdown === "function";
-}
-async function callOnModuleInit(instances) {
-  for (const instance of instances) {
-    if (hasOnModuleInit(instance)) {
-      await instance.onModuleInit();
-    }
-  }
-}
-async function callOnApplicationBootstrap(instances) {
-  for (const instance of instances) {
-    if (hasOnApplicationBootstrap(instance)) {
-      await instance.onApplicationBootstrap();
-    }
-  }
-}
-async function callOnModuleDestroy(instances) {
-  for (let i = instances.length - 1;i >= 0; i--) {
-    const instance = instances[i];
-    if (hasOnModuleDestroy(instance)) {
-      await instance.onModuleDestroy();
-    }
-  }
-}
-async function callOnApplicationShutdown(instances, signal) {
-  for (let i = instances.length - 1;i >= 0; i--) {
-    const instance = instances[i];
-    if (hasOnApplicationShutdown(instance)) {
-      await instance.onApplicationShutdown(signal);
-    }
-  }
-}
-
-// src/di/module-registry.ts
 class ModuleRegistry {
   static instance;
   moduleRefs = new Map;
@@ -4771,7 +4916,7 @@ class ModuleRegistry {
     }
     return moduleRef.middlewares;
   }
-  resolveAllProviderInstances() {
+  resolveAllComponentInstances() {
     const instances = [];
     const seen = new Set;
     for (const [, ref] of this.moduleRefs) {
@@ -4804,25 +4949,62 @@ class ModuleRegistry {
           }
         } catch (_error) {}
       }
+      for (const controller of ref.metadata.controllers) {
+        try {
+          const instance = ref.container.resolve(controller);
+          if (!seen.has(instance)) {
+            seen.add(instance);
+            instances.push(instance);
+          }
+        } catch (_error) {}
+      }
     }
     return instances;
   }
   async callModuleInitHooks() {
-    const instances = this.resolveAllProviderInstances();
+    const instances = this.resolveAllComponentInstances();
     await callOnModuleInit(instances);
   }
   async callBootstrapHooks() {
-    const instances = this.resolveAllProviderInstances();
+    const instances = this.resolveAllComponentInstances();
     await callOnApplicationBootstrap(instances);
   }
   async callModuleDestroyHooks() {
-    const instances = this.resolveAllProviderInstances();
+    const instances = this.resolveAllComponentInstances();
+    await callOnBeforeDestroy(instances);
     await callOnModuleDestroy(instances);
+    await callOnAfterDestroy(instances);
   }
   async callShutdownHooks(signal) {
-    const instances = this.resolveAllProviderInstances();
+    const instances = this.resolveAllComponentInstances();
     await callOnApplicationShutdown(instances, signal);
   }
+  async disposeScopedInstances(context) {
+    const containers = [];
+    if (this.rootContainer) {
+      containers.push(this.rootContainer);
+    }
+    containers.push(...this.getAllModuleContainers());
+    const instances = [];
+    const seen = new Set;
+    for (const container of containers) {
+      const scopedInstances = container.getScopedInstances(context);
+      for (const instance of scopedInstances) {
+        if (!seen.has(instance)) {
+          seen.add(instance);
+          instances.push(instance);
+        }
+      }
+    }
+    if (instances.length > 0) {
+      await callOnBeforeDestroy(instances);
+      await callOnModuleDestroy(instances);
+      await callOnAfterDestroy(instances);
+    }
+    for (const container of containers) {
+      container.clearScopedInstances(context);
+    }
+  }
   registerExport(parentContainer, moduleRef, token) {
     if (!moduleRef.container.isRegistered(token)) {
       throw new Error(`Module ${moduleRef.moduleClass.name} cannot export ${typeof token === "function" ? token.name : String(token)} because it is not registered`);
@@ -6570,6 +6752,7 @@ class Application {
       hostname: finalHostname,
       reusePort: this.options.reusePort,
       idleTimeout: this.options.idleTimeout,
+      sseKeepAlive: this.options.sseKeepAlive,
       fetch: this.handleRequest.bind(this),
       websocketRegistry: this.websocketRegistry,
       gracefulShutdownTimeout: this.options.gracefulShutdownTimeout
@@ -6649,30 +6832,43 @@ class Application {
   }
   async handleRequest(context) {
     const logger = LoggerManager11.getLogger();
+    const moduleRegistry = ModuleRegistry.getInstance();
     logger.debug("[Request] Incoming", {
       method: context.method,
       path: context.path,
       url: context.url?.href
     });
     return await contextStore.run(context, async () => {
-      if (["POST", "PUT", "PATCH"].includes(context.method)) {
-        await context.getBody();
-      }
-      const registry = RouteRegistry.getInstance();
-      const router = registry.getRouter();
-      await router.preHandle(context);
-      return await this.middlewarePipeline.run(context, async () => {
-        const response = await router.handle(context);
-        if (response) {
-          return response;
+      try {
+        if (["POST", "PUT", "PATCH"].includes(context.method)) {
+          await context.getBody();
         }
-        logger.debug("[Router] No route matched", {
-          method: context.method,
-          path: context.path
+        const registry = RouteRegistry.getInstance();
+        const router = registry.getRouter();
+        await router.preHandle(context);
+        return await this.middlewarePipeline.run(context, async () => {
+          const response = await router.handle(context);
+          if (response) {
+            return response;
+          }
+          logger.debug("[Router] No route matched", {
+            method: context.method,
+            path: context.path
+          });
+          context.setStatus(404);
+          return context.createErrorResponse({ error: "Not Found" });
         });
-        context.setStatus(404);
-        return context.createErrorResponse({ error: "Not Found" });
-      });
+      } finally {
+        try {
+          await moduleRegistry.disposeScopedInstances(context);
+        } catch (error) {
+          logger.warn("[Application] Failed to dispose scoped instances", {
+            path: context.path,
+            method: context.method,
+            errorMessage: error instanceof Error ? error.message : String(error)
+          });
+        }
+      }
     });
   }
   registerController(controllerClass) {
@@ -13864,7 +14060,7 @@ class AiService {
     const fallback = this.options.fallback ?? false;
     const timeout = this.options.timeout ?? 30000;
     if (!fallback) {
-      return this.withTimeout(this.getProvider(targetName).complete(request), timeout, targetName);
+      return this.withTimeout(this.getProvider(targetName).complete(request), timeout, targetName, request.signal);
     }
     const names = [
       targetName,
@@ -13876,21 +14072,32 @@ class AiService {
         const provider = this.providers.get(name);
         if (!provider)
           continue;
-        return await this.withTimeout(provider.complete({ ...request, provider: name }), timeout, name);
+        return await this.withTimeout(provider.complete({ ...request, provider: name }), timeout, name, request.signal);
       } catch (err) {
         errors.push(`${name}: ${err instanceof Error ? err.message : String(err)}`);
       }
     }
     throw new AiAllProvidersFailed(errors);
   }
-  withTimeout(promise, ms, providerName) {
+  withTimeout(promise, ms, providerName, signal) {
     return new Promise((resolve2, reject) => {
+      if (signal?.aborted) {
+        reject(signal.reason ?? new Error("Aborted"));
+        return;
+      }
       const timer = setTimeout(() => reject(new AiTimeoutError(providerName, ms)), ms);
+      const onAbort = () => {
+        clearTimeout(timer);
+        reject(signal.reason ?? new Error("Aborted"));
+      };
+      signal?.addEventListener("abort", onAbort, { once: true });
       promise.then((val) => {
         clearTimeout(timer);
+        signal?.removeEventListener("abort", onAbort);
         resolve2(val);
       }, (err) => {
         clearTimeout(timer);
+        signal?.removeEventListener("abort", onAbort);
         reject(err);
       });
     });
@@ -14016,7 +14223,7 @@ class OpenAIProvider {
         function: { name: t.name, description: t.description, parameters: t.parameters }
       }));
     }
-    const response = await this.post("/chat/completions", body);
+    const response = await this.post("/chat/completions", body, request.signal);
     const choice = response.choices?.[0];
     const usage = response.usage ?? { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 };
     const message = choice?.message;
@@ -14056,6 +14263,7 @@ class OpenAIProvider {
     const encoder = new TextEncoder;
     const apiKey = this.apiKey;
     const baseUrl = this.baseUrl;
+    const signal = request.signal;
     return new ReadableStream({
       async start(controller2) {
         try {
@@ -14065,7 +14273,8 @@ class OpenAIProvider {
               "Content-Type": "application/json",
               Authorization: `Bearer ${apiKey}`
             },
-            body: JSON.stringify(body)
+            body: JSON.stringify(body),
+            signal
           });
           if (!res.ok || !res.body) {
             const err = await res.text();
@@ -14119,14 +14328,15 @@ class OpenAIProvider {
   countTokens(messages) {
     return Math.ceil(messages.reduce((sum, m) => sum + m.content.length, 0) / 4);
   }
-  async post(path, body) {
+  async post(path, body, signal) {
     const res = await fetch(`${this.baseUrl}${path}`, {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
         Authorization: `Bearer ${this.apiKey}`
       },
-      body: JSON.stringify(body)
+      body: JSON.stringify(body),
+      signal
     });
     if (res.status === 429) {
       const retryAfter = res.headers.get("retry-after");
@@ -14202,7 +14412,7 @@ class AnthropicProvider {
         input_schema: t.parameters
       }));
     }
-    const response = await this.post("/v1/messages", body);
+    const response = await this.post("/v1/messages", body, request.signal);
     const usage = response["usage"] ?? { input_tokens: 0, output_tokens: 0 };
     let content = "";
     const toolCalls = [];
@@ -14250,6 +14460,7 @@ class AnthropicProvider {
     const baseUrl = this.baseUrl;
     const anthropicVersion = this.anthropicVersion;
     const encoder = new TextEncoder;
+    const signal = request.signal;
     return new ReadableStream({
       async start(controller2) {
         try {
@@ -14260,7 +14471,8 @@ class AnthropicProvider {
               "x-api-key": apiKey,
               "anthropic-version": anthropicVersion
             },
-            body: JSON.stringify(body)
+            body: JSON.stringify(body),
+            signal
           });
           if (!res.ok || !res.body) {
             controller2.enqueue(encoder.encode(`data: ${JSON.stringify({ error: await res.text(), done: true })}
@@ -14310,7 +14522,7 @@ class AnthropicProvider {
   countTokens(messages) {
     return Math.ceil(messages.reduce((sum, m) => sum + m.content.length, 0) / 4);
   }
-  async post(path, body) {
+  async post(path, body, signal) {
     const res = await fetch(`${this.baseUrl}${path}`, {
       method: "POST",
       headers: {
@@ -14318,7 +14530,8 @@ class AnthropicProvider {
         "x-api-key": this.apiKey,
         "anthropic-version": this.anthropicVersion
       },
-      body: JSON.stringify(body)
+      body: JSON.stringify(body),
+      signal
     });
     if (res.status === 429)
       throw new AiRateLimitError(this.name);
@@ -14351,7 +14564,8 @@ class OllamaProvider {
           temperature: request.temperature,
           num_predict: request.maxTokens
         }
-      })
+      }),
+      signal: request.signal
     });
     if (!res.ok) {
       throw new AiProviderError(await res.text(), this.name, res.status);
@@ -14376,6 +14590,7 @@ class OllamaProvider {
     const model = request.model ?? this.defaultModel;
     const baseUrl = this.baseUrl;
     const encoder = new TextEncoder;
+    const signal = request.signal;
     return new ReadableStream({
       async start(controller2) {
         try {
@@ -14390,7 +14605,8 @@ class OllamaProvider {
                 temperature: request.temperature,
                 num_predict: request.maxTokens
               }
-            })
+            }),
+            signal
           });
           if (!res.ok || !res.body) {
             controller2.enqueue(encoder.encode(`data: ${JSON.stringify({ error: await res.text(), done: true })}
@@ -14472,7 +14688,8 @@ class GoogleProvider {
     const res = await fetch(`${this.baseUrl}/models/${model}:generateContent?key=${this.apiKey}`, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
-      body: JSON.stringify(body)
+      body: JSON.stringify(body),
+      signal: request.signal
     });
     if (res.status === 429)
       throw new AiRateLimitError(this.name);
@@ -14515,6 +14732,7 @@ class GoogleProvider {
     const apiKey = this.apiKey;
     const baseUrl = this.baseUrl;
     const encoder = new TextEncoder;
+    const signal = request.signal;
     const body = {
       contents,
       generationConfig: { temperature: request.temperature, maxOutputTokens: request.maxTokens }
@@ -14527,7 +14745,8 @@ class GoogleProvider {
           const res = await fetch(`${baseUrl}/models/${model}:streamGenerateContent?key=${apiKey}&alt=sse`, {
             method: "POST",
             headers: { "Content-Type": "application/json" },
-            body: JSON.stringify(body)
+            body: JSON.stringify(body),
+            signal
           });
           if (!res.ok || !res.body) {
             controller2.enqueue(encoder.encode(`data: ${JSON.stringify({ error: await res.text(), done: true })}
@@ -15891,8 +16110,6 @@ class McpServer {
     });
   }
   createSseResponse() {
-    const registry = this.registry;
-    const serverInfo = this.serverInfo;
     const encoder = new TextEncoder;
     const stream = new ReadableStream({
       start(controller2) {
@@ -15904,15 +16121,6 @@ data: ${JSON.stringify({
 
 `;
         controller2.enqueue(encoder.encode(initEvent));
-        const pingInterval = setInterval(() => {
-          try {
-            controller2.enqueue(encoder.encode(`: ping
-
-`));
-          } catch (_error) {
-            clearInterval(pingInterval);
-          }
-        }, 15000);
       }
     });
     return new Response(stream, {
@@ -15920,7 +16128,7 @@ data: ${JSON.stringify({
         "Content-Type": "text/event-stream",
         "Cache-Control": "no-cache",
         Connection: "keep-alive",
-        "X-MCP-Server": `${serverInfo.name}/${serverInfo.version}`
+        "X-MCP-Server": `${this.serverInfo.name}/${this.serverInfo.version}`
       }
     });
   }