@mcp-ts/sdk 1.3.2 → 1.3.4

package/dist/index.js

@@ -1333,7 +1333,8 @@ var MCPClient = class _MCPClient {
         serverUrl: this.serverUrl,
         callbackUrl: this.callbackUrl,
         transportType: this.transportType || "streamable_http",
-        createdAt: this.createdAt
+        createdAt: this.createdAt,
+        active: false
       }, Math.floor(STATE_EXPIRATION_MS / 1e3));
     }
   }
@@ -1341,9 +1342,10 @@ var MCPClient = class _MCPClient {
    * Saves current session state to storage
    * Creates new session if it doesn't exist, updates if it does
    * @param ttl - Time-to-live in seconds (defaults to 12hr for connected sessions)
+   * @param active - Session status marker used to avoid unnecessary TTL rewrites
    * @private
    */
-  async saveSession(ttl = SESSION_TTL_SECONDS) {
+  async saveSession(ttl = SESSION_TTL_SECONDS, active = true) {
     if (!this.sessionId || !this.serverId || !this.serverUrl || !this.callbackUrl) {
       return;
     }
@@ -1355,7 +1357,8 @@ var MCPClient = class _MCPClient {
       serverUrl: this.serverUrl,
       callbackUrl: this.callbackUrl,
       transportType: this.transportType || "streamable_http",
-      createdAt: this.createdAt || Date.now()
+      createdAt: this.createdAt || Date.now(),
+      active
     };
     const existingSession = await storage.getSession(this.identity, this.sessionId);
     if (existingSession) {
@@ -1429,15 +1432,17 @@ var MCPClient = class _MCPClient {
       this.emitStateChange("CONNECTED");
       this.emitProgress("Connected successfully");
       const existingSession = await storage.getSession(this.identity, this.sessionId);
-      if (!existingSession || existingSession.transportType !== this.transportType) {
-        console.log(`[MCPClient] Saving session ${this.sessionId} (new or transport changed)`);
-        await this.saveSession(SESSION_TTL_SECONDS);
+      const needsTransportUpdate = !existingSession || existingSession.transportType !== this.transportType;
+      const needsTtlPromotion = !existingSession || existingSession.active !== true;
+      if (needsTransportUpdate || needsTtlPromotion) {
+        console.log(`[MCPClient] Saving session ${this.sessionId} with 12hr TTL (connect success)`);
+        await this.saveSession(SESSION_TTL_SECONDS, true);
       }
     } catch (error) {
       if (error instanceof auth_js.UnauthorizedError || error instanceof Error && error.message.toLowerCase().includes("unauthorized")) {
         this.emitStateChange("AUTHENTICATING");
         console.log(`[MCPClient] Saving session ${this.sessionId} with 10min TTL (OAuth pending)`);
-        await this.saveSession(Math.floor(STATE_EXPIRATION_MS / 1e3));
+        await this.saveSession(Math.floor(STATE_EXPIRATION_MS / 1e3), false);
         let authUrl = "";
         if (this.oauthProvider) {
           authUrl = this.oauthProvider.authUrl || "";
@@ -1515,7 +1520,7 @@ var MCPClient = class _MCPClient {
         await this.client.connect(this.transport);
         this.emitStateChange("CONNECTED");
         console.log(`[MCPClient] Updating session ${this.sessionId} to 12hr TTL (OAuth complete)`);
-        await this.saveSession(SESSION_TTL_SECONDS);
+        await this.saveSession(SESSION_TTL_SECONDS, true);
         return;
       } catch (error) {
         lastError = error;
@@ -2180,7 +2185,8 @@ var SSEConnectionManager = class {
         serverName: s.serverName,
         serverUrl: s.serverUrl,
         transport: s.transportType,
-        createdAt: s.createdAt
+        createdAt: s.createdAt,
+        active: s.active !== false
       }))
     };
   }
@@ -2195,6 +2201,13 @@ var SSEConnectionManager = class {
       (s) => s.serverId === serverId || s.serverUrl === serverUrl
     );
     if (duplicate) {
+      if (duplicate.active === false) {
+        await this.restoreSession({ sessionId: duplicate.sessionId });
+        return {
+          sessionId: duplicate.sessionId,
+          success: true
+        };
+      }
       throw new Error(`Connection already exists for server: ${duplicate.serverUrl || duplicate.serverId} (${duplicate.serverName})`);
     }
     const sessionId = await storage.generateSessionId();
@@ -2520,7 +2533,9 @@ function writeSSEEvent(res, event, data) {
 }
 
 // src/server/handlers/nextjs-handler.ts
-var managers = /* @__PURE__ */ new Map();
+function isRpcResponseEvent(event) {
+  return "id" in event && ("result" in event || "error" in event);
+}
 function createNextMcpHandler(options = {}) {
   const {
     getIdentity = (request) => new URL(request.url).searchParams.get("identity"),
@@ -2533,72 +2548,29 @@ function createNextMcpHandler(options = {}) {
     clientDefaults,
     getClientMetadata
   } = options;
-  async function GET(request) {
-    const identity = getIdentity(request);
-    const authToken = getAuthToken(request);
-    if (!identity) {
-      return new Response("Missing identity", { status: 400 });
-    }
-    const isAuthorized = await authenticate(identity, authToken);
-    if (!isAuthorized) {
-      return new Response("Unauthorized", { status: 401 });
-    }
-    const stream = new TransformStream();
-    const writer = stream.writable.getWriter();
-    const encoder = new TextEncoder();
-    const sendSSE = (event, data) => {
-      const message = `event: ${event}
-data: ${JSON.stringify(data)}
-
-`;
-      writer.write(encoder.encode(message)).catch(() => {
-      });
-    };
-    const previousManager = managers.get(identity);
-    if (previousManager) {
-      previousManager.dispose();
-    }
-    const resolvedClientMetadata = getClientMetadata ? await getClientMetadata(request) : clientDefaults;
-    const manager = new SSEConnectionManager(
+  const toManagerOptions = (identity, resolvedClientMetadata) => ({
+    identity,
+    heartbeatInterval,
+    clientDefaults: resolvedClientMetadata
+  });
+  async function resolveClientMetadata(request) {
+    return getClientMetadata ? await getClientMetadata(request) : clientDefaults;
+  }
+  async function GET() {
+    return Response.json(
       {
-        identity,
-        heartbeatInterval,
-        clientDefaults: resolvedClientMetadata
-        // Pass resolved metadata
-      },
-      (event) => {
-        if ("id" in event) {
-          sendSSE("rpc-response", event);
-        } else if ("type" in event && "sessionId" in event) {
-          sendSSE("connection", event);
-        } else {
-          sendSSE("observability", event);
+        error: {
+          code: "METHOD_NOT_ALLOWED",
+          message: "Use POST /api/mcp. For streaming use Accept: text/event-stream."
         }
-      }
+      },
+      { status: 405 }
     );
-    managers.set(identity, manager);
-    sendSSE("connected", { timestamp: Date.now() });
-    const abortController = new AbortController();
-    request.signal?.addEventListener("abort", () => {
-      manager.dispose();
-      managers.delete(identity);
-      writer.close().catch(() => {
-      });
-      abortController.abort();
-    });
-    return new Response(stream.readable, {
-      status: 200,
-      headers: {
-        "Content-Type": "text/event-stream",
-        "Cache-Control": "no-cache, no-transform",
-        "Connection": "keep-alive",
-        "X-Accel-Buffering": "no"
-      }
-    });
   }
   async function POST(request) {
     const identity = getIdentity(request);
     const authToken = getAuthToken(request);
+    const acceptsEventStream = (request.headers.get("accept") || "").toLowerCase().includes("text/event-stream");
     if (!identity) {
       return Response.json({ error: { code: "MISSING_IDENTITY", message: "Missing identity" } }, { status: 400 });
     }
@@ -2606,28 +2578,103 @@ data: ${JSON.stringify(data)}
     if (!isAuthorized) {
       return Response.json({ error: { code: "UNAUTHORIZED", message: "Unauthorized" } }, { status: 401 });
     }
+    let rawBody = "";
     try {
-      const body = await request.json();
-      const manager = managers.get(identity);
-      if (!manager) {
+      rawBody = await request.text();
+      const body = rawBody ? JSON.parse(rawBody) : null;
+      if (!body || typeof body !== "object") {
         return Response.json(
           {
             error: {
-              code: "NO_CONNECTION",
-              message: "No SSE connection found. Please establish SSE connection first."
+              code: "INVALID_REQUEST",
+              message: "Invalid JSON-RPC request body"
             }
           },
           { status: 400 }
         );
       }
-      const response = await manager.handleRequest(body);
-      return Response.json(response);
+      const resolvedClientMetadata = await resolveClientMetadata(request);
+      if (!acceptsEventStream) {
+        const manager2 = new SSEConnectionManager(
+          toManagerOptions(identity, resolvedClientMetadata),
+          () => {
+          }
+        );
+        try {
+          const response = await manager2.handleRequest(body);
+          return Response.json(response);
+        } finally {
+          manager2.dispose();
+        }
+      }
+      const stream = new TransformStream();
+      const writer = stream.writable.getWriter();
+      const encoder = new TextEncoder();
+      let streamWritable = true;
+      const sendSSE = (event, data) => {
+        if (!streamWritable) return;
+        const message = `event: ${event}
+data: ${JSON.stringify(data)}
+
+`;
+        writer.write(encoder.encode(message)).catch(() => {
+          streamWritable = false;
+        });
+      };
+      const manager = new SSEConnectionManager(
+        toManagerOptions(identity, resolvedClientMetadata),
+        (event) => {
+          if (isRpcResponseEvent(event)) {
+            sendSSE("rpc-response", event);
+          } else if ("type" in event && "sessionId" in event) {
+            sendSSE("connection", event);
+          } else {
+            sendSSE("observability", event);
+          }
+        }
+      );
+      sendSSE("connected", { timestamp: Date.now() });
+      void (async () => {
+        try {
+          await manager.handleRequest(body);
+        } catch (error) {
+          const err = error instanceof Error ? error : new Error("Unknown error");
+          sendSSE("rpc-response", {
+            id: body.id || "unknown",
+            error: {
+              code: "EXECUTION_ERROR",
+              message: err.message
+            }
+          });
+        } finally {
+          streamWritable = false;
+          manager.dispose();
+          writer.close().catch(() => {
+          });
+        }
+      })();
+      return new Response(stream.readable, {
+        status: 200,
+        headers: {
+          "Content-Type": "text/event-stream",
+          "Cache-Control": "no-cache, no-transform",
+          "Connection": "keep-alive",
+          "X-Accel-Buffering": "no"
+        }
+      });
     } catch (error) {
+      const err = error instanceof Error ? error : new Error("Unknown error");
+      console.error("[MCP Next Handler] Failed to handle RPC", {
+        identity,
+        message: err.message,
+        stack: err.stack,
+        rawBody: rawBody.slice(0, 500)
+      });
       return Response.json(
         {
           error: {
             code: "EXECUTION_ERROR",
-            message: error instanceof Error ? error.message : "Unknown error"
+            message: err.message
           }
         },
         { status: 500 }
@@ -2636,62 +2683,27 @@ data: ${JSON.stringify(data)}
   }
   return { GET, POST };
 }
-var DEFAULT_REQUEST_TIMEOUT = 6e4;
-var MAX_RECONNECT_ATTEMPTS = 5;
-var BASE_RECONNECT_DELAY = 1e3;
 var SSEClient = class {
   constructor(options) {
     this.options = options;
-    __publicField(this, "eventSource", null);
-    __publicField(this, "pendingRequests", /* @__PURE__ */ new Map());
     __publicField(this, "resourceCache", /* @__PURE__ */ new Map());
-    __publicField(this, "reconnectAttempts", 0);
-    __publicField(this, "isManuallyDisconnected", false);
-    __publicField(this, "connectionPromise", null);
-    __publicField(this, "connectionResolver", null);
+    __publicField(this, "connected", false);
   }
-  // ============================================
-  // Connection Management
-  // ============================================
-  /**
-   * Connect to the SSE endpoint
-   */
   connect() {
-    if (this.eventSource) {
+    if (this.connected) {
       return;
     }
-    this.isManuallyDisconnected = false;
-    this.options.onStatusChange?.("connecting");
-    this.connectionPromise = new Promise((resolve) => {
-      this.connectionResolver = resolve;
-    });
-    const url = this.buildUrl();
-    this.eventSource = new EventSource(url);
-    this.setupEventListeners();
+    this.connected = true;
+    this.options.onStatusChange?.("connected");
+    this.log("RPC mode: post_stream");
   }
-  /**
-   * Disconnect from the SSE endpoint
-   */
   disconnect() {
-    this.isManuallyDisconnected = true;
-    if (this.eventSource) {
-      this.eventSource.close();
-      this.eventSource = null;
-    }
-    this.connectionPromise = null;
-    this.connectionResolver = null;
-    this.rejectAllPendingRequests(new Error("Connection closed"));
+    this.connected = false;
     this.options.onStatusChange?.("disconnected");
   }
-  /**
-   * Check if connected to the SSE endpoint
-   */
   isConnected() {
-    return this.eventSource?.readyState === EventSource.OPEN;
+    return this.connected;
   }
-  // ============================================
-  // RPC Methods
-  // ============================================
   async getSessions() {
     return this.sendRequest("getSessions");
   }
@@ -2727,22 +2739,10 @@ var SSEClient = class {
   async readResource(sessionId, uri) {
     return this.sendRequest("readResource", { sessionId, uri });
   }
-  // ============================================
-  // Resource Preloading (for instant UI loading)
-  // ============================================
-  /**
-   * Preload UI resources for tools that have UI metadata.
-   * Call this when tools are discovered to enable instant MCP App UI loading.
-   */
   preloadToolUiResources(sessionId, tools) {
     for (const tool of tools) {
       const uri = this.extractUiResourceUri(tool);
-      if (!uri) continue;
-      if (this.resourceCache.has(uri)) {
-        this.log(`Resource already cached: ${uri}`);
-        continue;
-      }
-      this.log(`Preloading UI resource for tool "${tool.name}": ${uri}`);
+      if (!uri || this.resourceCache.has(uri)) continue;
       const promise = this.sendRequest("readResource", { sessionId, uri }).catch((err) => {
         this.log(`Failed to preload resource ${uri}: ${err.message}`, "warn");
         this.resourceCache.delete(uri);
@@ -2751,43 +2751,24 @@ var SSEClient = class {
       this.resourceCache.set(uri, promise);
     }
   }
-  /**
-   * Get a preloaded resource from cache, or fetch if not cached.
-   */
   getOrFetchResource(sessionId, uri) {
     const cached = this.resourceCache.get(uri);
-    if (cached) {
-      this.log(`Cache hit for resource: ${uri}`);
-      return cached;
-    }
-    this.log(`Cache miss, fetching resource: ${uri}`);
+    if (cached) return cached;
     const promise = this.sendRequest("readResource", { sessionId, uri });
     this.resourceCache.set(uri, promise);
     return promise;
   }
-  /**
-   * Check if a resource is already cached
-   */
   hasPreloadedResource(uri) {
     return this.resourceCache.has(uri);
   }
-  /**
-   * Clear the resource cache
-   */
   clearResourceCache() {
     this.resourceCache.clear();
   }
-  // ============================================
-  // Private: Request Handling
-  // ============================================
-  /**
-   * Send an RPC request and return the response directly from HTTP.
-   * This bypasses SSE latency by returning results in the HTTP response body.
-   */
   async sendRequest(method, params) {
-    if (this.connectionPromise) {
-      await this.connectionPromise;
+    if (!this.connected) {
+      this.connect();
     }
+    this.log(`RPC request via post_stream: ${method}`);
     const request = {
       id: `rpc_${nanoid.nanoid(10)}`,
       method,
@@ -2801,103 +2782,93 @@ var SSEClient = class {
     if (!response.ok) {
       throw new Error(`HTTP ${response.status}: ${response.statusText}`);
     }
-    const data = await response.json();
-    return this.parseRpcResponse(data, request.id);
+    const contentType = (response.headers.get("content-type") || "").toLowerCase();
+    if (!contentType.includes("text/event-stream")) {
+      const data2 = await response.json();
+      return this.parseRpcResponse(data2);
+    }
+    const data = await this.readRpcResponseFromStream(response);
+    return this.parseRpcResponse(data);
+  }
+  async readRpcResponseFromStream(response) {
+    if (!response.body) {
+      throw new Error("Streaming response body is missing");
+    }
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let rpcResponse = null;
+    const dispatchBlock = (block) => {
+      const lines = block.split("\n");
+      let eventName = "message";
+      const dataLines = [];
+      for (const rawLine of lines) {
+        const line = rawLine.replace(/\r$/, "");
+        if (!line || line.startsWith(":")) continue;
+        if (line.startsWith("event:")) {
+          eventName = line.slice("event:".length).trim();
+          continue;
+        }
+        if (line.startsWith("data:")) {
+          dataLines.push(line.slice("data:".length).trimStart());
+        }
+      }
+      if (!dataLines.length) return;
+      const payloadText = dataLines.join("\n");
+      let payload = payloadText;
+      try {
+        payload = JSON.parse(payloadText);
+      } catch {
+      }
+      switch (eventName) {
+        case "connected":
+          this.options.onStatusChange?.("connected");
+          break;
+        case "connection":
+          this.options.onConnectionEvent?.(payload);
+          break;
+        case "observability":
+          this.options.onObservabilityEvent?.(payload);
+          break;
+        case "rpc-response":
+          rpcResponse = payload;
+          break;
+      }
+    };
+    while (true) {
+      const { value, done } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      let separatorMatch = buffer.match(/\r?\n\r?\n/);
+      while (separatorMatch && separatorMatch.index !== void 0) {
+        const separatorIndex = separatorMatch.index;
+        const separatorLength = separatorMatch[0].length;
+        const block = buffer.slice(0, separatorIndex);
+        buffer = buffer.slice(separatorIndex + separatorLength);
+        dispatchBlock(block);
+        separatorMatch = buffer.match(/\r?\n\r?\n/);
+      }
+    }
+    if (buffer.trim()) {
+      dispatchBlock(buffer);
+    }
+    if (!rpcResponse) {
+      throw new Error("Missing rpc-response event in streamed RPC result");
+    }
+    return rpcResponse;
   }
-  /**
-   * Parse RPC response and handle different response formats
-   */
-  parseRpcResponse(data, requestId) {
+  parseRpcResponse(data) {
     if ("result" in data) {
       return data.result;
     }
     if ("error" in data && data.error) {
       throw new Error(data.error.message || "Unknown RPC error");
     }
-    if ("acknowledged" in data) {
-      return this.waitForSseResponse(requestId);
+    if (data && typeof data === "object" && "id" in data) {
+      return void 0;
     }
     throw new Error("Invalid RPC response format");
   }
-  /**
-   * Wait for RPC response via SSE (legacy fallback)
-   */
-  waitForSseResponse(requestId) {
-    const timeoutMs = this.options.requestTimeout ?? DEFAULT_REQUEST_TIMEOUT;
-    return new Promise((resolve, reject) => {
-      const timeoutId = setTimeout(() => {
-        this.pendingRequests.delete(requestId);
-        reject(new Error(`Request timeout after ${timeoutMs}ms`));
-      }, timeoutMs);
-      this.pendingRequests.set(requestId, {
-        resolve,
-        reject,
-        timeoutId
-      });
-    });
-  }
-  /**
-   * Handle RPC response received via SSE (legacy)
-   */
-  handleRpcResponse(response) {
-    const pending = this.pendingRequests.get(response.id);
-    if (!pending) return;
-    clearTimeout(pending.timeoutId);
-    this.pendingRequests.delete(response.id);
-    if (response.error) {
-      pending.reject(new Error(response.error.message));
-    } else {
-      pending.resolve(response.result);
-    }
-  }
-  // ============================================
-  // Private: Event Handling
-  // ============================================
-  setupEventListeners() {
-    if (!this.eventSource) return;
-    this.eventSource.addEventListener("open", () => {
-      this.log("Connected");
-      this.reconnectAttempts = 0;
-      this.options.onStatusChange?.("connected");
-    });
-    this.eventSource.addEventListener("connected", () => {
-      this.log("Server ready");
-      this.connectionResolver?.();
-      this.connectionResolver = null;
-    });
-    this.eventSource.addEventListener("connection", (e) => {
-      const event = JSON.parse(e.data);
-      this.options.onConnectionEvent?.(event);
-    });
-    this.eventSource.addEventListener("observability", (e) => {
-      const event = JSON.parse(e.data);
-      this.options.onObservabilityEvent?.(event);
-    });
-    this.eventSource.addEventListener("rpc-response", (e) => {
-      const response = JSON.parse(e.data);
-      this.handleRpcResponse(response);
-    });
-    this.eventSource.addEventListener("error", () => {
-      this.log("Connection error", "error");
-      this.options.onStatusChange?.("error");
-      this.attemptReconnect();
-    });
-  }
-  attemptReconnect() {
-    if (this.isManuallyDisconnected || this.reconnectAttempts >= MAX_RECONNECT_ATTEMPTS) {
-      return;
-    }
-    this.reconnectAttempts++;
-    const delay = BASE_RECONNECT_DELAY * this.reconnectAttempts;
-    this.log(`Reconnecting in ${delay}ms (attempt ${this.reconnectAttempts}/${MAX_RECONNECT_ATTEMPTS})`);
-    setTimeout(() => {
-      this.disconnect();
-      this.connect();
-    }, delay);
-  }
-  // ============================================
-  // Private: Utilities
-  // ============================================
   buildUrl() {
     const url = new URL(this.options.url, globalThis.location?.origin);
     url.searchParams.set("identity", this.options.identity);
@@ -2908,20 +2879,14 @@ var SSEClient = class {
   }
   buildHeaders() {
     const headers = {
-      "Content-Type": "application/json"
+      "Content-Type": "application/json",
+      "Accept": "text/event-stream"
     };
     if (this.options.authToken) {
       headers["Authorization"] = `Bearer ${this.options.authToken}`;
     }
     return headers;
   }
-  rejectAllPendingRequests(error) {
-    for (const [, pending] of this.pendingRequests) {
-      clearTimeout(pending.timeoutId);
-      pending.reject(error);
-    }
-    this.pendingRequests.clear();
-  }
   extractUiResourceUri(tool) {
     const meta = tool._meta?.ui;
     if (!meta || typeof meta !== "object") return void 0;