mcp-use 1.34.7 → 1.34.8

package/dist/src/server/index.cjs

@@ -661,7 +661,7 @@ var VERSION;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    VERSION = "1.34.7";
+    VERSION = "1.34.8";
     __name(getPackageVersion, "getPackageVersion");
   }
 });
@@ -8739,27 +8739,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*\(/,
@@ -8772,7 +8764,7 @@ function isExpressMiddleware(middleware) {
     if (hasHonoPattern) {
       return false;
     }
-    return false;
+    return hasExpressResponsePattern;
   }
   return false;
 }
@@ -8817,31 +8809,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, reject2) => {
+      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;
+        reject2(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)) {
@@ -8862,14 +8874,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;
@@ -12918,11 +12939,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.
    */
@@ -12935,6 +12962,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;
@@ -12959,90 +12987,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
@@ -13060,6 +13263,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(
@@ -13102,53 +13321,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)
@@ -13170,31 +13356,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
@@ -13259,9 +13456,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(
@@ -13269,17 +13466,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
@@ -13378,37 +13579,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;
@@ -13452,6 +13637,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;
@@ -13490,7 +13676,7 @@ async function requestLogger(c, next) {
     parts.push(import_chalk2.default.gray(`\u2192 session=${shortSessionId(responseSid)}`));
   }
   let outcomePart;
-  const errMsg = await extractResponseError(c.res);
+  const errMsg = isStreaming ? null : await extractResponseError(c.res);
   if (errMsg) {
     outcomePart = import_chalk2.default.red(`ERROR ${errMsg}`);
   } else if (mcpMethod) {
@@ -13526,7 +13712,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(import_chalk2.default.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);
@@ -13640,6 +13828,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);
@@ -13784,17 +13995,7 @@ async function mountMcp(app, mcpServerInstance, sessions, config, isProductionMo
               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(transport, sessionId, streamManager);
         await server.connect(transport);
@@ -13920,17 +14121,7 @@ async function mountMcp(app, mcpServerInstance, sessions, config, isProductionMo
               );
             };
           }, "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
         });
         allocatedTransport = transport;
         wrapTransportForStreamManager(transport, newSessionId, streamManager);