@mcp-ts/sdk 1.3.1 → 1.3.3

package/dist/client/vue.js

@@ -7,62 +7,27 @@ var appBridge = require('@modelcontextprotocol/ext-apps/app-bridge');
 var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-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");
   }
@@ -98,22 +63,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);
@@ -122,43 +75,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,
@@ -172,103 +106,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);
@@ -279,20 +203,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;
@@ -343,23 +261,35 @@ function useMcp(options) {
   } = options;
   const clientRef = vue.shallowRef(null);
   const isMountedRef = vue.ref(true);
+  const suppressAuthRedirectSessions = vue.ref(/* @__PURE__ */ new Set());
   const connections = vue.ref([]);
   const status = vue.ref("disconnected");
   const isInitializing = vue.ref(false);
   const updateConnectionsFromEvent = (event) => {
     if (!isMountedRef.value) return;
+    const isTransientReconnectState = (state) => state === "INITIALIZING" || state === "VALIDATING" || state === "RECONNECTING" || state === "CONNECTING" || state === "CONNECTED" || state === "DISCOVERING";
     switch (event.type) {
       case "state_changed": {
         const existing = connections.value.find((c) => c.sessionId === event.sessionId);
         if (existing) {
+          const nextState = existing.state === "READY" && isTransientReconnectState(event.state) ? existing.state : event.state;
           const index = connections.value.indexOf(existing);
-          connections.value[index] = { ...existing, state: event.state };
+          connections.value[index] = {
+            ...existing,
+            state: nextState,
+            // update createdAt if present in event, otherwise keep existing
+            createdAt: event.createdAt ? new Date(event.createdAt) : existing.createdAt
+          };
         } else {
+          if (event.state === "DISCONNECTED") {
+            break;
+          }
           connections.value = [...connections.value, {
             sessionId: event.sessionId,
             serverId: event.serverId,
             serverName: event.serverName,
             state: event.state,
+            createdAt: event.createdAt ? new Date(event.createdAt) : void 0,
             tools: []
           }];
         }
@@ -375,15 +305,17 @@ function useMcp(options) {
       case "auth_required": {
         if (event.authUrl) {
           onLog?.("info", `OAuth required - redirecting to ${event.authUrl}`, { authUrl: event.authUrl });
-          if (onRedirect) {
-            onRedirect(event.authUrl);
-          } else if (typeof window !== "undefined") {
-            window.location.href = event.authUrl;
+          if (!suppressAuthRedirectSessions.value.has(event.sessionId)) {
+            if (onRedirect) {
+              onRedirect(event.authUrl);
+            } else if (typeof window !== "undefined") {
+              window.location.href = event.authUrl;
+            }
           }
         }
         const index = connections.value.findIndex((c) => c.sessionId === event.sessionId);
         if (index !== -1) {
-          connections.value[index] = { ...connections.value[index], state: "AUTHENTICATING" };
+          connections.value[index] = { ...connections.value[index], state: "AUTHENTICATING", authUrl: event.authUrl };
         }
         break;
       }
@@ -413,7 +345,8 @@ function useMcp(options) {
           serverName: s.serverName ?? "Unknown Server",
           serverUrl: s.serverUrl,
           transport: s.transport,
-          state: "VALIDATING",
+          state: s.active === false ? "AUTHENTICATING" : "VALIDATING",
+          createdAt: new Date(s.createdAt),
           tools: []
         }));
       }
@@ -421,9 +354,15 @@ function useMcp(options) {
         sessions.map(async (session) => {
           if (clientRef.value) {
             try {
+              if (session.active === false) {
+                return;
+              }
+              suppressAuthRedirectSessions.value.add(session.sessionId);
               await clientRef.value.restoreSession(session.sessionId);
             } catch (error) {
               console.error(`[useMcp] Failed to validate session ${session.sessionId}:`, error);
+            } finally {
+              suppressAuthRedirectSessions.value.delete(session.sessionId);
             }
           }
         })
@@ -456,7 +395,8 @@ function useMcp(options) {
         if (isMountedRef.value) {
           status.value = newStatus;
         }
-      }
+      },
+      debug: options.debug
     };
     const client = new SSEClient(clientOptions);
     clientRef.value = client;
@@ -506,6 +446,13 @@ function useMcp(options) {
     }
     return await clientRef.value.finishAuth(sessionId, code);
   };
+  const resumeAuth = async (sessionId) => {
+    if (!clientRef.value) {
+      throw new Error("SSE client not initialized");
+    }
+    suppressAuthRedirectSessions.value.delete(sessionId);
+    await clientRef.value.restoreSession(sessionId);
+  };
   const callTool = async (sessionId, toolName, toolArgs) => {
     if (!clientRef.value) {
       throw new Error("SSE client not initialized");
@@ -567,12 +514,14 @@ function useMcp(options) {
     connectSSE,
     disconnectSSE,
     finishAuth,
+    resumeAuth,
     callTool,
     listTools,
     listPrompts,
     getPrompt,
     listResources,
-    readResource
+    readResource,
+    sseClient: clientRef.value
   };
 }
 var HOST_INFO = { name: "mcp-ts-host", version: "1.0.0" };