mcp-use 1.34.6 → 1.34.8

package/dist/src/server/index.js

@@ -17,7 +17,7 @@ import {
   findSessionContext,
   isValidLogLevel,
   supportsApps
-} from "../../chunk-DI4WNZQC.js";
+} from "../../chunk-SZYMINCU.js";
 import {
   getRequestContext,
   hasRequestContext,
@@ -59,7 +59,7 @@ import {
   Telemetry,
   VERSION,
   getPackageVersion
-} from "../../chunk-FOGBXW3W.js";
+} from "../../chunk-NCK7SUJD.js";
 import "../../chunk-BXZHMYMM.js";
 import {
   fsHelpers,
@@ -942,27 +942,19 @@ function isExpressMiddleware(middleware) {
   }
   const paramCount = middleware.length;
   const fnString = middleware.toString();
-  const expressPatterns = [
-    /\bres\.(send|json|status|end|redirect|render|sendFile|download)\b/,
-    /\breq\.(body|params|query|cookies|session)\b/,
-    /\breq\.get\s*\(/,
-    /\bres\.set\s*\(/,
-    /\bres\.statusCode\s*=/,
-    /\bres\.writeHead\s*\(/
+  const expressResponsePatterns = [
+    /(?<![\w$.])res\.(send|json|status|end|redirect|render|sendFile|download)\b/,
+    /(?<![\w$.])res\.set\s*\(/,
+    /(?<![\w$.])res\.statusCode\s*=/,
+    /(?<![\w$.])res\.writeHead\s*\(/
   ];
-  const hasExpressPattern = expressPatterns.some(
+  const hasExpressResponsePattern = expressResponsePatterns.some(
     (pattern) => pattern.test(fnString)
   );
   if (paramCount === 3 || paramCount === 4) {
-    if (hasExpressPattern) {
-      return true;
-    }
     return true;
   }
   if (paramCount === 2) {
-    if (hasExpressPattern) {
-      return true;
-    }
     const honoPatterns = [
       /\bc\.(req|res|json|text|html|status|header)\b/,
       /\bc\.get\s*\(/,
@@ -975,7 +967,7 @@ function isExpressMiddleware(middleware) {
     if (hasHonoPattern) {
       return false;
     }
-    return false;
+    return hasExpressResponsePattern;
   }
   return false;
 }
@@ -1020,31 +1012,51 @@ async function adaptConnectMiddleware(connectMiddleware, middlewarePath) {
       ...request.body && { body: request.body }
     });
     const mockResponse = createResponse();
-    let responseResolved = false;
-    const res = await new Promise((resolve) => {
+    const res = await new Promise((resolve, reject) => {
+      let responseSettled = false;
+      const resolveResponse = /* @__PURE__ */ __name((response) => {
+        if (responseSettled) return;
+        responseSettled = true;
+        resolve(response);
+      }, "resolveResponse");
+      const rejectResponse = /* @__PURE__ */ __name((error2) => {
+        if (responseSettled) return;
+        responseSettled = true;
+        reject(error2);
+      }, "rejectResponse");
       const originalEnd = mockResponse.end.bind(mockResponse);
       mockResponse.end = (...args) => {
-        const result = originalEnd(...args);
-        if (!responseResolved && mockResponse.writableEnded) {
-          responseResolved = true;
-          const statusCode = mockResponse.statusCode;
-          const noBodyStatuses = [204, 304];
-          const responseBody = noBodyStatuses.includes(statusCode) ? null : mockResponse._getData() || mockResponse._getBuffer() || null;
-          const connectResponse = new Response(responseBody, {
-            status: statusCode,
-            statusText: mockResponse.statusMessage,
-            headers: mockResponse.getHeaders()
-          });
-          resolve(connectResponse);
+        try {
+          const result = originalEnd(...args);
+          if (!responseSettled && mockResponse.writableEnded) {
+            const statusCode = mockResponse.statusCode;
+            const noBodyStatuses = [204, 304];
+            const responseBody = noBodyStatuses.includes(statusCode) ? null : mockResponse._getData() || mockResponse._getBuffer() || null;
+            const connectResponse = new Response(responseBody, {
+              status: statusCode,
+              statusText: mockResponse.statusMessage,
+              headers: mockResponse.getHeaders()
+            });
+            resolveResponse(connectResponse);
+          }
+          return result;
+        } catch (error2) {
+          rejectResponse(error2);
+          return mockResponse;
         }
-        return result;
       };
-      connectMiddleware(mockRequest, mockResponse, () => {
-        if (!responseResolved && !mockResponse.writableEnded) {
-          responseResolved = true;
+      const connectNext = /* @__PURE__ */ __name((error2) => {
+        if (responseSettled) return;
+        if (error2) {
+          rejectResponse(error2);
+          return;
+        }
+        if (mockResponse.writableEnded) return;
+        try {
           const statusCode = mockResponse.statusCode;
           const noBodyStatuses = [204, 304];
-          const responseBody = noBodyStatuses.includes(statusCode) ? null : mockResponse._getData() || mockResponse._getBuffer() || null;
+          const buffer = mockResponse._getBuffer();
+          const responseBody = noBodyStatuses.includes(statusCode) ? null : mockResponse._getData() || (buffer.length > 0 ? buffer : null);
           const preparedHeaders = c.newResponse(null, 204, {}).headers;
           for (const key of [...preparedHeaders.keys()]) {
             if (preparedHeaders.has(key)) {
@@ -1065,14 +1077,23 @@ async function adaptConnectMiddleware(connectMiddleware, middlewarePath) {
           }
           c.status(statusCode);
           if (noBodyStatuses.includes(statusCode)) {
-            resolve(c.newResponse(null, statusCode));
+            resolveResponse(c.newResponse(null, statusCode));
           } else if (responseBody) {
-            resolve(c.body(responseBody));
+            resolveResponse(c.body(responseBody));
           } else {
-            resolve(void 0);
+            resolveResponse(void 0);
           }
+        } catch (error3) {
+          rejectResponse(error3);
         }
-      });
+      }, "connectNext");
+      try {
+        Promise.resolve(
+          connectMiddleware(mockRequest, mockResponse, connectNext)
+        ).catch(rejectResponse);
+      } catch (error2) {
+        rejectResponse(error2);
+      }
     });
     if (res) {
       c.res = res;
@@ -3332,7 +3353,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-IJTPZL55.js");
     const initialRequestContext = getRequestContext2();
     const sessions = this.sessions || /* @__PURE__ */ new Map();
     const { requestContext, session } = findSessionContext2(
@@ -3537,7 +3558,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-IJTPZL55.js");
     const initialRequestContext = getRequestContext2();
     const sessions = this.sessions || /* @__PURE__ */ new Map();
     const { requestContext, session } = findSessionContext2(
@@ -3625,7 +3646,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-IJTPZL55.js");
       const initialRequestContext = getRequestContext2();
       const sessions = this.sessions || /* @__PURE__ */ new Map();
       const { requestContext } = findSessionContext2(
@@ -5099,11 +5120,17 @@ var RedisStreamManager = class {
    * Key: sessionId, Value: controller
    */
   localControllers = /* @__PURE__ */ new Map();
+  streamGenerations = /* @__PURE__ */ new Map();
   /**
    * Map of heartbeat intervals for keeping sessions alive
    * Key: sessionId, Value: interval timer
    */
   heartbeats = /* @__PURE__ */ new Map();
+  // Track attempted subscriptions separately from controllers: a disconnected
+  // controller or a rejected subscribe() must not lose its cleanup ownership.
+  sessionSubscriptions = /* @__PURE__ */ new Map();
+  sessionOperations = /* @__PURE__ */ new Map();
+  closing = false;
   /**
    * Unique identifier for this server instance, used for request/response routing.
    */
@@ -5116,6 +5143,7 @@ var RedisStreamManager = class {
    * Whether the server-level response channel subscription is active.
    */
   serverChannelSubscribed = false;
+  serverChannelSubscription;
   constructor(config) {
     this.pubSubClient = config.pubSubClient;
     this.client = config.client;
@@ -5140,90 +5168,265 @@ var RedisStreamManager = class {
   getActiveSessionsKey() {
     return `${this.prefix}active`;
   }
-  /**
-   * Register an active SSE stream and subscribe to Redis channel.
-   * Idempotent: if the session already has a subscription, it is cleaned up first.
-   */
-  async create(sessionId, controller) {
+  withSessionOperation(sessionId, operation) {
+    const previous = this.sessionOperations.get(sessionId) ?? Promise.resolve();
+    const result = previous.then(operation);
+    const settled = result.then(
+      () => {
+      },
+      () => {
+      }
+    );
+    this.sessionOperations.set(sessionId, settled);
+    void settled.then(() => {
+      if (this.sessionOperations.get(sessionId) === settled) {
+        this.sessionOperations.delete(sessionId);
+      }
+    });
+    return result;
+  }
+  clearLocalStream(sessionId) {
+    const heartbeat = this.heartbeats.get(sessionId);
+    if (heartbeat) clearInterval(heartbeat);
+    this.heartbeats.delete(sessionId);
+    const controller = this.localControllers.get(sessionId);
+    this.localControllers.delete(sessionId);
+    this.streamGenerations.delete(sessionId);
+    this.closeController(controller);
+  }
+  closeController(controller) {
     try {
-      if (this.localControllers.has(sessionId)) {
-        const oldHeartbeat = this.heartbeats.get(sessionId);
-        if (oldHeartbeat) {
-          clearInterval(oldHeartbeat);
-          this.heartbeats.delete(sessionId);
-        }
-        const channel2 = this.getChannel(sessionId);
-        const deleteChannel2 = `delete:${channel2}`;
-        try {
-          await this.pubSubClient.unsubscribe?.(channel2);
-          await this.pubSubClient.unsubscribe?.(deleteChannel2);
-        } catch {
-        }
+      controller?.close();
+    } catch {
+    }
+  }
+  async unsubscribeSession(sessionId) {
+    const channels = this.sessionSubscriptions.get(sessionId);
+    if (!channels?.size) return;
+    if (!this.pubSubClient.unsubscribe) {
+      throw new Error(
+        "[RedisStreamManager] Redis client does not support unsubscribe method"
+      );
+    }
+    const results = await Promise.allSettled(
+      Array.from(channels, async (channel) => {
+        await this.pubSubClient.unsubscribe(channel);
+        channels.delete(channel);
+      })
+    );
+    if (!channels.size) this.sessionSubscriptions.delete(sessionId);
+    this.throwCleanupError(results);
+  }
+  throwCleanupError(results) {
+    const failed = results.find((result) => result.status === "rejected");
+    if (failed?.status === "rejected") throw failed.reason;
+  }
+  async markAvailable(sessionId) {
+    const key = this.getAvailableKey(sessionId);
+    const ttl = this.heartbeatInterval * 2;
+    if (this.client.setEx) {
+      await this.client.setEx(key, ttl, "active");
+    } else if (this.client.setex) {
+      await this.client.setex(key, ttl, "active");
+    } else {
+      await this.client.set(key, "active", { EX: ttl });
+      if (this.client.expire) await this.client.expire(key, ttl);
+    }
+    if (this.client.sAdd) {
+      await this.client.sAdd(this.getActiveSessionsKey(), sessionId);
+      await this.client.expire?.(this.getActiveSessionsKey(), ttl);
+    }
+  }
+  async removeAvailability(sessionId) {
+    const results = await Promise.allSettled([
+      Promise.resolve().then(
+        () => this.client.del(this.getAvailableKey(sessionId))
+      ),
+      Promise.resolve().then(
+        () => this.client.sRem?.(this.getActiveSessionsKey(), sessionId)
+      )
+    ]);
+    this.throwCleanupError(results);
+  }
+  async removeStream(sessionId, notifyOtherServers, cleanupAvailability = true) {
+    this.clearLocalStream(sessionId);
+    const results = await Promise.allSettled([
+      this.unsubscribeSession(sessionId),
+      cleanupAvailability ? this.removeAvailability(sessionId) : Promise.resolve()
+    ]);
+    if (notifyOtherServers) {
+      results.push(
+        ...await Promise.allSettled([
+          Promise.resolve().then(() => {
+            if (!this.client.publish) {
+              throw new Error(
+                "[RedisStreamManager] Redis client does not support publish method"
+              );
+            }
+            return this.client.publish(
+              `delete:${this.getChannel(sessionId)}`,
+              ""
+            );
+          })
+        ])
+      );
+    }
+    this.throwCleanupError(results);
+  }
+  // These factories have no enclosing controller or handler argument. Redis
+  // may retain their callbacks after a failed unsubscribe, so the callbacks
+  // must resolve controllers/handlers through the manager rather than capture
+  // a registration operation's context.
+  createMessageCallback(sessionId, generation) {
+    return (message) => {
+      if (this.streamGenerations.get(sessionId) !== generation) return;
+      const controller = this.localControllers.get(sessionId);
+      if (!controller) return;
+      try {
+        controller.enqueue(this.textEncoder.encode(message));
+      } catch {
+        this.clearLocalStream(sessionId);
+        this.cleanupDisconnectedStream(sessionId);
       }
-      this.localControllers.set(sessionId, controller);
-      const availableKey = this.getAvailableKey(sessionId);
-      await this.client.set(availableKey, "active");
-      if (this.client.expire) {
-        await this.client.expire(availableKey, this.heartbeatInterval * 2);
+    };
+  }
+  cleanupDisconnectedStream(sessionId) {
+    void this.withSessionOperation(sessionId, async () => {
+      if (!this.localControllers.has(sessionId)) {
+        await this.unsubscribeSession(sessionId);
       }
-      const activeSessionsKey = this.getActiveSessionsKey();
-      if (this.client.sAdd) {
-        await this.client.sAdd(activeSessionsKey, sessionId);
+    }).catch((error2) => {
+      console.warn(
+        `[RedisStreamManager] Failed to unsubscribe disconnected stream ${sessionId}:`,
+        error2
+      );
+    });
+  }
+  createDeleteCallback(sessionId, generation) {
+    return () => {
+      if (this.streamGenerations.get(sessionId) !== generation) return;
+      void this.withSessionOperation(
+        sessionId,
+        () => this.removeStream(sessionId, false)
+      ).catch((error2) => {
+        console.warn(
+          `[RedisStreamManager] Failed to clean up deleted stream ${sessionId}:`,
+          error2
+        );
+      });
+    };
+  }
+  startHeartbeat(sessionId) {
+    const availableKey = this.getAvailableKey(sessionId);
+    const activeSessionsKey = this.getActiveSessionsKey();
+    const heartbeat = setInterval(async () => {
+      try {
         if (this.client.expire) {
+          await this.client.expire(availableKey, this.heartbeatInterval * 2);
           await this.client.expire(
             activeSessionsKey,
             this.heartbeatInterval * 2
           );
         }
+      } catch (error2) {
+        console.warn(
+          `[RedisStreamManager] Heartbeat failed for session ${sessionId}:`,
+          error2
+        );
       }
-      const heartbeat = setInterval(async () => {
-        try {
-          if (this.client.expire) {
-            await this.client.expire(availableKey, this.heartbeatInterval * 2);
-            const activeSessionsKey2 = this.getActiveSessionsKey();
-            await this.client.expire(
-              activeSessionsKey2,
-              this.heartbeatInterval * 2
-            );
-          }
-        } catch (error2) {
-          console.warn(
-            `[RedisStreamManager] Heartbeat failed for session ${sessionId}:`,
-            error2
+    }, this.heartbeatInterval * 1e3);
+    this.heartbeats.set(sessionId, heartbeat);
+  }
+  createForwardedResponseCallback() {
+    return (raw) => {
+      try {
+        const { response, sessionId } = JSON.parse(raw);
+        this.forwardedResponseHandler?.(response, sessionId);
+      } catch (error2) {
+        console.warn(
+          `[RedisStreamManager] Failed to parse forwarded response:`,
+          error2
+        );
+      }
+    };
+  }
+  /**
+   * Register an active SSE stream and subscribe to Redis channel.
+   * Idempotent: if the session already has a subscription, it is cleaned up first.
+   */
+  async create(sessionId, controller) {
+    return this.withSessionOperation(sessionId, async () => {
+      if (this.closing) {
+        this.closeController(controller);
+        throw new Error("[RedisStreamManager] Stream manager is closed");
+      }
+      if (this.localControllers.get(sessionId) === controller) return;
+      this.clearLocalStream(sessionId);
+      let controllerRegistered = false;
+      try {
+        await this.unsubscribeSession(sessionId);
+        if (this.closing) {
+          throw new Error("[RedisStreamManager] Stream manager is closed");
+        }
+        this.localControllers.set(sessionId, controller);
+        controllerRegistered = true;
+        const generation = Symbol(sessionId);
+        this.streamGenerations.set(sessionId, generation);
+        if (!this.pubSubClient.subscribe) {
+          throw new Error(
+            "[RedisStreamManager] Redis client does not support subscribe method"
           );
         }
-      }, this.heartbeatInterval * 1e3);
-      this.heartbeats.set(sessionId, heartbeat);
-      const channel = this.getChannel(sessionId);
-      if (!this.pubSubClient.subscribe) {
-        throw new Error(
-          "[RedisStreamManager] Redis client does not support subscribe method"
+        const channels = /* @__PURE__ */ new Set();
+        this.sessionSubscriptions.set(sessionId, channels);
+        const channel = this.getChannel(sessionId);
+        channels.add(channel);
+        await this.pubSubClient.subscribe(
+          channel,
+          this.createMessageCallback(sessionId, generation)
         );
-      }
-      await this.pubSubClient.subscribe(channel, (message) => {
-        const localController = this.localControllers.get(sessionId);
-        if (localController) {
-          try {
-            localController.enqueue(this.textEncoder.encode(message));
-          } catch {
-            this.localControllers.delete(sessionId);
+        const deleteChannel = `delete:${channel}`;
+        channels.add(deleteChannel);
+        await this.pubSubClient.subscribe(
+          deleteChannel,
+          this.createDeleteCallback(sessionId, generation)
+        );
+        if (this.closing || this.streamGenerations.get(sessionId) !== generation) {
+          throw new Error(
+            "[RedisStreamManager] Stream closed during registration"
+          );
+        }
+        await this.markAvailable(sessionId);
+        if (this.closing || this.streamGenerations.get(sessionId) !== generation) {
+          throw new Error(
+            "[RedisStreamManager] Stream closed during registration"
+          );
+        }
+        this.startHeartbeat(sessionId);
+        console.log(
+          `[RedisStreamManager] Created stream for session ${sessionId}`
+        );
+      } catch (error2) {
+        this.clearLocalStream(sessionId);
+        if (!controllerRegistered) this.closeController(controller);
+        const cleanups = await Promise.allSettled([
+          this.unsubscribeSession(sessionId)
+        ]);
+        for (const cleanup of cleanups) {
+          if (cleanup.status === "rejected") {
+            console.warn(
+              `[RedisStreamManager] Failed to roll back stream ${sessionId}:`,
+              cleanup.reason
+            );
           }
         }
-      });
-      const deleteChannel = `delete:${this.getChannel(sessionId)}`;
-      await this.pubSubClient.subscribe(deleteChannel, async () => {
-        await this.delete(sessionId);
-      });
-      console.log(
-        `[RedisStreamManager] Created stream for session ${sessionId}`
-      );
-    } catch (error2) {
-      console.error(
-        `[RedisStreamManager] Error creating stream for ${sessionId}:`,
-        error2
-      );
-      throw error2;
-    }
+        console.error(
+          `[RedisStreamManager] Error creating stream for ${sessionId}:`,
+          error2
+        );
+        throw error2;
+      }
+    });
   }
   /**
    * Send data to sessions via Redis Pub/Sub
@@ -5241,6 +5444,22 @@ var RedisStreamManager = class {
         if (this.client.sMembers) {
           const sessionIds2 = await this.client.sMembers(activeSessionsKey);
           for (const sessionId of sessionIds2) {
+            const availableKey = this.getAvailableKey(sessionId);
+            if (await this.client.exists(availableKey) !== 1) {
+              await this.client.sRem?.(activeSessionsKey, sessionId);
+              let available;
+              try {
+                available = await this.client.exists(availableKey);
+              } catch (error2) {
+                try {
+                  await this.client.sAdd?.(activeSessionsKey, sessionId);
+                } catch {
+                }
+                throw error2;
+              }
+              if (available !== 1) continue;
+              await this.client.sAdd?.(activeSessionsKey, sessionId);
+            }
             const channel = this.getChannel(sessionId);
             if (!this.client.publish) {
               throw new Error(
@@ -5283,53 +5502,20 @@ var RedisStreamManager = class {
    * Remove an active SSE stream
    */
   async delete(sessionId) {
-    try {
-      const heartbeat = this.heartbeats.get(sessionId);
-      if (heartbeat) {
-        clearInterval(heartbeat);
-        this.heartbeats.delete(sessionId);
-      }
-      const channel = this.getChannel(sessionId);
-      const deleteChannel = `delete:${channel}`;
-      if (!this.pubSubClient.unsubscribe) {
-        throw new Error(
-          "[RedisStreamManager] Redis client does not support unsubscribe method"
+    return this.withSessionOperation(sessionId, async () => {
+      try {
+        await this.removeStream(sessionId, true);
+        console.log(
+          `[RedisStreamManager] Deleted stream for session ${sessionId}`
         );
-      }
-      await this.pubSubClient.unsubscribe(channel);
-      await this.pubSubClient.unsubscribe(deleteChannel);
-      if (!this.client.publish) {
-        throw new Error(
-          "[RedisStreamManager] Redis client does not support publish method"
+      } catch (error2) {
+        console.error(
+          `[RedisStreamManager] Error deleting stream for ${sessionId}:`,
+          error2
         );
+        throw error2;
       }
-      await this.client.publish(deleteChannel, "");
-      await this.client.del(this.getAvailableKey(sessionId));
-      const activeSessionsKey = this.getActiveSessionsKey();
-      if (this.client.sRem) {
-        await this.client.sRem(activeSessionsKey, sessionId);
-      }
-      const controller = this.localControllers.get(sessionId);
-      if (controller) {
-        try {
-          controller.close();
-        } catch (error2) {
-          console.debug(
-            `[RedisStreamManager] Controller already closed for ${sessionId}`
-          );
-        }
-        this.localControllers.delete(sessionId);
-      }
-      console.log(
-        `[RedisStreamManager] Deleted stream for session ${sessionId}`
-      );
-    } catch (error2) {
-      console.error(
-        `[RedisStreamManager] Error deleting stream for ${sessionId}:`,
-        error2
-      );
-      throw error2;
-    }
+    });
   }
   /**
    * Check if a session has an active stream (on ANY server)
@@ -5351,31 +5537,42 @@ var RedisStreamManager = class {
    * Close all connections and cleanup
    */
   async close() {
-    try {
-      for (const heartbeat of this.heartbeats.values()) {
-        clearInterval(heartbeat);
-      }
-      this.heartbeats.clear();
-      const activeSessionsKey = this.getActiveSessionsKey();
-      const sessionIdsToCleanup = Array.from(this.localControllers.keys());
-      for (const sessionId of sessionIdsToCleanup) {
-        await this.client.del(this.getAvailableKey(sessionId));
-        if (this.client.sRem) {
-          await this.client.sRem(activeSessionsKey, sessionId);
-        }
-      }
-      for (const controller of this.localControllers.values()) {
-        try {
-          controller.close();
-        } catch (error2) {
+    this.closing = true;
+    this.forwardedResponseHandler = void 0;
+    const sessionIds = /* @__PURE__ */ new Set([
+      ...this.localControllers.keys(),
+      ...this.heartbeats.keys(),
+      ...this.sessionSubscriptions.keys(),
+      ...this.sessionOperations.keys()
+    ]);
+    for (const sessionId of sessionIds) this.clearLocalStream(sessionId);
+    const results = await Promise.allSettled([
+      ...Array.from(
+        sessionIds,
+        (sessionId) => this.withSessionOperation(
+          sessionId,
+          () => (
+            // Shared availability expires after shutdown; deleting it here
+            // could invalidate another manager serving the same session.
+            this.removeStream(sessionId, false, false)
+          )
+        )
+      ),
+      Promise.resolve().then(async () => {
+        await this.serverChannelSubscription;
+        if (this.serverChannelSubscribed) {
+          if (!this.pubSubClient.unsubscribe) {
+            throw new Error(
+              "[RedisStreamManager] Redis client does not support unsubscribe method"
+            );
+          }
+          await this.pubSubClient.unsubscribe(this.getServerChannel());
+          this.serverChannelSubscribed = false;
         }
-      }
-      this.localControllers.clear();
-      console.log(`[RedisStreamManager] Closed all streams`);
-    } catch (error2) {
-      console.error(`[RedisStreamManager] Error during close:`, error2);
-      throw error2;
-    }
+      })
+    ]);
+    this.throwCleanupError(results);
+    console.log(`[RedisStreamManager] Closed all streams`);
   }
   /**
    * Get count of active local streams on this server instance
@@ -5440,9 +5637,9 @@ var RedisStreamManager = class {
    * Subscribes to this server's dedicated Pub/Sub channel.
    */
   onForwardedResponse(handler) {
+    if (this.closing) return;
     this.forwardedResponseHandler = handler;
     if (this.serverChannelSubscribed) return;
-    this.serverChannelSubscribed = true;
     const serverChannel = this.getServerChannel();
     if (!this.pubSubClient.subscribe) {
       console.warn(
@@ -5450,17 +5647,21 @@ var RedisStreamManager = class {
       );
       return;
     }
-    this.pubSubClient.subscribe(serverChannel, (raw) => {
+    this.serverChannelSubscribed = true;
+    this.serverChannelSubscription = Promise.resolve().then(
+      () => this.pubSubClient.subscribe(
+        serverChannel,
+        this.createForwardedResponseCallback()
+      )
+    ).then(() => {
+    }).catch(async (error2) => {
       try {
-        const { response, sessionId } = JSON.parse(raw);
-        this.forwardedResponseHandler?.(response, sessionId);
-      } catch (error2) {
-        console.warn(
-          `[RedisStreamManager] Failed to parse forwarded response:`,
-          error2
-        );
+        if (this.pubSubClient.unsubscribe) {
+          await this.pubSubClient.unsubscribe(serverChannel);
+          this.serverChannelSubscribed = false;
+        }
+      } catch {
       }
-    }).catch((error2) => {
       console.error(
         `[RedisStreamManager] Failed to subscribe to server channel:`,
         error2
@@ -5528,37 +5729,21 @@ async function extractResponseError(res) {
     return null;
   }
   if (!text2) return null;
-  const isSse = (res.headers.get("content-type") || "").includes(
-    "text/event-stream"
-  );
-  const payloads = [];
-  const tryParse = /* @__PURE__ */ __name((raw) => {
-    try {
-      payloads.push(JSON.parse(raw));
-    } catch {
-    }
-  }, "tryParse");
-  if (isSse) {
-    for (const line of text2.split(/\r?\n/)) {
-      if (line.startsWith("data:")) {
-        const data = line.slice(5).trim();
-        if (data) tryParse(data);
-      }
-    }
-  } else {
-    tryParse(text2);
+  let payload;
+  try {
+    payload = JSON.parse(text2);
+  } catch {
+    return null;
   }
-  for (const payload of payloads) {
-    for (const msg of Array.isArray(payload) ? payload : [payload]) {
-      if (!msg || typeof msg !== "object") continue;
-      const m = msg;
-      if (typeof m.error?.message === "string") return m.error.message;
-      if (m.result?.isError === true) {
-        const textBlock = Array.isArray(m.result.content) ? m.result.content.find(
-          (b) => b?.type === "text" && typeof b.text === "string"
-        ) : null;
-        return textBlock ? String(textBlock.text) : "tool error";
-      }
+  for (const msg of Array.isArray(payload) ? payload : [payload]) {
+    if (!msg || typeof msg !== "object") continue;
+    const m = msg;
+    if (typeof m.error?.message === "string") return m.error.message;
+    if (m.result?.isError === true) {
+      const textBlock = Array.isArray(m.result.content) ? m.result.content.find(
+        (b) => b?.type === "text" && typeof b.text === "string"
+      ) : null;
+      return textBlock ? String(textBlock.text) : "tool error";
     }
   }
   return null;
@@ -5602,6 +5787,7 @@ async function requestLogger(c, next) {
   await next();
   const durationMs = Date.now() - startedAt;
   const statusCode = c.res.status;
+  const isStreaming = c.res.headers.get("content-type")?.split(";", 1)[0]?.trim().toLowerCase() === "text/event-stream";
   const incomingSid = c.req.header("mcp-session-id");
   const responseSid = c.res.headers.get("mcp-session-id");
   const mcpMethod = requestBody?.method;
@@ -5640,7 +5826,7 @@ async function requestLogger(c, next) {
     parts.push(chalk2.gray(`\u2192 session=${shortSessionId(responseSid)}`));
   }
   let outcomePart;
-  const errMsg = await extractResponseError(c.res);
+  const errMsg = isStreaming ? null : await extractResponseError(c.res);
   if (errMsg) {
     outcomePart = chalk2.red(`ERROR ${errMsg}`);
   } else if (mcpMethod) {
@@ -5676,7 +5862,9 @@ async function requestLogger(c, next) {
     console.log(formatForLogging(responseHeaders));
   }
   try {
-    if (c.res.body !== null && c.res.body !== void 0) {
+    if (isStreaming) {
+      console.log(chalk2.yellow("Response Body:") + " (streaming; skipped)");
+    } else if (c.res.body !== null && c.res.body !== void 0) {
       try {
         const clonedResponse = c.res.clone();
         const responseBody = await clonedResponse.text().catch(() => null);
@@ -5789,6 +5977,29 @@ async function mountMcp(app, mcpServerInstance, sessions, config, isProductionMo
   }));
   const streamManager = config.streamManager ?? new InMemoryStreamManager();
   const transports = /* @__PURE__ */ new Map();
+  const cleanupClosedSession = /* @__PURE__ */ __name(async (sid) => {
+    if (getDebugLevel() !== "info") {
+      console.log(`[MCP] Session closed: ${sid}`);
+    }
+    transports.delete(sid);
+    sessions.delete(sid);
+    const cleanups = await Promise.allSettled([
+      Promise.resolve().then(
+        () => mcpServerInstance.cleanupSessionSubscriptions?.(sid)
+      ),
+      Promise.resolve().then(() => mcpServerInstance.cleanupSessionRefs?.(sid)),
+      Promise.resolve().then(() => streamManager.delete(sid)),
+      Promise.resolve().then(() => sessionStore.delete(sid))
+    ]);
+    for (const cleanup of cleanups) {
+      if (cleanup.status === "rejected") {
+        console.warn(
+          `[MCP] Error cleaning up closed session ${sid}:`,
+          cleanup.reason
+        );
+      }
+    }
+  }, "cleanupClosedSession");
   if (streamManager.onForwardedResponse) {
     streamManager.onForwardedResponse((message, sid) => {
       const transport = transports.get(sid);
@@ -5862,7 +6073,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 +6118,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,35 +6136,25 @@ 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") {
               console.log(`[MCP] Session re-initialized: ${sid}`);
             }
           }, "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")
+          onsessionclosed: cleanupClosedSession
         });
-        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 +6166,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 +6188,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 +6205,112 @@ 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}`);
             }
-            const sessionData2 = sessions.get(sid);
-            if (sessionData2) {
-              sessionData2.clientCapabilities = clientCapabilities;
-              sessionData2.clientInfo = clientInfo;
+            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: cleanupClosedSession
+        });
+        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 +7212,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-IJTPZL55.js");
           const ctx = getRequestContext2();
           if (!ctx) throw new Error("No request context");
           const { session } = findSessionContext2(
@@ -7015,7 +7240,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-IJTPZL55.js");
           const ctx = getRequestContext2();
           if (!ctx) throw new Error("No request context");
           const { session } = findSessionContext2(