mcp-use 1.34.6 → 1.34.7

package/dist/src/server/index.cjs

@@ -661,7 +661,7 @@ var VERSION;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    VERSION = "1.34.6";
+    VERSION = "1.34.7";
     __name(getPackageVersion, "getPackageVersion");
   }
 });
@@ -13713,7 +13713,9 @@ async function mountMcp(app, mcpServerInstance, sessions, config, isProductionMo
     }
     const acceptHeader = c.req.header("Accept") || c.req.header("accept") || "";
     const clientSupportsSSE = acceptHeader.includes("text/event-stream");
-    const useStatelessMode = config.stateless || !clientSupportsSSE;
+    const sessionId = c.req.header("mcp-session-id");
+    const isSessionDelete = c.req.method === "DELETE" && !!sessionId;
+    const useStatelessMode = config.stateless || !clientSupportsSSE && !isSessionDelete;
     if (useStatelessMode) {
       if (c.req.method === "HEAD") {
         return new Response(null, { status: 200 });
@@ -13756,7 +13758,6 @@ async function mountMcp(app, mcpServerInstance, sessions, config, isProductionMo
         throw error2;
       }
     } else {
-      const sessionId = c.req.header("mcp-session-id");
       if (c.req.method === "HEAD") {
         if (sessionId && await sessionStore.has(sessionId)) {
           const session = await sessionStore.get(sessionId);
@@ -13775,8 +13776,8 @@ async function mountMcp(app, mcpServerInstance, sessions, config, isProductionMo
         console.log(
           `[MCP] Session metadata found but transport lost (restart/hot-reload): ${sessionId} - recovering`
         );
-        const server2 = mcpServerInstance.getServerForSession(sessionId);
-        const transport2 = new WebStandardStreamableHTTPServerTransport({
+        const server = mcpServerInstance.getServerForSession(sessionId);
+        const transport = new WebStandardStreamableHTTPServerTransport({
           sessionIdGenerator: /* @__PURE__ */ __name(() => sessionId, "sessionIdGenerator"),
           onsessioninitialized: /* @__PURE__ */ __name(async (sid) => {
             if (getDebugLevel() !== "info") {
@@ -13795,15 +13796,15 @@ async function mountMcp(app, mcpServerInstance, sessions, config, isProductionMo
             mcpServerInstance.cleanupSessionRefs?.(sid);
           }, "onsessionclosed")
         });
-        wrapTransportForStreamManager(transport2, sessionId, streamManager);
-        await server2.connect(transport2);
-        transport2._initialized = true;
-        transport2.sessionId = sessionId;
-        transports.set(sessionId, transport2);
+        wrapTransportForStreamManager(transport, sessionId, streamManager);
+        await server.connect(transport);
+        transport._initialized = true;
+        transport.sessionId = sessionId;
+        transports.set(sessionId, transport);
         const metadata = await sessionStore.get(sessionId);
         const sessionData = {
-          transport: transport2,
-          server: server2,
+          transport,
+          server,
           lastAccessedAt: Date.now(),
           context: c,
           honoContext: c,
@@ -13815,11 +13816,11 @@ async function mountMcp(app, mcpServerInstance, sessions, config, isProductionMo
         }
         const recoveryResponse = await runWithContext(
           c,
-          async () => transport2.handleRequest(c.req.raw),
+          async () => transport.handleRequest(c.req.raw),
           sessionId
         );
         if (c.req.method === "GET") {
-          await registerSseStream(transport2, sessionId, streamManager);
+          await registerSseStream(transport, sessionId, streamManager);
         }
         return recoveryResponse;
       }
@@ -13837,7 +13838,7 @@ async function mountMcp(app, mcpServerInstance, sessions, config, isProductionMo
         );
       }
       if (sessionId && transports.has(sessionId)) {
-        const transport2 = transports.get(sessionId);
+        const transport = transports.get(sessionId);
         const metadata = await sessionStore.get(sessionId);
         if (metadata) {
           metadata.lastAccessedAt = Date.now();
@@ -13854,89 +13855,122 @@ async function mountMcp(app, mcpServerInstance, sessions, config, isProductionMo
         }
         const existingResponse = await runWithContext(
           c,
-          async () => transport2.handleRequest(c.req.raw),
+          async () => transport.handleRequest(c.req.raw),
           sessionId
         );
         if (c.req.method === "GET") {
-          await registerSseStream(transport2, sessionId, streamManager);
+          await registerSseStream(transport, sessionId, streamManager);
         }
         return existingResponse;
       }
       const newSessionId = generateUUID();
-      const server = mcpServerInstance.getServerForSession(newSessionId);
-      const transport = new WebStandardStreamableHTTPServerTransport({
-        sessionIdGenerator: /* @__PURE__ */ __name(() => newSessionId, "sessionIdGenerator"),
-        onsessioninitialized: /* @__PURE__ */ __name(async (sid) => {
-          if (getDebugLevel() !== "info") {
-            console.log(`[MCP] Session initialized: ${sid}`);
-          }
-          transports.set(sid, transport);
-          const sessionData = {
-            transport,
-            server,
-            lastAccessedAt: Date.now(),
-            context: c,
-            honoContext: c
-          };
-          sessions.set(sid, sessionData);
-          await sessionStore.set(sid, {
-            lastAccessedAt: Date.now()
-          });
-          server.server.oninitialized = async () => {
-            const clientCapabilities = server.server.getClientCapabilities();
-            const clientInfo = server.server.getClientVersion?.() || server.server.getClientInfo?.() || {};
-            const protocolVersion = server.server.getProtocolVersion?.() || "unknown";
-            const metadata = await sessionStore.get(sid);
-            if (metadata) {
-              metadata.clientCapabilities = clientCapabilities;
-              metadata.clientInfo = clientInfo;
-              metadata.protocolVersion = String(protocolVersion);
-              await sessionStore.set(sid, metadata);
-              if (getDebugLevel() !== "info") {
-                console.log(
-                  `[MCP] Captured client capabilities for session ${sid}:`,
-                  clientCapabilities ? Object.keys(clientCapabilities) : "none"
-                );
+      let allocatedServer;
+      let allocatedTransport;
+      let sessionEstablished = false;
+      try {
+        const server = mcpServerInstance.getServerForSession(newSessionId);
+        allocatedServer = server;
+        const transport = new WebStandardStreamableHTTPServerTransport({
+          sessionIdGenerator: /* @__PURE__ */ __name(() => newSessionId, "sessionIdGenerator"),
+          onsessioninitialized: /* @__PURE__ */ __name(async (sid) => {
+            if (getDebugLevel() !== "info") {
+              console.log(`[MCP] Session initialized: ${sid}`);
+            }
+            transports.set(sid, transport);
+            const sessionData = {
+              transport,
+              server,
+              lastAccessedAt: Date.now(),
+              context: c,
+              honoContext: c
+            };
+            sessions.set(sid, sessionData);
+            await sessionStore.set(sid, {
+              lastAccessedAt: Date.now()
+            });
+            server.server.oninitialized = async () => {
+              const clientCapabilities = server.server.getClientCapabilities();
+              const clientInfo = server.server.getClientVersion?.() || server.server.getClientInfo?.() || {};
+              const protocolVersion = server.server.getProtocolVersion?.() || "unknown";
+              const metadata = await sessionStore.get(sid);
+              if (metadata) {
+                metadata.clientCapabilities = clientCapabilities;
+                metadata.clientInfo = clientInfo;
+                metadata.protocolVersion = String(protocolVersion);
+                await sessionStore.set(sid, metadata);
+                if (getDebugLevel() !== "info") {
+                  console.log(
+                    `[MCP] Captured client capabilities for session ${sid}:`,
+                    clientCapabilities ? Object.keys(clientCapabilities) : "none"
+                  );
+                }
               }
+              const sessionData2 = sessions.get(sid);
+              if (sessionData2) {
+                sessionData2.clientCapabilities = clientCapabilities;
+                sessionData2.clientInfo = clientInfo;
+              }
+              Telemetry.getInstance().trackServerInitialize({
+                protocolVersion: String(protocolVersion),
+                clientInfo: clientInfo || {},
+                clientCapabilities: clientCapabilities || {},
+                sessionId: sid
+              }).catch(
+                (e) => console.debug(`Failed to track server initialize: ${e}`)
+              );
+            };
+          }, "onsessioninitialized"),
+          onsessionclosed: /* @__PURE__ */ __name(async (sid) => {
+            if (getDebugLevel() !== "info") {
+              console.log(`[MCP] Session closed: ${sid}`);
             }
-            const sessionData2 = sessions.get(sid);
-            if (sessionData2) {
-              sessionData2.clientCapabilities = clientCapabilities;
-              sessionData2.clientInfo = clientInfo;
+            transports.delete(sid);
+            await streamManager.delete(sid);
+            await sessionStore.delete(sid);
+            sessions.delete(sid);
+            mcpServerInstance.cleanupSessionSubscriptions?.(sid);
+            mcpServerInstance.cleanupSessionRefs?.(sid);
+          }, "onsessionclosed")
+        });
+        allocatedTransport = transport;
+        wrapTransportForStreamManager(transport, newSessionId, streamManager);
+        await server.connect(transport);
+        const newSessionResponse = await runWithContext(
+          c,
+          async () => transport.handleRequest(c.req.raw),
+          newSessionId
+        );
+        if (c.req.method === "GET") {
+          await registerSseStream(transport, newSessionId, streamManager);
+        }
+        sessionEstablished = newSessionResponse.ok && sessions.has(newSessionId) && !c.req.raw.signal.aborted;
+        return newSessionResponse;
+      } finally {
+        if (!sessionEstablished) {
+          transports.delete(newSessionId);
+          sessions.delete(newSessionId);
+          const cleanups = await Promise.allSettled([
+            Promise.resolve().then(
+              () => mcpServerInstance.cleanupSessionSubscriptions?.(newSessionId)
+            ),
+            Promise.resolve().then(
+              () => mcpServerInstance.cleanupSessionRefs?.(newSessionId)
+            ),
+            Promise.resolve().then(() => streamManager.delete(newSessionId)),
+            Promise.resolve().then(() => sessionStore.delete(newSessionId)),
+            Promise.resolve().then(() => allocatedServer?.close()),
+            Promise.resolve().then(() => allocatedTransport?.close())
+          ]);
+          for (const cleanup of cleanups) {
+            if (cleanup.status === "rejected") {
+              console.warn(
+                `[MCP] Error cleaning up unsuccessful session ${newSessionId}:`,
+                cleanup.reason
+              );
             }
-            Telemetry.getInstance().trackServerInitialize({
-              protocolVersion: String(protocolVersion),
-              clientInfo: clientInfo || {},
-              clientCapabilities: clientCapabilities || {},
-              sessionId: sid
-            }).catch(
-              (e) => console.debug(`Failed to track server initialize: ${e}`)
-            );
-          };
-        }, "onsessioninitialized"),
-        onsessionclosed: /* @__PURE__ */ __name(async (sid) => {
-          if (getDebugLevel() !== "info") {
-            console.log(`[MCP] Session closed: ${sid}`);
           }
-          transports.delete(sid);
-          await streamManager.delete(sid);
-          await sessionStore.delete(sid);
-          sessions.delete(sid);
-          mcpServerInstance.cleanupSessionSubscriptions?.(sid);
-          mcpServerInstance.cleanupSessionRefs?.(sid);
-        }, "onsessionclosed")
-      });
-      wrapTransportForStreamManager(transport, newSessionId, streamManager);
-      await server.connect(transport);
-      const newSessionResponse = await runWithContext(
-        c,
-        async () => transport.handleRequest(c.req.raw),
-        newSessionId
-      );
-      if (c.req.method === "GET") {
-        await registerSseStream(transport, newSessionId, streamManager);
+        }
       }
-      return newSessionResponse;
     }
   }, "handleRequest");
   for (const endpoint of ["/mcp", "/sse"]) {

package/dist/src/server/index.js

@@ -17,7 +17,7 @@ import {
   findSessionContext,
   isValidLogLevel,
   supportsApps
-} from "../../chunk-DI4WNZQC.js";
+} from "../../chunk-E7PWRUQZ.js";
 import {
   getRequestContext,
   hasRequestContext,
@@ -59,8 +59,7 @@ import {
   Telemetry,
   VERSION,
   getPackageVersion
-} from "../../chunk-FOGBXW3W.js";
-import "../../chunk-BXZHMYMM.js";
+} from "../../chunk-QEYINRZL.js";
 import {
   fsHelpers,
   generateUUID,
@@ -70,6 +69,7 @@ import {
   pathHelpers
 } from "../../chunk-MTHLLDCX.js";
 import "../../chunk-QWQYAQCK.js";
+import "../../chunk-BXZHMYMM.js";
 import {
   __name
 } from "../../chunk-3GQAWCBQ.js";
@@ -3332,7 +3332,7 @@ function registerPrompt(promptDefinition, callback) {
   }
   const wrappedCallback = /* @__PURE__ */ __name(async (params, extra) => {
     const { getRequestContext: getRequestContext2, runWithContext: runWithContext2 } = await import("../../context-storage-KMOAHEL7.js");
-    const { findSessionContext: findSessionContext2, createClientCapabilityChecker } = await import("../../tool-execution-helpers-5OCWDSO5.js");
+    const { findSessionContext: findSessionContext2, createClientCapabilityChecker } = await import("../../tool-execution-helpers-YOE4JC6H.js");
     const initialRequestContext = getRequestContext2();
     const sessions = this.sessions || /* @__PURE__ */ new Map();
     const { requestContext, session } = findSessionContext2(
@@ -3537,7 +3537,7 @@ function registerResource(resourceDefinition, callback) {
   const explicitMimeType = resourceDefinition.mimeType;
   const wrappedCallback = /* @__PURE__ */ __name(async () => {
     const { getRequestContext: getRequestContext2, runWithContext: runWithContext2 } = await import("../../context-storage-KMOAHEL7.js");
-    const { findSessionContext: findSessionContext2, createClientCapabilityChecker } = await import("../../tool-execution-helpers-5OCWDSO5.js");
+    const { findSessionContext: findSessionContext2, createClientCapabilityChecker } = await import("../../tool-execution-helpers-YOE4JC6H.js");
     const initialRequestContext = getRequestContext2();
     const sessions = this.sessions || /* @__PURE__ */ new Map();
     const { requestContext, session } = findSessionContext2(
@@ -3625,7 +3625,7 @@ function registerResourceTemplate(resourceTemplateDefinition, callback) {
     async (uri) => {
       const params = this.parseTemplateUri(uriTemplate, uri.toString());
       const { getRequestContext: getRequestContext2, runWithContext: runWithContext2 } = await import("../../context-storage-KMOAHEL7.js");
-      const { findSessionContext: findSessionContext2 } = await import("../../tool-execution-helpers-5OCWDSO5.js");
+      const { findSessionContext: findSessionContext2 } = await import("../../tool-execution-helpers-YOE4JC6H.js");
       const initialRequestContext = getRequestContext2();
       const sessions = this.sessions || /* @__PURE__ */ new Map();
       const { requestContext } = findSessionContext2(
@@ -5862,7 +5862,9 @@ async function mountMcp(app, mcpServerInstance, sessions, config, isProductionMo
     }
     const acceptHeader = c.req.header("Accept") || c.req.header("accept") || "";
     const clientSupportsSSE = acceptHeader.includes("text/event-stream");
-    const useStatelessMode = config.stateless || !clientSupportsSSE;
+    const sessionId = c.req.header("mcp-session-id");
+    const isSessionDelete = c.req.method === "DELETE" && !!sessionId;
+    const useStatelessMode = config.stateless || !clientSupportsSSE && !isSessionDelete;
     if (useStatelessMode) {
       if (c.req.method === "HEAD") {
         return new Response(null, { status: 200 });
@@ -5905,7 +5907,6 @@ async function mountMcp(app, mcpServerInstance, sessions, config, isProductionMo
         throw error2;
       }
     } else {
-      const sessionId = c.req.header("mcp-session-id");
       if (c.req.method === "HEAD") {
         if (sessionId && await sessionStore.has(sessionId)) {
           const session = await sessionStore.get(sessionId);
@@ -5924,8 +5925,8 @@ async function mountMcp(app, mcpServerInstance, sessions, config, isProductionMo
         console.log(
           `[MCP] Session metadata found but transport lost (restart/hot-reload): ${sessionId} - recovering`
         );
-        const server2 = mcpServerInstance.getServerForSession(sessionId);
-        const transport2 = new WebStandardStreamableHTTPServerTransport({
+        const server = mcpServerInstance.getServerForSession(sessionId);
+        const transport = new WebStandardStreamableHTTPServerTransport({
           sessionIdGenerator: /* @__PURE__ */ __name(() => sessionId, "sessionIdGenerator"),
           onsessioninitialized: /* @__PURE__ */ __name(async (sid) => {
             if (getDebugLevel() !== "info") {
@@ -5944,15 +5945,15 @@ async function mountMcp(app, mcpServerInstance, sessions, config, isProductionMo
             mcpServerInstance.cleanupSessionRefs?.(sid);
           }, "onsessionclosed")
         });
-        wrapTransportForStreamManager(transport2, sessionId, streamManager);
-        await server2.connect(transport2);
-        transport2._initialized = true;
-        transport2.sessionId = sessionId;
-        transports.set(sessionId, transport2);
+        wrapTransportForStreamManager(transport, sessionId, streamManager);
+        await server.connect(transport);
+        transport._initialized = true;
+        transport.sessionId = sessionId;
+        transports.set(sessionId, transport);
         const metadata = await sessionStore.get(sessionId);
         const sessionData = {
-          transport: transport2,
-          server: server2,
+          transport,
+          server,
           lastAccessedAt: Date.now(),
           context: c,
           honoContext: c,
@@ -5964,11 +5965,11 @@ async function mountMcp(app, mcpServerInstance, sessions, config, isProductionMo
         }
         const recoveryResponse = await runWithContext(
           c,
-          async () => transport2.handleRequest(c.req.raw),
+          async () => transport.handleRequest(c.req.raw),
           sessionId
         );
         if (c.req.method === "GET") {
-          await registerSseStream(transport2, sessionId, streamManager);
+          await registerSseStream(transport, sessionId, streamManager);
         }
         return recoveryResponse;
       }
@@ -5986,7 +5987,7 @@ async function mountMcp(app, mcpServerInstance, sessions, config, isProductionMo
         );
       }
       if (sessionId && transports.has(sessionId)) {
-        const transport2 = transports.get(sessionId);
+        const transport = transports.get(sessionId);
         const metadata = await sessionStore.get(sessionId);
         if (metadata) {
           metadata.lastAccessedAt = Date.now();
@@ -6003,89 +6004,122 @@ async function mountMcp(app, mcpServerInstance, sessions, config, isProductionMo
         }
         const existingResponse = await runWithContext(
           c,
-          async () => transport2.handleRequest(c.req.raw),
+          async () => transport.handleRequest(c.req.raw),
           sessionId
         );
         if (c.req.method === "GET") {
-          await registerSseStream(transport2, sessionId, streamManager);
+          await registerSseStream(transport, sessionId, streamManager);
         }
         return existingResponse;
       }
       const newSessionId = generateUUID();
-      const server = mcpServerInstance.getServerForSession(newSessionId);
-      const transport = new WebStandardStreamableHTTPServerTransport({
-        sessionIdGenerator: /* @__PURE__ */ __name(() => newSessionId, "sessionIdGenerator"),
-        onsessioninitialized: /* @__PURE__ */ __name(async (sid) => {
-          if (getDebugLevel() !== "info") {
-            console.log(`[MCP] Session initialized: ${sid}`);
-          }
-          transports.set(sid, transport);
-          const sessionData = {
-            transport,
-            server,
-            lastAccessedAt: Date.now(),
-            context: c,
-            honoContext: c
-          };
-          sessions.set(sid, sessionData);
-          await sessionStore.set(sid, {
-            lastAccessedAt: Date.now()
-          });
-          server.server.oninitialized = async () => {
-            const clientCapabilities = server.server.getClientCapabilities();
-            const clientInfo = server.server.getClientVersion?.() || server.server.getClientInfo?.() || {};
-            const protocolVersion = server.server.getProtocolVersion?.() || "unknown";
-            const metadata = await sessionStore.get(sid);
-            if (metadata) {
-              metadata.clientCapabilities = clientCapabilities;
-              metadata.clientInfo = clientInfo;
-              metadata.protocolVersion = String(protocolVersion);
-              await sessionStore.set(sid, metadata);
-              if (getDebugLevel() !== "info") {
-                console.log(
-                  `[MCP] Captured client capabilities for session ${sid}:`,
-                  clientCapabilities ? Object.keys(clientCapabilities) : "none"
-                );
+      let allocatedServer;
+      let allocatedTransport;
+      let sessionEstablished = false;
+      try {
+        const server = mcpServerInstance.getServerForSession(newSessionId);
+        allocatedServer = server;
+        const transport = new WebStandardStreamableHTTPServerTransport({
+          sessionIdGenerator: /* @__PURE__ */ __name(() => newSessionId, "sessionIdGenerator"),
+          onsessioninitialized: /* @__PURE__ */ __name(async (sid) => {
+            if (getDebugLevel() !== "info") {
+              console.log(`[MCP] Session initialized: ${sid}`);
+            }
+            transports.set(sid, transport);
+            const sessionData = {
+              transport,
+              server,
+              lastAccessedAt: Date.now(),
+              context: c,
+              honoContext: c
+            };
+            sessions.set(sid, sessionData);
+            await sessionStore.set(sid, {
+              lastAccessedAt: Date.now()
+            });
+            server.server.oninitialized = async () => {
+              const clientCapabilities = server.server.getClientCapabilities();
+              const clientInfo = server.server.getClientVersion?.() || server.server.getClientInfo?.() || {};
+              const protocolVersion = server.server.getProtocolVersion?.() || "unknown";
+              const metadata = await sessionStore.get(sid);
+              if (metadata) {
+                metadata.clientCapabilities = clientCapabilities;
+                metadata.clientInfo = clientInfo;
+                metadata.protocolVersion = String(protocolVersion);
+                await sessionStore.set(sid, metadata);
+                if (getDebugLevel() !== "info") {
+                  console.log(
+                    `[MCP] Captured client capabilities for session ${sid}:`,
+                    clientCapabilities ? Object.keys(clientCapabilities) : "none"
+                  );
+                }
               }
+              const sessionData2 = sessions.get(sid);
+              if (sessionData2) {
+                sessionData2.clientCapabilities = clientCapabilities;
+                sessionData2.clientInfo = clientInfo;
+              }
+              Telemetry.getInstance().trackServerInitialize({
+                protocolVersion: String(protocolVersion),
+                clientInfo: clientInfo || {},
+                clientCapabilities: clientCapabilities || {},
+                sessionId: sid
+              }).catch(
+                (e) => console.debug(`Failed to track server initialize: ${e}`)
+              );
+            };
+          }, "onsessioninitialized"),
+          onsessionclosed: /* @__PURE__ */ __name(async (sid) => {
+            if (getDebugLevel() !== "info") {
+              console.log(`[MCP] Session closed: ${sid}`);
             }
-            const sessionData2 = sessions.get(sid);
-            if (sessionData2) {
-              sessionData2.clientCapabilities = clientCapabilities;
-              sessionData2.clientInfo = clientInfo;
+            transports.delete(sid);
+            await streamManager.delete(sid);
+            await sessionStore.delete(sid);
+            sessions.delete(sid);
+            mcpServerInstance.cleanupSessionSubscriptions?.(sid);
+            mcpServerInstance.cleanupSessionRefs?.(sid);
+          }, "onsessionclosed")
+        });
+        allocatedTransport = transport;
+        wrapTransportForStreamManager(transport, newSessionId, streamManager);
+        await server.connect(transport);
+        const newSessionResponse = await runWithContext(
+          c,
+          async () => transport.handleRequest(c.req.raw),
+          newSessionId
+        );
+        if (c.req.method === "GET") {
+          await registerSseStream(transport, newSessionId, streamManager);
+        }
+        sessionEstablished = newSessionResponse.ok && sessions.has(newSessionId) && !c.req.raw.signal.aborted;
+        return newSessionResponse;
+      } finally {
+        if (!sessionEstablished) {
+          transports.delete(newSessionId);
+          sessions.delete(newSessionId);
+          const cleanups = await Promise.allSettled([
+            Promise.resolve().then(
+              () => mcpServerInstance.cleanupSessionSubscriptions?.(newSessionId)
+            ),
+            Promise.resolve().then(
+              () => mcpServerInstance.cleanupSessionRefs?.(newSessionId)
+            ),
+            Promise.resolve().then(() => streamManager.delete(newSessionId)),
+            Promise.resolve().then(() => sessionStore.delete(newSessionId)),
+            Promise.resolve().then(() => allocatedServer?.close()),
+            Promise.resolve().then(() => allocatedTransport?.close())
+          ]);
+          for (const cleanup of cleanups) {
+            if (cleanup.status === "rejected") {
+              console.warn(
+                `[MCP] Error cleaning up unsuccessful session ${newSessionId}:`,
+                cleanup.reason
+              );
             }
-            Telemetry.getInstance().trackServerInitialize({
-              protocolVersion: String(protocolVersion),
-              clientInfo: clientInfo || {},
-              clientCapabilities: clientCapabilities || {},
-              sessionId: sid
-            }).catch(
-              (e) => console.debug(`Failed to track server initialize: ${e}`)
-            );
-          };
-        }, "onsessioninitialized"),
-        onsessionclosed: /* @__PURE__ */ __name(async (sid) => {
-          if (getDebugLevel() !== "info") {
-            console.log(`[MCP] Session closed: ${sid}`);
           }
-          transports.delete(sid);
-          await streamManager.delete(sid);
-          await sessionStore.delete(sid);
-          sessions.delete(sid);
-          mcpServerInstance.cleanupSessionSubscriptions?.(sid);
-          mcpServerInstance.cleanupSessionRefs?.(sid);
-        }, "onsessionclosed")
-      });
-      wrapTransportForStreamManager(transport, newSessionId, streamManager);
-      await server.connect(transport);
-      const newSessionResponse = await runWithContext(
-        c,
-        async () => transport.handleRequest(c.req.raw),
-        newSessionId
-      );
-      if (c.req.method === "GET") {
-        await registerSseStream(transport, newSessionId, streamManager);
+        }
       }
-      return newSessionResponse;
     }
   }, "handleRequest");
   for (const endpoint of ["/mcp", "/sse"]) {
@@ -6987,7 +7021,7 @@ var MCPServerClass = class _MCPServerClass {
       onSampling: /* @__PURE__ */ __name(async (params) => {
         try {
           const { getRequestContext: getRequestContext2 } = await import("../../context-storage-KMOAHEL7.js");
-          const { findSessionContext: findSessionContext2 } = await import("../../tool-execution-helpers-5OCWDSO5.js");
+          const { findSessionContext: findSessionContext2 } = await import("../../tool-execution-helpers-YOE4JC6H.js");
           const ctx = getRequestContext2();
           if (!ctx) throw new Error("No request context");
           const { session } = findSessionContext2(
@@ -7015,7 +7049,7 @@ var MCPServerClass = class _MCPServerClass {
       onElicitation: /* @__PURE__ */ __name(async (params) => {
         try {
           const { getRequestContext: getRequestContext2 } = await import("../../context-storage-KMOAHEL7.js");
-          const { findSessionContext: findSessionContext2 } = await import("../../tool-execution-helpers-5OCWDSO5.js");
+          const { findSessionContext: findSessionContext2 } = await import("../../tool-execution-helpers-YOE4JC6H.js");
           const ctx = getRequestContext2();
           if (!ctx) throw new Error("No request context");
           const { session } = findSessionContext2(

package/dist/src/version.d.ts

@@ -1,4 +1,4 @@
-export declare const VERSION = "1.34.6";
+export declare const VERSION = "1.34.7";
 /**
  * Get the package version.
  * The version is embedded at build time via scripts/generate-version.mjs

package/dist/{stdio-Q655HD2H.js → stdio-3JX4DSGH.js}

@@ -1,8 +1,8 @@
 import {
   BaseConnector,
   ConnectionManager
-} from "./chunk-NF3GBT4Z.js";
-import "./chunk-DDMBF2UU.js";
+} from "./chunk-XRLI6ZYX.js";
+import "./chunk-6ERGZHCN.js";
 import {
   logger
 } from "./chunk-QWQYAQCK.js";

package/dist/{stdio-KQEZC3W4.js → stdio-BJKCQSAY.js}

@@ -1,12 +1,12 @@
 import {
   StdioConnector
-} from "./chunk-7R56RSZ6.js";
+} from "./chunk-LOSPF4H5.js";
 import "./chunk-GKPKUKD6.js";
-import "./chunk-V64O255P.js";
-import "./chunk-FOGBXW3W.js";
-import "./chunk-BXZHMYMM.js";
+import "./chunk-SGT4D4LO.js";
+import "./chunk-QEYINRZL.js";
 import "./chunk-MTHLLDCX.js";
 import "./chunk-QWQYAQCK.js";
+import "./chunk-BXZHMYMM.js";
 import "./chunk-3GQAWCBQ.js";
 export {
   StdioConnector