mcp-use 1.2.1 → 1.2.2-canary.1

package/dist/index.cjs

@@ -90,7 +90,15 @@ var init_logging = __esm({
         this._level = level;
       }
       shouldLog(level) {
-        const levels = ["error", "warn", "info", "http", "verbose", "debug", "silly"];
+        const levels = [
+          "error",
+          "warn",
+          "info",
+          "http",
+          "verbose",
+          "debug",
+          "silly"
+        ];
         const currentIndex = levels.indexOf(this._level);
         const messageIndex = levels.indexOf(level);
         return messageIndex <= currentIndex;
@@ -163,7 +171,10 @@ var init_logging = __esm({
         if (!isNodeJSEnvironment()) {
           if (!this.simpleInstances[name]) {
             const debugEnv = typeof process !== "undefined" && process.env?.DEBUG || void 0;
-            this.simpleInstances[name] = new SimpleConsoleLogger(name, resolveLevel(debugEnv));
+            this.simpleInstances[name] = new SimpleConsoleLogger(
+              name,
+              resolveLevel(debugEnv)
+            );
           }
           return this.simpleInstances[name];
         }
@@ -237,10 +248,8 @@ var init_logging = __esm({
       }
       static setDebug(enabled) {
         let level;
-        if (enabled === 2 || enabled === true)
-          level = "debug";
-        else if (enabled === 1)
-          level = "info";
+        if (enabled === 2 || enabled === true) level = "debug";
+        else if (enabled === 1) level = "info";
         else level = "info";
         Object.values(this.simpleInstances).forEach((logger2) => {
           logger2.level = level;
@@ -280,7 +289,9 @@ async function initializeLangfuse(agentId, metadata, metadataProvider, tagsProvi
   try {
     const langfuseModule = await import("langfuse-langchain").catch(() => null);
     if (!langfuseModule) {
-      logger.debug("Langfuse package not installed - tracing disabled. Install with: npm install @langfuse/langchain");
+      logger.debug(
+        "Langfuse package not installed - tracing disabled. Install with: npm install @langfuse/langchain"
+      );
       return;
     }
     const { CallbackHandler } = langfuseModule;
@@ -309,10 +320,23 @@ async function initializeLangfuse(agentId, metadata, metadataProvider, tagsProvi
         const enhancedTags = [...tags || [], ...customTags];
         const enhancedMetadata = { ...metadata2 || {}, ...metadataToAdd };
         if (this.verbose) {
-          logger.debug(`Langfuse: Chain start with custom tags: ${JSON.stringify(enhancedTags)}`);
-          logger.debug(`Langfuse: Chain start with metadata: ${JSON.stringify(enhancedMetadata)}`);
+          logger.debug(
+            `Langfuse: Chain start with custom tags: ${JSON.stringify(enhancedTags)}`
+          );
+          logger.debug(
+            `Langfuse: Chain start with metadata: ${JSON.stringify(enhancedMetadata)}`
+          );
         }
-        return super.handleChainStart(chain, inputs, runId, parentRunId, enhancedTags, enhancedMetadata, name, kwargs);
+        return super.handleChainStart(
+          chain,
+          inputs,
+          runId,
+          parentRunId,
+          enhancedTags,
+          enhancedMetadata,
+          name,
+          kwargs
+        );
       }
       // Get custom tags based on environment and agent configuration
       getCustomTags() {
@@ -388,7 +412,9 @@ async function initializeLangfuse(agentId, metadata, metadataProvider, tagsProvi
       async handleRetrieverStart(...args) {
         logger.debug("Langfuse: Retriever start intercepted");
         if (this.verbose) {
-          logger.debug(`Langfuse: Retriever start args: ${JSON.stringify(args)}`);
+          logger.debug(
+            `Langfuse: Retriever start args: ${JSON.stringify(args)}`
+          );
         }
         return super.handleRetrieverStart(...args);
       }
@@ -414,9 +440,13 @@ async function initializeLangfuse(agentId, metadata, metadataProvider, tagsProvi
       secretKey: process.env.LANGFUSE_SECRET_KEY,
       baseUrl: process.env.LANGFUSE_HOST || process.env.LANGFUSE_BASEURL || "https://cloud.langfuse.com",
       flushAt: Number.parseInt(process.env.LANGFUSE_FLUSH_AT || "15"),
-      flushInterval: Number.parseInt(process.env.LANGFUSE_FLUSH_INTERVAL || "10000"),
+      flushInterval: Number.parseInt(
+        process.env.LANGFUSE_FLUSH_INTERVAL || "10000"
+      ),
       release: process.env.LANGFUSE_RELEASE,
-      requestTimeout: Number.parseInt(process.env.LANGFUSE_REQUEST_TIMEOUT || "10000"),
+      requestTimeout: Number.parseInt(
+        process.env.LANGFUSE_REQUEST_TIMEOUT || "10000"
+      ),
       enabled: process.env.LANGFUSE_ENABLED !== "false",
       // Set trace name - can be customized via metadata.trace_name or defaults to 'mcp-use-agent'
       traceName: initialMetadata.trace_name || process.env.LANGFUSE_TRACE_NAME || "mcp-use-agent",
@@ -426,14 +456,29 @@ async function initializeLangfuse(agentId, metadata, metadataProvider, tagsProvi
       tags: initialTags.length > 0 ? initialTags : void 0,
       metadata: initialMetadata || void 0
     };
-    logger.debug("Langfuse handler config:", JSON.stringify({
-      traceName: config2.traceName,
-      sessionId: config2.sessionId,
-      userId: config2.userId,
-      tags: config2.tags
-    }, null, 2));
-    langfuseState.handler = new LoggingCallbackHandler(config2, agentId, metadata, metadataProvider, tagsProvider);
-    logger.debug("Langfuse observability initialized successfully with logging enabled");
+    logger.debug(
+      "Langfuse handler config:",
+      JSON.stringify(
+        {
+          traceName: config2.traceName,
+          sessionId: config2.sessionId,
+          userId: config2.userId,
+          tags: config2.tags
+        },
+        null,
+        2
+      )
+    );
+    langfuseState.handler = new LoggingCallbackHandler(
+      config2,
+      agentId,
+      metadata,
+      metadataProvider,
+      tagsProvider
+    );
+    logger.debug(
+      "Langfuse observability initialized successfully with logging enabled"
+    );
     try {
       const langfuseCore = await import("langfuse").catch(() => null);
       if (langfuseCore) {
@@ -467,7 +512,9 @@ var init_langfuse = __esm({
     };
     __name(initializeLangfuse, "initializeLangfuse");
     if (langfuseDisabled) {
-      logger.debug("Langfuse tracing disabled via MCP_USE_LANGFUSE environment variable");
+      logger.debug(
+        "Langfuse tracing disabled via MCP_USE_LANGFUSE environment variable"
+      );
     } else if (!process.env.LANGFUSE_PUBLIC_KEY || !process.env.LANGFUSE_SECRET_KEY) {
       logger.debug(
         "Langfuse API keys not found - tracing disabled. Set LANGFUSE_PUBLIC_KEY and LANGFUSE_SECRET_KEY to enable"
@@ -682,9 +729,14 @@ var LangChainAdapter = class extends BaseAdapter {
       // Blank is acceptable but discouraged.
       schema: argsSchema,
       func: /* @__PURE__ */ __name(async (input) => {
-        logger.debug(`MCP tool "${mcpTool.name}" received input: ${JSON.stringify(input)}`);
+        logger.debug(
+          `MCP tool "${mcpTool.name}" received input: ${JSON.stringify(input)}`
+        );
         try {
-          const result = await connector.callTool(mcpTool.name, input);
+          const result = await connector.callTool(
+            mcpTool.name,
+            input
+          );
           return JSON.stringify(result);
         } catch (err) {
           logger.error(`Error executing MCP tool: ${err.message}`);
@@ -844,7 +896,9 @@ var ConnectMCPServerTool = class extends MCPServerTool {
       const numTools = serverTools.length;
       return `Connected to MCP server '${serverName}'. ${numTools} tools are now available.`;
     } catch (error) {
-      logger.error(`Error connecting to server '${serverName}': ${String(error)}`);
+      logger.error(
+        `Error connecting to server '${serverName}': ${String(error)}`
+      );
       return `Failed to connect to server '${serverName}': ${String(error)}`;
     }
   }
@@ -880,7 +934,9 @@ var ListMCPServersTool = class extends MCPServerTool {
         outputLines.push(`${numberOfTools} tools available for this server
 `);
       } catch (error) {
-        logger.error(`Unexpected error listing tools for server '${serverName}': ${String(error)}`);
+        logger.error(
+          `Unexpected error listing tools for server '${serverName}': ${String(error)}`
+        );
       }
     }
     return outputLines.join("\n");
@@ -941,10 +997,10 @@ var ServerManager = class {
     }
     const tableData = allServerNames.map((name) => ({
       "Server Name": name,
-      "Connected": activeSessionNames.includes(name) ? "\u2705" : "\u274C",
-      "Initialized": this.initializedServers[name] ? "\u2705" : "\u274C",
+      Connected: activeSessionNames.includes(name) ? "\u2705" : "\u274C",
+      Initialized: this.initializedServers[name] ? "\u2705" : "\u274C",
       "Tool Count": this.serverTools[name]?.length ?? 0,
-      "Active": this.activeServer === name ? "\u2705" : "\u274C"
+      Active: this.activeServer === name ? "\u2705" : "\u274C"
     }));
     logger.info(`Server Manager State: [${context}]`);
     console.table(tableData);
@@ -961,13 +1017,19 @@ var ServerManager = class {
       try {
         let session = null;
         session = this.client.getSession(serverName);
-        logger.debug(`Using existing session for server '${serverName}' to prefetch tools.`);
+        logger.debug(
+          `Using existing session for server '${serverName}' to prefetch tools.`
+        );
         if (!session) {
           session = await this.client.createSession(serverName).catch((createSessionError) => {
-            logger.warn(`Could not create session for '${serverName}' during prefetch: ${createSessionError}`);
+            logger.warn(
+              `Could not create session for '${serverName}' during prefetch: ${createSessionError}`
+            );
             return null;
           });
-          logger.debug(`Temporarily created session for '${serverName}' to prefetch tools.`);
+          logger.debug(
+            `Temporarily created session for '${serverName}' to prefetch tools.`
+          );
         }
         if (session) {
           const connector = session.connector;
@@ -975,7 +1037,9 @@ var ServerManager = class {
           try {
             tools = await this.adapter.createToolsFromConnectors([connector]);
           } catch (toolFetchError) {
-            logger.error(`Failed to create tools from connector for server '${serverName}': ${toolFetchError}`);
+            logger.error(
+              `Failed to create tools from connector for server '${serverName}': ${toolFetchError}`
+            );
             continue;
           }
           const cachedTools = this.serverTools[serverName];
@@ -983,7 +1047,9 @@ var ServerManager = class {
           if (toolsChanged) {
             this.serverTools[serverName] = tools;
             this.initializedServers[serverName] = true;
-            logger.debug(`Prefetched ${tools.length} tools for server '${serverName}'.`);
+            logger.debug(
+              `Prefetched ${tools.length} tools for server '${serverName}'.`
+            );
           } else {
             logger.debug(
               `Tools for server '${serverName}' unchanged, using cached version.`
@@ -991,7 +1057,9 @@ var ServerManager = class {
           }
         }
       } catch (outerError) {
-        logger.error(`Error prefetching tools for server '${serverName}': ${outerError}`);
+        logger.error(
+          `Error prefetching tools for server '${serverName}': ${outerError}`
+        );
       }
     }
   }
@@ -1057,8 +1125,15 @@ var ObservabilityManager = class {
       const { langfuseHandler: langfuseHandler2, langfuseInitPromise: langfuseInitPromise2 } = await Promise.resolve().then(() => (init_langfuse(), langfuse_exports));
       if (this.agentId || this.metadata || this.metadataProvider || this.tagsProvider) {
         const { initializeLangfuse: initializeLangfuse2 } = await Promise.resolve().then(() => (init_langfuse(), langfuse_exports));
-        await initializeLangfuse2(this.agentId, this.metadata, this.metadataProvider, this.tagsProvider);
-        logger.debug(`ObservabilityManager: Reinitialized Langfuse with agent ID: ${this.agentId}, metadata: ${JSON.stringify(this.metadata)}`);
+        await initializeLangfuse2(
+          this.agentId,
+          this.metadata,
+          this.metadataProvider,
+          this.tagsProvider
+        );
+        logger.debug(
+          `ObservabilityManager: Reinitialized Langfuse with agent ID: ${this.agentId}, metadata: ${JSON.stringify(this.metadata)}`
+        );
       } else {
         const initPromise = langfuseInitPromise2();
         if (initPromise) {
@@ -1082,16 +1157,22 @@ var ObservabilityManager = class {
    */
   async getCallbacks() {
     if (!this.observe) {
-      logger.debug("ObservabilityManager: Observability disabled via observe=false");
+      logger.debug(
+        "ObservabilityManager: Observability disabled via observe=false"
+      );
       return [];
     }
     if (this.customCallbacks) {
-      logger.debug(`ObservabilityManager: Using ${this.customCallbacks.length} custom callbacks`);
+      logger.debug(
+        `ObservabilityManager: Using ${this.customCallbacks.length} custom callbacks`
+      );
       return this.customCallbacks;
     }
     await this.collectAvailableHandlers();
     if (this.availableHandlers.length > 0) {
-      logger.debug(`ObservabilityManager: Using ${this.availableHandlers.length} handlers`);
+      logger.debug(
+        `ObservabilityManager: Using ${this.availableHandlers.length} handlers`
+      );
     } else {
       logger.debug("ObservabilityManager: No callbacks configured");
     }
@@ -1148,7 +1229,9 @@ var ObservabilityManager = class {
       this.customCallbacks = [];
     }
     this.customCallbacks.push(callback);
-    logger.debug(`ObservabilityManager: Added custom callback: ${callback.constructor.name}`);
+    logger.debug(
+      `ObservabilityManager: Added custom callback: ${callback.constructor.name}`
+    );
   }
   /**
    * Clear all custom callbacks.
@@ -1280,7 +1363,15 @@ function getModelName(llm) {
   if ("_identifyingParams" in llm) {
     const identifyingParams = llm._identifyingParams;
     if (typeof identifyingParams === "object" && identifyingParams !== null) {
-      for (const key of ["model", "modelName", "model_name", "modelId", "model_id", "deploymentName", "deployment_name"]) {
+      for (const key of [
+        "model",
+        "modelName",
+        "model_name",
+        "modelId",
+        "model_id",
+        "deploymentName",
+        "deployment_name"
+      ]) {
         if (key in identifyingParams) {
           return String(identifyingParams[key]);
         }
@@ -1371,8 +1462,16 @@ var Telemetry = class _Telemetry {
     __name(this, "Telemetry");
   }
   static instance = null;
-  USER_ID_PATH = path2.join(getCacheHome(), "mcp_use_3", "telemetry_user_id");
-  VERSION_DOWNLOAD_PATH = path2.join(getCacheHome(), "mcp_use", "download_version");
+  USER_ID_PATH = path2.join(
+    getCacheHome(),
+    "mcp_use_3",
+    "telemetry_user_id"
+  );
+  VERSION_DOWNLOAD_PATH = path2.join(
+    getCacheHome(),
+    "mcp_use",
+    "download_version"
+  );
   PROJECT_API_KEY = "phc_lyTtbYwvkdSbrcMQNPiKiiRWrrM1seyKIMjycSvItEI";
   HOST = "https://eu.i.posthog.com";
   SCARF_GATEWAY_URL = "https://mcpuse.gateway.scarf.sh/events-ts";
@@ -1392,17 +1491,18 @@ var Telemetry = class _Telemetry {
     } else if (!isNodeJS) {
       this._posthogClient = null;
       this._scarfClient = null;
-      logger.debug("Telemetry disabled - non-Node.js environment detected (e.g., Cloudflare Workers)");
+      logger.debug(
+        "Telemetry disabled - non-Node.js environment detected (e.g., Cloudflare Workers)"
+      );
     } else {
-      logger.info("Anonymized telemetry enabled. Set MCP_USE_ANONYMIZED_TELEMETRY=false to disable.");
+      logger.info(
+        "Anonymized telemetry enabled. Set MCP_USE_ANONYMIZED_TELEMETRY=false to disable."
+      );
       try {
-        this._posthogClient = new import_posthog_node.PostHog(
-          this.PROJECT_API_KEY,
-          {
-            host: this.HOST,
-            disableGeoip: false
-          }
-        );
+        this._posthogClient = new import_posthog_node.PostHog(this.PROJECT_API_KEY, {
+          host: this.HOST,
+          disableGeoip: false
+        });
       } catch (e) {
         logger.warn(`Failed to initialize PostHog telemetry: ${e}`);
         this._posthogClient = null;
@@ -1512,7 +1612,9 @@ var Telemetry = class _Telemetry {
       if (!fs2.existsSync(this.VERSION_DOWNLOAD_PATH)) {
         shouldTrack = true;
         firstDownload = true;
-        fs2.mkdirSync(path2.dirname(this.VERSION_DOWNLOAD_PATH), { recursive: true });
+        fs2.mkdirSync(path2.dirname(this.VERSION_DOWNLOAD_PATH), {
+          recursive: true
+        });
         fs2.writeFileSync(this.VERSION_DOWNLOAD_PATH, currentVersion);
       } else {
         const savedVersion = fs2.readFileSync(this.VERSION_DOWNLOAD_PATH, "utf-8").trim();
@@ -1523,7 +1625,9 @@ var Telemetry = class _Telemetry {
         }
       }
       if (shouldTrack) {
-        logger.debug(`Tracking package download event with properties: ${JSON.stringify(properties)}`);
+        logger.debug(
+          `Tracking package download event with properties: ${JSON.stringify(properties)}`
+        );
         const eventProperties = { ...properties || {} };
         eventProperties.mcp_use_version = currentVersion;
         eventProperties.user_id = this.userId;
@@ -1581,8 +1685,7 @@ function generateToolDescriptions(tools, disallowedTools) {
   const disallowedSet = new Set(disallowedTools ?? []);
   const descriptions = [];
   for (const tool of tools) {
-    if (disallowedSet.has(tool.name))
-      continue;
+    if (disallowedSet.has(tool.name)) continue;
     const escaped = tool.description.replace(/\{/g, "{{").replace(/\}/g, "}}");
     descriptions.push(`- ${tool.name}: ${escaped}`);
   }
@@ -1595,7 +1698,9 @@ function buildSystemPromptContent(template, toolDescriptionLines, additionalInst
   if (template.includes("{tool_descriptions}")) {
     content = template.replace("{tool_descriptions}", block);
   } else {
-    console.warn("`{tool_descriptions}` placeholder not found; appending at end.");
+    console.warn(
+      "`{tool_descriptions}` placeholder not found; appending at end."
+    );
     content = `${template}
 
 Available tools:
@@ -1751,7 +1856,9 @@ var RemoteAgent = class {
             `Agent not found: Agent '${this.agentId}' does not exist or you don't have access to it. Please verify the agent ID and ensure it exists in your account.`
           );
         }
-        throw new Error(`Failed to create chat session: ${statusCode} - ${responseText}`);
+        throw new Error(
+          `Failed to create chat session: ${statusCode} - ${responseText}`
+        );
       }
       const chatData = await response.json();
       const chatId = chatData.id;
@@ -1824,8 +1931,12 @@ var RemoteAgent = class {
             "Internal server error occurred during agent execution. Please try again later or contact support if the issue persists."
           );
         } else {
-          logger.error(`\u274C Remote execution failed with status ${statusCode}: ${responseText}`);
-          throw new Error(`Remote agent execution failed: ${statusCode} - ${responseText}`);
+          logger.error(
+            `\u274C Remote execution failed with status ${statusCode}: ${responseText}`
+          );
+          throw new Error(
+            `Remote agent execution failed: ${statusCode} - ${responseText}`
+          );
         }
       }
       const result = await response.json();
@@ -1876,7 +1987,13 @@ Raw error: ${result}`
   }
   // eslint-disable-next-line require-yield
   async *stream(query, maxSteps, manageConnector, externalHistory, outputSchema) {
-    const result = await this.run(query, maxSteps, manageConnector, externalHistory, outputSchema);
+    const result = await this.run(
+      query,
+      maxSteps,
+      manageConnector,
+      externalHistory,
+      outputSchema
+    );
     return result;
   }
   async close() {
@@ -1952,7 +2069,9 @@ var MCPAgent = class {
       return;
     }
     if (!options.llm) {
-      throw new Error("llm is required for local execution. For remote execution, provide agentId instead.");
+      throw new Error(
+        "llm is required for local execution. For remote execution, provide agentId instead."
+      );
     }
     this.llm = options.llm;
     this.client = options.client;
@@ -1970,11 +2089,15 @@ var MCPAgent = class {
     this.verbose = options.verbose ?? false;
     this.observe = options.observe ?? true;
     if (!this.client && this.connectors.length === 0) {
-      throw new Error("Either 'client' or at least one 'connector' must be provided.");
+      throw new Error(
+        "Either 'client' or at least one 'connector' must be provided."
+      );
     }
     if (this.useServerManager) {
       if (!this.client) {
-        throw new Error("'client' must be provided when 'useServerManager' is true.");
+        throw new Error(
+          "'client' must be provided when 'useServerManager' is true."
+        );
       }
       this.adapter = options.adapter ?? new LangChainAdapter(this.disallowedTools);
       this.serverManager = options.serverManagerFactory?.(this.client) ?? new ServerManager(this.client, this.adapter);
@@ -2034,25 +2157,37 @@ var MCPAgent = class {
     } else {
       if (this.client) {
         this.sessions = this.client.getAllActiveSessions();
-        logger.info(`\u{1F50C} Found ${Object.keys(this.sessions).length} existing sessions`);
+        logger.info(
+          `\u{1F50C} Found ${Object.keys(this.sessions).length} existing sessions`
+        );
         if (Object.keys(this.sessions).length === 0) {
           logger.info("\u{1F504} No active sessions found, creating new ones...");
           this.sessions = await this.client.createAllSessions();
-          logger.info(`\u2705 Created ${Object.keys(this.sessions).length} new sessions`);
+          logger.info(
+            `\u2705 Created ${Object.keys(this.sessions).length} new sessions`
+          );
         }
         this._tools = await LangChainAdapter.createTools(this.client);
         this._tools.push(...this.additionalTools);
-        logger.info(`\u{1F6E0}\uFE0F Created ${this._tools.length} LangChain tools from client`);
+        logger.info(
+          `\u{1F6E0}\uFE0F Created ${this._tools.length} LangChain tools from client`
+        );
       } else {
-        logger.info(`\u{1F517} Connecting to ${this.connectors.length} direct connectors...`);
+        logger.info(
+          `\u{1F517} Connecting to ${this.connectors.length} direct connectors...`
+        );
         for (const connector of this.connectors) {
           if (!connector.isClientConnected) {
             await connector.connect();
           }
         }
-        this._tools = await this.adapter.createToolsFromConnectors(this.connectors);
+        this._tools = await this.adapter.createToolsFromConnectors(
+          this.connectors
+        );
         this._tools.push(...this.additionalTools);
-        logger.info(`\u{1F6E0}\uFE0F Created ${this._tools.length} LangChain tools from connectors`);
+        logger.info(
+          `\u{1F6E0}\uFE0F Created ${this._tools.length} LangChain tools from connectors`
+        );
       }
       logger.info(`\u{1F9F0} Found ${this._tools.length} tools across all connectors`);
       await this.createSystemMessageFromTools(this._tools);
@@ -2062,7 +2197,9 @@ var MCPAgent = class {
     const mcpServerInfo = this.getMCPServerInfo();
     if (Object.keys(mcpServerInfo).length > 0) {
       this.setMetadata(mcpServerInfo);
-      logger.debug(`MCP server info added to metadata: ${JSON.stringify(mcpServerInfo)}`);
+      logger.debug(
+        `MCP server info added to metadata: ${JSON.stringify(mcpServerInfo)}`
+      );
     }
     logger.info("\u2728 Agent initialization complete");
   }
@@ -2080,7 +2217,9 @@ var MCPAgent = class {
     if (this.memoryEnabled) {
       this.conversationHistory = [
         this.systemMessage,
-        ...this.conversationHistory.filter((m) => !(m instanceof import_langchain2.SystemMessage))
+        ...this.conversationHistory.filter(
+          (m) => !(m instanceof import_langchain2.SystemMessage)
+        )
       ];
     }
   }
@@ -2098,7 +2237,9 @@ var MCPAgent = class {
       systemPrompt: systemContent,
       middleware
     });
-    logger.debug(`Created agent with max_steps=${this.maxSteps} (via ModelCallLimitMiddleware) and ${this.callbacks.length} callbacks`);
+    logger.debug(
+      `Created agent with max_steps=${this.maxSteps} (via ModelCallLimitMiddleware) and ${this.callbacks.length} callbacks`
+    );
     return agent;
   }
   getConversationHistory() {
@@ -2108,8 +2249,7 @@ var MCPAgent = class {
     this.conversationHistory = this.memoryEnabled && this.systemMessage ? [this.systemMessage] : [];
   }
   addToHistory(message) {
-    if (this.memoryEnabled)
-      this.conversationHistory.push(message);
+    if (this.memoryEnabled) this.conversationHistory.push(message);
   }
   getSystemMessage() {
     return this.systemMessage;
@@ -2117,7 +2257,9 @@ var MCPAgent = class {
   setSystemMessage(message) {
     this.systemMessage = new import_langchain2.SystemMessage(message);
     if (this.memoryEnabled) {
-      this.conversationHistory = this.conversationHistory.filter((m) => !(m instanceof import_langchain2.SystemMessage));
+      this.conversationHistory = this.conversationHistory.filter(
+        (m) => !(m instanceof import_langchain2.SystemMessage)
+      );
       this.conversationHistory.unshift(this.systemMessage);
     }
     if (this._initialized && this._tools.length) {
@@ -2129,7 +2271,9 @@ var MCPAgent = class {
     this.disallowedTools = disallowedTools;
     this.adapter = new LangChainAdapter(this.disallowedTools);
     if (this._initialized) {
-      logger.debug("Agent already initialized. Changes will take effect on next initialization.");
+      logger.debug(
+        "Agent already initialized. Changes will take effect on next initialization."
+      );
     }
   }
   getDisallowedTools() {
@@ -2195,16 +2339,22 @@ var MCPAgent = class {
         try {
           const serialized = JSON.stringify(value);
           if (serialized.length > 1e3) {
-            logger.warn(`Metadata value for key '${sanitizedKey}' is too large. Truncating.`);
+            logger.warn(
+              `Metadata value for key '${sanitizedKey}' is too large. Truncating.`
+            );
             sanitized[sanitizedKey] = `${serialized.substring(0, 1e3)}...`;
           } else {
             sanitized[sanitizedKey] = value;
           }
         } catch (error) {
-          logger.warn(`Failed to serialize metadata value for key '${sanitizedKey}': ${error}. Skipping.`);
+          logger.warn(
+            `Failed to serialize metadata value for key '${sanitizedKey}': ${error}. Skipping.`
+          );
         }
       } else {
-        logger.warn(`Unsupported metadata value type for key '${sanitizedKey}': ${typeof value}. Skipping.`);
+        logger.warn(
+          `Unsupported metadata value type for key '${sanitizedKey}': ${typeof value}. Skipping.`
+        );
       }
     }
     return sanitized;
@@ -2251,15 +2401,24 @@ var MCPAgent = class {
               };
             }
           } catch (error) {
-            logger.warn(`Failed to get config for server '${serverName}': ${error}`);
-            serverConfigs[serverName] = { type: "error", error: "config_unavailable" };
+            logger.warn(
+              `Failed to get config for server '${serverName}': ${error}`
+            );
+            serverConfigs[serverName] = {
+              type: "error",
+              error: "config_unavailable"
+            };
           }
         }
         serverInfo.mcp_server_configs = serverConfigs;
       } else if (this.connectors && this.connectors.length > 0) {
         serverInfo.mcp_servers_count = this.connectors.length;
-        serverInfo.mcp_server_names = this.connectors.map((c) => c.publicIdentifier);
-        serverInfo.mcp_server_types = this.connectors.map((c) => c.constructor.name);
+        serverInfo.mcp_server_names = this.connectors.map(
+          (c) => c.publicIdentifier
+        );
+        serverInfo.mcp_server_types = this.connectors.map(
+          (c) => c.constructor.name
+        );
       }
     } catch (error) {
       logger.warn(`Failed to collect MCP server info: ${error}`);
@@ -2313,7 +2472,13 @@ var MCPAgent = class {
   }
   async run(query, maxSteps, manageConnector, externalHistory, outputSchema) {
     if (this.isRemote && this.remoteAgent) {
-      return this.remoteAgent.run(query, maxSteps, manageConnector, externalHistory, outputSchema);
+      return this.remoteAgent.run(
+        query,
+        maxSteps,
+        manageConnector,
+        externalHistory,
+        outputSchema
+      );
     }
     const generator = this.stream(
       query,
@@ -2326,7 +2491,13 @@ var MCPAgent = class {
   }
   async *stream(query, maxSteps, manageConnector = true, externalHistory, outputSchema) {
     if (this.isRemote && this.remoteAgent) {
-      const result = await this.remoteAgent.run(query, maxSteps, manageConnector, externalHistory, outputSchema);
+      const result = await this.remoteAgent.run(
+        query,
+        maxSteps,
+        manageConnector,
+        externalHistory,
+        outputSchema
+      );
       return result;
     }
     let initializedHere = false;
@@ -2371,27 +2542,31 @@ var MCPAgent = class {
       logger.info("\u{1F3C1} Starting agent execution");
       const maxRestarts = 3;
       let restartCount = 0;
-      const accumulatedMessages = [...langchainHistory, new import_langchain2.HumanMessage(query)];
+      const accumulatedMessages = [
+        ...langchainHistory,
+        new import_langchain2.HumanMessage(query)
+      ];
       while (restartCount <= maxRestarts) {
         const inputs = { messages: accumulatedMessages };
         let shouldRestart = false;
-        const stream = await this._agentExecutor.stream(
-          inputs,
-          {
-            streamMode: "updates",
-            // Get updates as they happen
-            callbacks: this.callbacks,
-            metadata: this.getMetadata(),
-            tags: this.getTags(),
-            // Set trace name for LangChain/Langfuse
-            runName: this.metadata.trace_name || "mcp-use-agent",
-            // Pass sessionId for Langfuse if present in metadata
-            ...this.metadata.session_id && { sessionId: this.metadata.session_id }
+        const stream = await this._agentExecutor.stream(inputs, {
+          streamMode: "updates",
+          // Get updates as they happen
+          callbacks: this.callbacks,
+          metadata: this.getMetadata(),
+          tags: this.getTags(),
+          // Set trace name for LangChain/Langfuse
+          runName: this.metadata.trace_name || "mcp-use-agent",
+          // Pass sessionId for Langfuse if present in metadata
+          ...this.metadata.session_id && {
+            sessionId: this.metadata.session_id
           }
-        );
+        });
         for await (const chunk of stream) {
           for (const [nodeName, nodeOutput] of Object.entries(chunk)) {
-            logger.debug(`\u{1F4E6} Node '${nodeName}' output: ${JSON.stringify(nodeOutput)}`);
+            logger.debug(
+              `\u{1F4E6} Node '${nodeName}' output: ${JSON.stringify(nodeOutput)}`
+            );
             if (nodeOutput && typeof nodeOutput === "object" && "messages" in nodeOutput) {
               let messages = nodeOutput.messages;
               if (!Array.isArray(messages)) {
@@ -2413,7 +2588,9 @@ var MCPAgent = class {
                     if (toolInputStr.length > 100) {
                       toolInputStr = `${toolInputStr.slice(0, 97)}...`;
                     }
-                    logger.info(`\u{1F527} Tool call: ${toolName} with input: ${toolInputStr}`);
+                    logger.info(
+                      `\u{1F527} Tool call: ${toolName} with input: ${toolInputStr}`
+                    );
                     yield {
                       action: {
                         tool: toolName,
@@ -2435,9 +2612,15 @@ var MCPAgent = class {
                   logger.info(`\u{1F4C4} Tool result: ${observationStr}`);
                   if (this.useServerManager && this.serverManager) {
                     const currentTools = this.serverManager.tools;
-                    const currentToolNames = new Set(currentTools.map((t) => t.name));
-                    const existingToolNames = new Set(this._tools.map((t) => t.name));
-                    if (currentToolNames.size !== existingToolNames.size || [...currentToolNames].some((n) => !existingToolNames.has(n))) {
+                    const currentToolNames = new Set(
+                      currentTools.map((t) => t.name)
+                    );
+                    const existingToolNames = new Set(
+                      this._tools.map((t) => t.name)
+                    );
+                    if (currentToolNames.size !== existingToolNames.size || [...currentToolNames].some(
+                      (n) => !existingToolNames.has(n)
+                    )) {
                       logger.info(
                         `\u{1F504} Tools changed during execution. New tools: ${[...currentToolNames].join(", ")}`
                       );
@@ -2472,7 +2655,9 @@ var MCPAgent = class {
           break;
         }
         if (restartCount > maxRestarts) {
-          logger.warn(`\u26A0\uFE0F Max restarts (${maxRestarts}) reached. Continuing with current tools.`);
+          logger.warn(
+            `\u26A0\uFE0F Max restarts (${maxRestarts}) reached. Continuing with current tools.`
+          );
           break;
         }
       }
@@ -2491,17 +2676,25 @@ var MCPAgent = class {
             outputSchema
           );
           if (this.memoryEnabled) {
-            this.addToHistory(new import_langchain2.AIMessage(`Structured result: ${JSON.stringify(structuredResult)}`));
+            this.addToHistory(
+              new import_langchain2.AIMessage(
+                `Structured result: ${JSON.stringify(structuredResult)}`
+              )
+            );
           }
           logger.info("\u2705 Structured output successful");
           success = true;
           return structuredResult;
         } catch (e) {
           logger.error(`\u274C Structured output failed: ${e}`);
-          throw new Error(`Failed to generate structured output: ${e instanceof Error ? e.message : String(e)}`);
+          throw new Error(
+            `Failed to generate structured output: ${e instanceof Error ? e.message : String(e)}`
+          );
         }
       }
-      logger.info(`\u{1F389} Agent execution complete in ${((Date.now() - startTime) / 1e3).toFixed(2)} seconds`);
+      logger.info(
+        `\u{1F389} Agent execution complete in ${((Date.now() - startTime) / 1e3).toFixed(2)} seconds`
+      );
       success = true;
       return finalOutput || "No output generated";
     } catch (e) {
@@ -2528,7 +2721,9 @@ var MCPAgent = class {
         modelProvider: this.modelProvider,
         modelName: this.modelName,
         serverCount,
-        serverIdentifiers: this.connectors.map((connector) => connector.publicIdentifier),
+        serverIdentifiers: this.connectors.map(
+          (connector) => connector.publicIdentifier
+        ),
         totalToolsAvailable: toolsAvailable.length,
         toolsAvailableNames: toolsAvailable.map((t) => t.name),
         maxStepsConfigured: this.maxSteps,
@@ -2632,7 +2827,10 @@ var MCPAgent = class {
           logger.info(`\u26A0\uFE0F Skipped message of type: ${msg.constructor.name}`);
         }
       }
-      const inputs = [...langchainHistory, new import_langchain2.HumanMessage(query)];
+      const inputs = [
+        ...langchainHistory,
+        new import_langchain2.HumanMessage(query)
+      ];
       logger.info("callbacks", this.callbacks);
       const eventStream = agentExecutor.streamEvents(
         { messages: inputs },
@@ -2645,7 +2843,9 @@ var MCPAgent = class {
           // Set trace name for LangChain/Langfuse
           runName: this.metadata.trace_name || "mcp-use-agent",
           // Pass sessionId for Langfuse if present in metadata
-          ...this.metadata.session_id && { sessionId: this.metadata.session_id }
+          ...this.metadata.session_id && {
+            sessionId: this.metadata.session_id
+          }
         }
       );
       for await (const event of eventStream) {
@@ -2664,7 +2864,9 @@ var MCPAgent = class {
             }
             const normalizedContent = this._normalizeOutput(chunk.content);
             finalResponse += normalizedContent;
-            logger.debug(`\u{1F4DD} Accumulated response length: ${finalResponse.length}`);
+            logger.debug(
+              `\u{1F4DD} Accumulated response length: ${finalResponse.length}`
+            );
           }
         }
         yield event;
@@ -2721,7 +2923,11 @@ var MCPAgent = class {
               data: { output: conversionResult }
             };
             if (this.memoryEnabled) {
-              this.addToHistory(new import_langchain2.AIMessage(`Structured result: ${JSON.stringify(conversionResult)}`));
+              this.addToHistory(
+                new import_langchain2.AIMessage(
+                  `Structured result: ${JSON.stringify(conversionResult)}`
+                )
+              );
             }
             logger.info("\u2705 Structured output successful");
           }
@@ -2740,7 +2946,9 @@ var MCPAgent = class {
     } catch (e) {
       logger.error(`\u274C Error during streamEvents: ${e}`);
       if (initializedHere && manageConnector) {
-        logger.info("\u{1F9F9} Cleaning up resources after initialization error in streamEvents");
+        logger.info(
+          "\u{1F9F9} Cleaning up resources after initialization error in streamEvents"
+        );
         await this.close();
       }
       throw e;
@@ -2760,7 +2968,9 @@ var MCPAgent = class {
         modelProvider: this.modelProvider,
         modelName: this.modelName,
         serverCount,
-        serverIdentifiers: this.connectors.map((connector) => connector.publicIdentifier),
+        serverIdentifiers: this.connectors.map(
+          (connector) => connector.publicIdentifier
+        ),
         totalToolsAvailable: this._tools.length,
         toolsAvailableNames: this._tools.map((t) => t.name),
         maxStepsConfigured: this.maxSteps,
@@ -2788,11 +2998,15 @@ var MCPAgent = class {
    * @param outputSchema - The Zod schema to validate against
    */
   async _attemptStructuredOutput(rawResult, llm, outputSchema) {
-    logger.info(`\u{1F504} Attempting structured output with schema: ${JSON.stringify(outputSchema, null, 2)}`);
+    logger.info(
+      `\u{1F504} Attempting structured output with schema: ${JSON.stringify(outputSchema, null, 2)}`
+    );
     logger.info(`\u{1F504} Raw result: ${JSON.stringify(rawResult, null, 2)}`);
     let structuredLlm = null;
     let schemaDescription = "";
-    logger.debug(`\u{1F504} Structured output requested, schema: ${JSON.stringify((0, import_zod_to_json_schema2.zodToJsonSchema)(outputSchema), null, 2)}`);
+    logger.debug(
+      `\u{1F504} Structured output requested, schema: ${JSON.stringify((0, import_zod_to_json_schema2.zodToJsonSchema)(outputSchema), null, 2)}`
+    );
     if (llm && "withStructuredOutput" in llm && typeof llm.withStructuredOutput === "function") {
       structuredLlm = llm.withStructuredOutput(outputSchema);
     } else if (llm) {
@@ -2844,11 +3058,17 @@ var MCPAgent = class {
         `;
       }
       try {
-        logger.info(`\u{1F504} Structured output attempt ${attempt} - using streaming approach`);
+        logger.info(
+          `\u{1F504} Structured output attempt ${attempt} - using streaming approach`
+        );
         const contentPreview = textContent.length > 300 ? `${textContent.slice(0, 300)}...` : textContent;
-        logger.info(`\u{1F504} Content being formatted (${textContent.length} chars): ${contentPreview}`);
-        logger.info(`\u{1F504} Full format prompt (${formatPrompt.length} chars):
-${formatPrompt}`);
+        logger.info(
+          `\u{1F504} Content being formatted (${textContent.length} chars): ${contentPreview}`
+        );
+        logger.info(
+          `\u{1F504} Full format prompt (${formatPrompt.length} chars):
+${formatPrompt}`
+        );
         const stream = await structuredLlm.stream(formatPrompt);
         let structuredResult = null;
         let chunkCount = 0;
@@ -2874,19 +3094,30 @@ ${formatPrompt}`);
             logger.info(`\u{1F504} Structured output streaming: ${chunkCount} chunks`);
           }
         }
-        logger.info(`\u{1F504} Structured result attempt ${attempt}: ${JSON.stringify(structuredResult, null, 2)}`);
+        logger.info(
+          `\u{1F504} Structured result attempt ${attempt}: ${JSON.stringify(structuredResult, null, 2)}`
+        );
         if (!structuredResult) {
           throw new Error("No structured result received from stream");
         }
-        const validatedResult = this._validateStructuredResult(structuredResult, outputSchema);
+        const validatedResult = this._validateStructuredResult(
+          structuredResult,
+          outputSchema
+        );
         logger.info(`\u2705 Structured output successful on attempt ${attempt}`);
         return validatedResult;
       } catch (e) {
         lastError = e instanceof Error ? e.message : String(e);
-        logger.warn(`\u26A0\uFE0F Structured output attempt ${attempt} failed: ${lastError}`);
+        logger.warn(
+          `\u26A0\uFE0F Structured output attempt ${attempt} failed: ${lastError}`
+        );
         if (attempt === maxRetries) {
-          logger.error(`\u274C All ${maxRetries} structured output attempts failed`);
-          throw new Error(`Failed to generate valid structured output after ${maxRetries} attempts. Last error: ${lastError}`);
+          logger.error(
+            `\u274C All ${maxRetries} structured output attempts failed`
+          );
+          throw new Error(
+            `Failed to generate valid structured output after ${maxRetries} attempts. Last error: ${lastError}`
+          );
         }
         continue;
       }
@@ -2901,14 +3132,18 @@ ${formatPrompt}`);
       const validatedResult = outputSchema.parse(structuredResult);
       const schemaType = outputSchema;
       if (schemaType._def && schemaType._def.shape) {
-        for (const [fieldName, fieldSchema] of Object.entries(schemaType._def.shape)) {
+        for (const [fieldName, fieldSchema] of Object.entries(
+          schemaType._def.shape
+        )) {
           const field = fieldSchema;
           const isOptional = field.isOptional?.() ?? field._def?.typeName === "ZodOptional";
           const isNullable = field.isNullable?.() ?? field._def?.typeName === "ZodNullable";
           if (!isOptional && !isNullable) {
             const value = validatedResult[fieldName];
             if (value === null || value === void 0 || typeof value === "string" && !value.trim() || Array.isArray(value) && value.length === 0) {
-              throw new Error(`Required field '${fieldName}' is missing or empty`);
+              throw new Error(
+                `Required field '${fieldName}' is missing or empty`
+              );
             }
           }
         }
@@ -3059,7 +3294,9 @@ var BaseMCPClient = class {
   async closeSession(serverName) {
     const session = this.sessions[serverName];
     if (!session) {
-      logger.warn(`No session exists for server ${serverName}, nothing to close`);
+      logger.warn(
+        `No session exists for server ${serverName}, nothing to close`
+      );
       return;
     }
     try {
@@ -3086,7 +3323,9 @@ var BaseMCPClient = class {
       }
     }
     if (errors.length) {
-      logger.error(`Encountered ${errors.length} errors while closing sessions`);
+      logger.error(
+        `Encountered ${errors.length} errors while closing sessions`
+      );
     } else {
       logger.debug("All sessions closed successfully");
     }
@@ -3192,7 +3431,9 @@ var ConnectionManager = class {
         try {
           await this.closeConnection(this._connection);
         } catch (closeErr) {
-          logger.warn(`Error closing connection in ${this.constructor.name}: ${closeErr}`);
+          logger.warn(
+            `Error closing connection in ${this.constructor.name}: ${closeErr}`
+          );
         }
         this._connection = null;
       }
@@ -3325,6 +3566,7 @@ var BaseConnector = class {
   client = null;
   connectionManager = null;
   toolsCache = null;
+  capabilitiesCache = null;
   connected = false;
   opts;
   constructor(opts = {}) {
@@ -3358,9 +3600,14 @@ var BaseConnector = class {
     }
     logger.debug("Caching server capabilities & tools");
     const capabilities = this.client.getServerCapabilities();
-    const listToolsRes = await this.client.listTools(void 0, defaultRequestOptions);
+    this.capabilitiesCache = capabilities;
+    const listToolsRes = await this.client.listTools(
+      void 0,
+      defaultRequestOptions
+    );
     this.toolsCache = listToolsRes.tools ?? [];
     logger.debug(`Fetched ${this.toolsCache.length} tools from server`);
+    logger.debug("Server capabilities:", capabilities);
     return capabilities;
   }
   /** Lazily expose the cached tools list. */
@@ -3376,13 +3623,17 @@ var BaseConnector = class {
       throw new Error("MCP client is not connected");
     }
     logger.debug(`Calling tool '${name}' with args`, args);
-    const res = await this.client.callTool({ name, arguments: args }, void 0, options);
+    const res = await this.client.callTool(
+      { name, arguments: args },
+      void 0,
+      options
+    );
     logger.debug(`Tool '${name}' returned`, res);
     return res;
   }
   /**
    * List resources from the server with optional pagination
-   * 
+   *
    * @param cursor - Optional cursor for pagination
    * @param options - Request options
    * @returns Resource list with optional nextCursor for pagination
@@ -3396,7 +3647,7 @@ var BaseConnector = class {
   }
   /**
    * List all resources from the server, automatically handling pagination
-   * 
+   *
    * @param options - Request options
    * @returns Complete list of all resources
    */
@@ -3404,19 +3655,31 @@ var BaseConnector = class {
     if (!this.client) {
       throw new Error("MCP client is not connected");
     }
-    logger.debug("Listing all resources (with auto-pagination)");
-    const allResources = [];
-    let cursor = void 0;
-    do {
-      const result = await this.client.listResources({ cursor }, options);
-      allResources.push(...result.resources || []);
-      cursor = result.nextCursor;
-    } while (cursor);
-    return { resources: allResources };
+    if (!this.capabilitiesCache?.resources) {
+      logger.debug("Server does not advertise resources capability, skipping");
+      return { resources: [] };
+    }
+    try {
+      logger.debug("Listing all resources (with auto-pagination)");
+      const allResources = [];
+      let cursor = void 0;
+      do {
+        const result = await this.client.listResources({ cursor }, options);
+        allResources.push(...result.resources || []);
+        cursor = result.nextCursor;
+      } while (cursor);
+      return { resources: allResources };
+    } catch (err) {
+      if (err.code === -32601) {
+        logger.debug("Server advertised resources but method not found");
+        return { resources: [] };
+      }
+      throw err;
+    }
   }
   /**
    * List resource templates from the server
-   * 
+   *
    * @param options - Request options
    * @returns List of available resource templates
    */
@@ -3434,11 +3697,11 @@ var BaseConnector = class {
     }
     logger.debug(`Reading resource ${uri}`);
     const res = await this.client.readResource({ uri }, options);
-    return { content: res.content, mimeType: res.mimeType };
+    return res;
   }
   /**
    * Subscribe to resource updates
-   * 
+   *
    * @param uri - URI of the resource to subscribe to
    * @param options - Request options
    */
@@ -3451,7 +3714,7 @@ var BaseConnector = class {
   }
   /**
    * Unsubscribe from resource updates
-   * 
+   *
    * @param uri - URI of the resource to unsubscribe from
    * @param options - Request options
    */
@@ -3466,8 +3729,20 @@ var BaseConnector = class {
     if (!this.client) {
       throw new Error("MCP client is not connected");
     }
-    logger.debug("Listing prompt");
-    return await this.client.listPrompts();
+    if (!this.capabilitiesCache?.prompts) {
+      logger.debug("Server does not advertise prompts capability, skipping");
+      return { prompts: [] };
+    }
+    try {
+      logger.debug("Listing prompts");
+      return await this.client.listPrompts();
+    } catch (err) {
+      if (err.code === -32601) {
+        logger.debug("Server advertised prompts but method not found");
+        return { prompts: [] };
+      }
+      throw err;
+    }
   }
   async getPrompt(name, args) {
     if (!this.client) {
@@ -3482,7 +3757,11 @@ var BaseConnector = class {
       throw new Error("MCP client is not connected");
     }
     logger.debug(`Sending raw request '${method}' with params`, params);
-    return await this.client.request({ method, params: params ?? {} }, void 0, options);
+    return await this.client.request(
+      { method, params: params ?? {} },
+      void 0,
+      options
+    );
   }
   /**
    * Helper to tear down the client & connection manager safely.
@@ -3541,7 +3820,10 @@ var HttpConnector = class extends BaseConnector {
     }
     this.timeout = opts.timeout ?? 3e4;
     this.sseReadTimeout = opts.sseReadTimeout ?? 3e5;
-    this.clientInfo = opts.clientInfo ?? { name: "http-connector", version: "1.0.0" };
+    this.clientInfo = opts.clientInfo ?? {
+      name: "http-connector",
+      version: "1.0.0"
+    };
     this.preferSse = opts.preferSse ?? false;
   }
   /** Establish connection to the MCP implementation via HTTP (streamable or SSE). */
@@ -3563,7 +3845,9 @@ var HttpConnector = class extends BaseConnector {
       logger.info("\u2705 Successfully connected via streamable HTTP");
     } catch (err) {
       let fallbackReason = "Unknown error";
+      let is401Error = false;
       if (err instanceof import_streamableHttp2.StreamableHTTPError) {
+        is401Error = err.code === 401;
         if (err.code === 400 && err.message.includes("Missing session ID")) {
           fallbackReason = "Server requires session ID (FastMCP compatibility) - using SSE transport";
           logger.warn(`\u26A0\uFE0F  ${fallbackReason}`);
@@ -3577,6 +3861,7 @@ var HttpConnector = class extends BaseConnector {
       } else if (err instanceof Error) {
         const errorStr = err.toString();
         const errorMsg = err.message || "";
+        is401Error = errorStr.includes("401") || errorMsg.includes("Unauthorized");
         if (errorStr.includes("Missing session ID") || errorStr.includes("Bad Request: Missing session ID") || errorMsg.includes("FastMCP session ID error")) {
           fallbackReason = "Server requires session ID (FastMCP compatibility) - using SSE transport";
           logger.warn(`\u26A0\uFE0F  ${fallbackReason}`);
@@ -3588,6 +3873,13 @@ var HttpConnector = class extends BaseConnector {
           logger.debug(fallbackReason);
         }
       }
+      if (is401Error) {
+        logger.info("Authentication required - skipping SSE fallback");
+        await this.cleanupResources();
+        const authError = new Error("Authentication required");
+        authError.code = 401;
+        throw authError;
+      }
       logger.info("\u{1F504} Falling back to SSE transport...");
       try {
         await this.connectWithSse(baseUrl);
@@ -3596,27 +3888,34 @@ var HttpConnector = class extends BaseConnector {
         logger.error(`  Streamable HTTP: ${fallbackReason}`);
         logger.error(`  SSE: ${sseErr}`);
         await this.cleanupResources();
-        throw new Error("Could not connect to server with any available transport");
+        const sseIs401 = sseErr?.message?.includes("401") || sseErr?.message?.includes("Unauthorized");
+        if (sseIs401) {
+          const authError = new Error("Authentication required");
+          authError.code = 401;
+          throw authError;
+        }
+        throw new Error(
+          "Could not connect to server with any available transport"
+        );
       }
     }
   }
   async connectWithStreamableHttp(baseUrl) {
     try {
-      this.connectionManager = new StreamableHttpConnectionManager(
-        baseUrl,
-        {
-          requestInit: {
-            headers: this.headers
-          },
-          // Pass through timeout and other options
-          reconnectionOptions: {
-            maxReconnectionDelay: 3e4,
-            initialReconnectionDelay: 1e3,
-            reconnectionDelayGrowFactor: 1.5,
-            maxRetries: 2
-          }
+      this.connectionManager = new StreamableHttpConnectionManager(baseUrl, {
+        authProvider: this.opts.authProvider,
+        // ← Pass OAuth provider to SDK
+        requestInit: {
+          headers: this.headers
+        },
+        // Pass through timeout and other options
+        reconnectionOptions: {
+          maxReconnectionDelay: 3e4,
+          initialReconnectionDelay: 1e3,
+          reconnectionDelayGrowFactor: 1.5,
+          maxRetries: 2
         }
-      );
+      });
       const transport = await this.connectionManager.start();
       this.client = new import_client.Client(this.clientInfo, this.opts.clientOptions);
       try {
@@ -3625,7 +3924,9 @@ var HttpConnector = class extends BaseConnector {
         if (connectErr instanceof Error) {
           const errMsg = connectErr.message || connectErr.toString();
           if (errMsg.includes("Missing session ID") || errMsg.includes("Bad Request: Missing session ID")) {
-            const wrappedError = new Error(`FastMCP session ID error: ${errMsg}`);
+            const wrappedError = new Error(
+              `FastMCP session ID error: ${errMsg}`
+            );
             wrappedError.cause = connectErr;
             throw wrappedError;
           }
@@ -3634,7 +3935,9 @@ var HttpConnector = class extends BaseConnector {
       }
       this.connected = true;
       this.transportType = "streamable-http";
-      logger.debug(`Successfully connected to MCP implementation via streamable HTTP: ${baseUrl}`);
+      logger.debug(
+        `Successfully connected to MCP implementation via streamable HTTP: ${baseUrl}`
+      );
     } catch (err) {
       await this.cleanupResources();
       throw err;
@@ -3642,20 +3945,19 @@ var HttpConnector = class extends BaseConnector {
   }
   async connectWithSse(baseUrl) {
     try {
-      this.connectionManager = new SseConnectionManager(
-        baseUrl,
-        {
-          requestInit: {
-            headers: this.headers
-          }
+      this.connectionManager = new SseConnectionManager(baseUrl, {
+        requestInit: {
+          headers: this.headers
         }
-      );
+      });
       const transport = await this.connectionManager.start();
       this.client = new import_client.Client(this.clientInfo, this.opts.clientOptions);
       await this.client.connect(transport);
       this.connected = true;
       this.transportType = "sse";
-      logger.debug(`Successfully connected to MCP implementation via HTTP/SSE: ${baseUrl}`);
+      logger.debug(
+        `Successfully connected to MCP implementation via HTTP/SSE: ${baseUrl}`
+      );
     } catch (err) {
       await this.cleanupResources();
       throw err;
@@ -3710,7 +4012,9 @@ var StdioConnectionManager = class extends ConnectionManager {
   async establishConnection() {
     this._transport = new import_stdio.StdioClientTransport(this.serverParams);
     if (this._transport.stderr && typeof this._transport.stderr.pipe === "function") {
-      this._transport.stderr.pipe(this.errlog);
+      this._transport.stderr.pipe(
+        this.errlog
+      );
     }
     logger.debug(`${this.constructor.name} connected successfully`);
     return this._transport;
@@ -3754,7 +4058,10 @@ var StdioConnector = class extends BaseConnector {
     this.args = args;
     this.env = env;
     this.errlog = errlog;
-    this.clientInfo = rest.clientInfo ?? { name: "stdio-connector", version: "1.0.0" };
+    this.clientInfo = rest.clientInfo ?? {
+      name: "stdio-connector",
+      version: "1.0.0"
+    };
   }
   /** Establish connection to the MCP implementation. */
   async connect() {
@@ -3779,12 +4086,17 @@ var StdioConnector = class extends BaseConnector {
         args: this.args,
         env: mergedEnv
       };
-      this.connectionManager = new StdioConnectionManager(serverParams, this.errlog);
+      this.connectionManager = new StdioConnectionManager(
+        serverParams,
+        this.errlog
+      );
       const transport = await this.connectionManager.start();
       this.client = new import_client2.Client(this.clientInfo, this.opts.clientOptions);
       await this.client.connect(transport);
       this.connected = true;
-      logger.debug(`Successfully connected to MCP implementation: ${this.command}`);
+      logger.debug(
+        `Successfully connected to MCP implementation: ${this.command}`
+      );
     } catch (err) {
       logger.error(`Failed to connect to MCP implementation: ${err}`);
       await this.cleanupResources();
@@ -3793,7 +4105,7 @@ var StdioConnector = class extends BaseConnector {
   }
   get publicIdentifier() {
     return {
-      "type": "stdio",
+      type: "stdio",
       "command&args": `${this.command} ${this.args.join(" ")}`
     };
   }
@@ -3826,7 +4138,9 @@ var WebSocketConnectionManager = class extends ConnectionManager {
   async establishConnection() {
     logger.debug(`Connecting to WebSocket: ${this.url}`);
     return new Promise((resolve, reject) => {
-      const ws = new import_ws.default(this.url, { headers: this.headers });
+      const ws = new import_ws.default(this.url, {
+        headers: this.headers
+      });
       this._ws = ws;
       const onOpen = /* @__PURE__ */ __name(() => {
         cleanup();
@@ -3886,8 +4200,7 @@ var WebSocketConnector = class extends BaseConnector {
     super();
     this.url = url;
     this.headers = { ...opts.headers ?? {} };
-    if (opts.authToken)
-      this.headers.Authorization = `Bearer ${opts.authToken}`;
+    if (opts.authToken) this.headers.Authorization = `Bearer ${opts.authToken}`;
   }
   async connect() {
     if (this.connected) {
@@ -3896,7 +4209,10 @@ var WebSocketConnector = class extends BaseConnector {
     }
     logger.debug(`Connecting via WebSocket: ${this.url}`);
     try {
-      this.connectionManager = new WebSocketConnectionManager(this.url, this.headers);
+      this.connectionManager = new WebSocketConnectionManager(
+        this.url,
+        this.headers
+      );
       this.ws = await this.connectionManager.start();
       this.receiverTask = this.receiveLoop();
       this.connected = true;
@@ -3917,8 +4233,7 @@ var WebSocketConnector = class extends BaseConnector {
     this.connected = false;
   }
   sendRequest(method, params = null) {
-    if (!this.ws)
-      throw new Error("WebSocket is not connected");
+    if (!this.ws) throw new Error("WebSocket is not connected");
     const id = (0, import_uuid2.v4)();
     const payload = JSON.stringify({ id, method, params: params ?? {} });
     return new Promise((resolve, reject) => {
@@ -3932,8 +4247,7 @@ var WebSocketConnector = class extends BaseConnector {
     });
   }
   async receiveLoop() {
-    if (!this.ws)
-      return;
+    if (!this.ws) return;
     const socket = this.ws;
     const onMessage = /* @__PURE__ */ __name((msg) => {
       let data;
@@ -3947,10 +4261,8 @@ var WebSocketConnector = class extends BaseConnector {
       if (id && this.pending.has(id)) {
         const { resolve, reject } = this.pending.get(id);
         this.pending.delete(id);
-        if ("result" in data)
-          resolve(data.result);
-        else if ("error" in data)
-          reject(data.error);
+        if ("result" in data) resolve(data.result);
+        else if ("error" in data) reject(data.error);
       } else {
         logger.debug("Received unsolicited message", data);
       }
@@ -4002,20 +4314,18 @@ var WebSocketConnector = class extends BaseConnector {
   }
   async readResource(uri) {
     const res = await this.sendRequest("resources/read", { uri });
-    return { content: res.content, mimeType: res.mimeType };
+    return res;
   }
   async request(method, params = null) {
     return await this.sendRequest(method, params);
   }
   get tools() {
-    if (!this.toolsCache)
-      throw new Error("MCP client is not initialized");
+    if (!this.toolsCache) throw new Error("MCP client is not initialized");
     return this.toolsCache;
   }
   async cleanupResources() {
-    if (this.receiverTask)
-      await this.receiverTask.catch(() => {
-      });
+    if (this.receiverTask) await this.receiverTask.catch(() => {
+    });
     this.receiverTask = null;
     this.rejectAll(new Error("WebSocket disconnected"));
     if (this.connectionManager) {
@@ -4200,7 +4510,7 @@ var OAuthHelper = class {
       const response = await fetch(serverUrl, {
         method: "GET",
         headers: {
-          "Accept": "text/event-stream",
+          Accept: "text/event-stream",
           "Cache-Control": "no-cache"
         },
         redirect: "manual",
@@ -4216,16 +4526,29 @@ var OAuthHelper = class {
         console.log("\u{1F510} [OAuthHelper] Authentication required for:", serverUrl);
         return true;
       }
-      console.log("\u2705 [OAuthHelper] No authentication required for:", serverUrl);
+      console.log(
+        "\u2705 [OAuthHelper] No authentication required for:",
+        serverUrl
+      );
       return false;
     } catch (error) {
-      console.warn("\u26A0\uFE0F [OAuthHelper] Could not check auth requirement for:", serverUrl, error);
+      console.warn(
+        "\u26A0\uFE0F [OAuthHelper] Could not check auth requirement for:",
+        serverUrl,
+        error
+      );
       if (error.name === "TypeError" && (error.message?.includes("CORS") || error.message?.includes("Failed to fetch"))) {
-        console.log("\u{1F50D} [OAuthHelper] CORS blocked direct check, using heuristics for:", serverUrl);
+        console.log(
+          "\u{1F50D} [OAuthHelper] CORS blocked direct check, using heuristics for:",
+          serverUrl
+        );
         return this.checkAuthByHeuristics(serverUrl);
       }
       if (error.name === "AbortError") {
-        console.log("\u23F0 [OAuthHelper] Request timeout, assuming no auth required for:", serverUrl);
+        console.log(
+          "\u23F0 [OAuthHelper] Request timeout, assuming no auth required for:",
+          serverUrl
+        );
         return false;
       }
       return this.checkAuthByHeuristics(serverUrl);
@@ -4235,7 +4558,10 @@ var OAuthHelper = class {
    * Fallback heuristics for determining auth requirements when direct checking fails
    */
   checkAuthByHeuristics(serverUrl) {
-    console.log("\u{1F50D} [OAuthHelper] Using heuristics to determine auth for:", serverUrl);
+    console.log(
+      "\u{1F50D} [OAuthHelper] Using heuristics to determine auth for:",
+      serverUrl
+    );
     const authRequiredPatterns = [
       /api\.githubcopilot\.com/i,
       // GitHub Copilot
@@ -4268,17 +4594,26 @@ var OAuthHelper = class {
     ];
     for (const pattern of noAuthPatterns) {
       if (pattern.test(serverUrl)) {
-        console.log("\u2705 [OAuthHelper] Heuristic: No auth required (matches no-auth pattern):", serverUrl);
+        console.log(
+          "\u2705 [OAuthHelper] Heuristic: No auth required (matches no-auth pattern):",
+          serverUrl
+        );
         return false;
       }
     }
     for (const pattern of authRequiredPatterns) {
       if (pattern.test(serverUrl)) {
-        console.log("\u{1F510} [OAuthHelper] Heuristic: Auth required (matches auth pattern):", serverUrl);
+        console.log(
+          "\u{1F510} [OAuthHelper] Heuristic: Auth required (matches auth pattern):",
+          serverUrl
+        );
         return true;
       }
     }
-    console.log("\u2753 [OAuthHelper] Heuristic: Unknown pattern, assuming no auth required:", serverUrl);
+    console.log(
+      "\u2753 [OAuthHelper] Heuristic: Unknown pattern, assuming no auth required:",
+      serverUrl
+    );
     return false;
   }
   /**
@@ -4287,7 +4622,10 @@ var OAuthHelper = class {
   async discoverOAuthConfig(serverUrl) {
     try {
       const discoveryUrl = `${serverUrl}/.well-known/oauth-authorization-server`;
-      console.log("\u{1F50D} [OAuthHelper] Attempting OAuth discovery at:", discoveryUrl);
+      console.log(
+        "\u{1F50D} [OAuthHelper] Attempting OAuth discovery at:",
+        discoveryUrl
+      );
       const response = await fetch(discoveryUrl);
       if (!response.ok) {
         console.error("\u274C [OAuthHelper] OAuth discovery failed:", {
@@ -4295,7 +4633,9 @@ var OAuthHelper = class {
           statusText: response.statusText,
           url: discoveryUrl
         });
-        throw new Error(`OAuth discovery failed: ${response.status} ${response.statusText}`);
+        throw new Error(
+          `OAuth discovery failed: ${response.status} ${response.statusText}`
+        );
       }
       this.discovery = await response.json();
       console.log("\u2705 [OAuthHelper] OAuth discovery successful:", {
@@ -4314,7 +4654,9 @@ var OAuthHelper = class {
    */
   async registerClient(_serverUrl) {
     if (!this.discovery) {
-      throw new Error("OAuth discovery not performed. Call discoverOAuthConfig first.");
+      throw new Error(
+        "OAuth discovery not performed. Call discoverOAuthConfig first."
+      );
     }
     if (!this.discovery.registration_endpoint) {
       throw new Error("Server does not support dynamic client registration");
@@ -4343,7 +4685,9 @@ var OAuthHelper = class {
       });
       if (!response.ok) {
         const errorText = await response.text();
-        throw new Error(`Client registration failed: ${response.status} ${response.statusText} - ${errorText}`);
+        throw new Error(
+          `Client registration failed: ${response.status} ${response.statusText} - ${errorText}`
+        );
       }
       this.clientRegistration = await response.json();
       console.log("\u2705 [OAuthHelper] Client registered successfully:", {
@@ -4361,7 +4705,9 @@ var OAuthHelper = class {
    */
   generateAuthUrl(serverUrl, additionalParams) {
     if (!this.discovery) {
-      throw new Error("OAuth discovery not performed. Call discoverOAuthConfig first.");
+      throw new Error(
+        "OAuth discovery not performed. Call discoverOAuthConfig first."
+      );
     }
     if (!this.clientRegistration) {
       throw new Error("Client not registered. Call registerClient first.");
@@ -4381,7 +4727,9 @@ var OAuthHelper = class {
    */
   async exchangeCodeForToken(serverUrl, code, codeVerifier) {
     if (!this.discovery) {
-      throw new Error("OAuth discovery not performed. Call discoverOAuthConfig first.");
+      throw new Error(
+        "OAuth discovery not performed. Call discoverOAuthConfig first."
+      );
     }
     if (!this.clientRegistration) {
       throw new Error("Client not registered. Call registerClient first.");
@@ -4404,7 +4752,9 @@ var OAuthHelper = class {
     });
     if (!response.ok) {
       const error = await response.text();
-      throw new Error(`Token exchange failed: ${response.status} ${response.statusText} - ${error}`);
+      throw new Error(
+        `Token exchange failed: ${response.status} ${response.statusText} - ${error}`
+      );
     }
     return await response.json();
   }
@@ -4442,7 +4792,9 @@ var OAuthHelper = class {
         "width=500,height=600,scrollbars=yes,resizable=yes,status=yes,location=yes"
       );
       if (!authWindow) {
-        throw new Error("Failed to open authentication window. Please allow popups for this site and try again.");
+        throw new Error(
+          "Failed to open authentication window. Please allow popups for this site and try again."
+        );
       }
       console.log("\u2705 [OAuthHelper] OAuth popup opened successfully");
     } catch (error) {
@@ -4577,7 +4929,10 @@ var BrowserOAuthClientProvider = class {
     try {
       return JSON.parse(data);
     } catch (e) {
-      console.warn(`[${this.storageKeyPrefix}] Failed to parse client information:`, e);
+      console.warn(
+        `[${this.storageKeyPrefix}] Failed to parse client information:`,
+        e
+      );
       localStorage.removeItem(key);
       return void 0;
     }
@@ -4659,7 +5014,11 @@ var BrowserOAuthClientProvider = class {
     const sanitizedAuthUrl = await this.prepareAuthorizationUrl(authorizationUrl);
     const popupFeatures = "width=600,height=700,resizable=yes,scrollbars=yes,status=yes";
     try {
-      const popup = window.open(sanitizedAuthUrl, `mcp_auth_${this.serverUrlHash}`, popupFeatures);
+      const popup = window.open(
+        sanitizedAuthUrl,
+        `mcp_auth_${this.serverUrlHash}`,
+        popupFeatures
+      );
       if (this.onPopupWindow) {
         this.onPopupWindow(sanitizedAuthUrl, popupFeatures, popup);
       }
@@ -4669,10 +5028,15 @@ var BrowserOAuthClientProvider = class {
         );
       } else {
         popup.focus();
-        console.info(`[${this.storageKeyPrefix}] Redirecting to authorization URL in popup.`);
+        console.info(
+          `[${this.storageKeyPrefix}] Redirecting to authorization URL in popup.`
+        );
       }
     } catch (e) {
-      console.error(`[${this.storageKeyPrefix}] Error opening popup window:`, e);
+      console.error(
+        `[${this.storageKeyPrefix}] Error opening popup window:`,
+        e
+      );
     }
   }
   // --- Helper Methods ---
@@ -4703,7 +5067,10 @@ var BrowserOAuthClientProvider = class {
             }
           }
         } catch (e) {
-          console.warn(`[${this.storageKeyPrefix}] Error parsing state key ${key} during clearStorage:`, e);
+          console.warn(
+            `[${this.storageKeyPrefix}] Error parsing state key ${key} during clearStorage:`,
+            e
+          );
         }
       }
     }
@@ -4737,23 +5104,36 @@ async function onMcpAuthorization() {
   const error = queryParams.get("error");
   const errorDescription = queryParams.get("error_description");
   const logPrefix = "[mcp-callback]";
-  console.log(`${logPrefix} Handling callback...`, { code, state, error, errorDescription });
+  console.log(`${logPrefix} Handling callback...`, {
+    code,
+    state,
+    error,
+    errorDescription
+  });
   let provider = null;
   let storedStateData = null;
   const stateKey = state ? `mcp:auth:state_${state}` : null;
   try {
     if (error) {
-      throw new Error(`OAuth error: ${error} - ${errorDescription || "No description provided."}`);
+      throw new Error(
+        `OAuth error: ${error} - ${errorDescription || "No description provided."}`
+      );
     }
     if (!code) {
-      throw new Error("Authorization code not found in callback query parameters.");
+      throw new Error(
+        "Authorization code not found in callback query parameters."
+      );
     }
     if (!state || !stateKey) {
-      throw new Error("State parameter not found or invalid in callback query parameters.");
+      throw new Error(
+        "State parameter not found or invalid in callback query parameters."
+      );
     }
     const storedStateJSON = localStorage.getItem(stateKey);
     if (!storedStateJSON) {
-      throw new Error(`Invalid or expired state parameter "${state}". No matching state found in storage.`);
+      throw new Error(
+        `Invalid or expired state parameter "${state}". No matching state found in storage.`
+      );
     }
     try {
       storedStateData = JSON.parse(storedStateJSON);
@@ -4762,38 +5142,59 @@ async function onMcpAuthorization() {
     }
     if (!storedStateData.expiry || storedStateData.expiry < Date.now()) {
       localStorage.removeItem(stateKey);
-      throw new Error("OAuth state has expired. Please try initiating authentication again.");
+      throw new Error(
+        "OAuth state has expired. Please try initiating authentication again."
+      );
     }
     if (!storedStateData.providerOptions) {
       throw new Error("Stored state is missing required provider options.");
     }
     const { serverUrl, ...providerOptions } = storedStateData.providerOptions;
-    console.log(`${logPrefix} Re-instantiating provider for server: ${serverUrl}`);
+    console.log(
+      `${logPrefix} Re-instantiating provider for server: ${serverUrl}`
+    );
     provider = new BrowserOAuthClientProvider(serverUrl, providerOptions);
     console.log(`${logPrefix} Calling SDK auth() to exchange code...`);
     const baseUrl = new URL(serverUrl).origin;
-    const authResult = await (0, import_auth.auth)(provider, { serverUrl: baseUrl, authorizationCode: code });
+    const authResult = await (0, import_auth.auth)(provider, {
+      serverUrl: baseUrl,
+      authorizationCode: code
+    });
     if (authResult === "AUTHORIZED") {
-      console.log(`${logPrefix} Authorization successful via SDK auth(). Notifying opener...`);
+      console.log(
+        `${logPrefix} Authorization successful via SDK auth(). Notifying opener...`
+      );
       if (window.opener && !window.opener.closed) {
-        window.opener.postMessage({ type: "mcp_auth_callback", success: true }, window.location.origin);
+        window.opener.postMessage(
+          { type: "mcp_auth_callback", success: true },
+          window.location.origin
+        );
         window.close();
       } else {
-        console.warn(`${logPrefix} No opener window detected. Redirecting to root.`);
+        console.warn(
+          `${logPrefix} No opener window detected. Redirecting to root.`
+        );
         const pathParts = window.location.pathname.split("/").filter(Boolean);
         const basePath = pathParts.length > 0 && pathParts[pathParts.length - 1] === "callback" ? "/" + pathParts.slice(0, -2).join("/") : "/";
         window.location.href = basePath || "/";
       }
       localStorage.removeItem(stateKey);
     } else {
-      console.warn(`${logPrefix} SDK auth() returned unexpected status: ${authResult}`);
-      throw new Error(`Unexpected result from authentication library: ${authResult}`);
+      console.warn(
+        `${logPrefix} SDK auth() returned unexpected status: ${authResult}`
+      );
+      throw new Error(
+        `Unexpected result from authentication library: ${authResult}`
+      );
     }
   } catch (err) {
     console.error(`${logPrefix} Error during OAuth callback handling:`, err);
     const errorMessage = err instanceof Error ? err.message : String(err);
     if (window.opener && !window.opener.closed) {
-      window.opener.postMessage({ type: "mcp_auth_callback", success: false, error: errorMessage }, window.location.origin);
+      window.opener.postMessage(
+        { type: "mcp_auth_callback", success: false, error: errorMessage },
+        window.location.origin
+      );
     }
     try {
       document.body.innerHTML = `
@@ -4807,7 +5208,10 @@ async function onMcpAuthorization() {
             </div>
         `;
     } catch (displayError) {
-      console.error(`${logPrefix} Could not display error in callback window:`, displayError);
+      console.error(
+        `${logPrefix} Could not display error in callback window:`,
+        displayError
+      );
     }
     if (stateKey) {
       localStorage.removeItem(stateKey);
@@ -4821,14 +5225,45 @@ async function onMcpAuthorization() {
 __name(onMcpAuthorization, "onMcpAuthorization");
 
 // src/react/useMcp.ts
-var import_types = require("@modelcontextprotocol/sdk/types.js");
 var import_react = require("react");
-var import_auth2 = require("@modelcontextprotocol/sdk/client/auth.js");
-var import_client3 = require("@modelcontextprotocol/sdk/client/index.js");
-var import_sse3 = require("@modelcontextprotocol/sdk/client/sse.js");
-var import_streamableHttp3 = require("@modelcontextprotocol/sdk/client/streamableHttp.js");
 var import_strict_url_sanitise2 = require("strict-url-sanitise");
 
+// src/client/browser.ts
+var BrowserMCPClient = class _BrowserMCPClient extends BaseMCPClient {
+  static {
+    __name(this, "BrowserMCPClient");
+  }
+  constructor(config2) {
+    super(config2);
+  }
+  static fromDict(cfg) {
+    return new _BrowserMCPClient(cfg);
+  }
+  /**
+   * Create a connector from server configuration (Browser version)
+   * Supports HTTP and WebSocket connectors only
+   */
+  createConnectorFromConfig(serverConfig) {
+    const { url, transport, headers, authToken, authProvider } = serverConfig;
+    if (!url) {
+      throw new Error("Server URL is required");
+    }
+    const connectorOptions = {
+      headers,
+      authToken,
+      authProvider
+      // ← Pass OAuth provider to connector
+    };
+    if (transport === "websocket" || url.startsWith("ws://") || url.startsWith("wss://")) {
+      return new WebSocketConnector(url, connectorOptions);
+    } else if (transport === "http" || url.startsWith("http://") || url.startsWith("https://")) {
+      return new HttpConnector(url, connectorOptions);
+    } else {
+      return new HttpConnector(url, connectorOptions);
+    }
+  }
+};
+
 // src/utils/assert.ts
 function assert(condition, message) {
   if (!condition) {
@@ -4847,7 +5282,9 @@ function useMcp(options) {
     enabled = true,
     clientName,
     clientUri,
-    callbackUrl = typeof window !== "undefined" ? (0, import_strict_url_sanitise2.sanitizeUrl)(new URL("/oauth/callback", window.location.origin).toString()) : "/oauth/callback",
+    callbackUrl = typeof window !== "undefined" ? (0, import_strict_url_sanitise2.sanitizeUrl)(
+      new URL("/oauth/callback", window.location.origin).toString()
+    ) : "/oauth/callback",
     storageKeyPrefix = "mcp:auth",
     clientConfig = {},
     customHeaders = {},
@@ -4871,7 +5308,6 @@ function useMcp(options) {
   const [log, setLog] = (0, import_react.useState)([]);
   const [authUrl, setAuthUrl] = (0, import_react.useState)(void 0);
   const clientRef = (0, import_react.useRef)(null);
-  const transportRef = (0, import_react.useRef)(null);
   const authProviderRef = (0, import_react.useRef)(null);
   const connectingRef = (0, import_react.useRef)(false);
   const isMountedRef = (0, import_react.useRef)(true);
@@ -4889,7 +5325,10 @@ function useMcp(options) {
       const fullMessage = args.length > 0 ? `${message} ${args.map((arg) => JSON.stringify(arg)).join(" ")}` : message;
       console[level](`[useMcp] ${fullMessage}`);
       if (isMountedRef.current) {
-        setLog((prevLog) => [...prevLog.slice(-100), { level, message: fullMessage, timestamp: Date.now() }]);
+        setLog((prevLog) => [
+          ...prevLog.slice(-100),
+          { level, message: fullMessage, timestamp: Date.now() }
+        ]);
       }
     },
     []
@@ -4900,9 +5339,15 @@ function useMcp(options) {
       connectingRef.current = false;
       if (authTimeoutRef.current) clearTimeout(authTimeoutRef.current);
       authTimeoutRef.current = null;
-      const transport = transportRef.current;
+      if (clientRef.current) {
+        try {
+          const serverName = "inspector-server";
+          await clientRef.current.closeSession(serverName);
+        } catch (err) {
+          if (!quiet) addLog("warn", "Error closing session:", err);
+        }
+      }
       clientRef.current = null;
-      transportRef.current = null;
       if (isMountedRef.current && !quiet) {
         setState("discovering");
         setTools([]);
@@ -4912,14 +5357,6 @@ function useMcp(options) {
         setError(void 0);
         setAuthUrl(void 0);
       }
-      if (transport) {
-        try {
-          await transport.close();
-          if (!quiet) addLog("debug", "Transport closed");
-        } catch (err) {
-          if (!quiet) addLog("warn", "Error closing transport:", err);
-        }
-      }
     },
     [addLog]
   );
@@ -4932,7 +5369,11 @@ function useMcp(options) {
         const manualUrl = authProviderRef.current?.getLastAttemptedAuthUrl();
         if (manualUrl) {
           setAuthUrl(manualUrl);
-          addLog("info", "Manual authentication URL may be available.", manualUrl);
+          addLog(
+            "info",
+            "Manual authentication URL may be available.",
+            manualUrl
+          );
         }
       }
       connectingRef.current = false;
@@ -4941,7 +5382,10 @@ function useMcp(options) {
   );
   const connect = (0, import_react.useCallback)(async () => {
     if (!enabled || !url) {
-      addLog("debug", enabled ? "No server URL provided, skipping connection." : "Connection disabled via enabled flag.");
+      addLog(
+        "debug",
+        enabled ? "No server URL provided, skipping connection." : "Connection disabled via enabled flag."
+      );
       return;
     }
     if (connectingRef.current) {
@@ -4958,7 +5402,10 @@ function useMcp(options) {
     setAuthUrl(void 0);
     successfulTransportRef.current = null;
     setState("discovering");
-    addLog("info", `Connecting attempt #${connectAttemptRef.current} to ${url}...`);
+    addLog(
+      "info",
+      `Connecting attempt #${connectAttemptRef.current} to ${url}...`
+    );
     if (!authProviderRef.current) {
       authProviderRef.current = new BrowserOAuthClientProvider(url, {
         storageKeyPrefix,
@@ -4971,187 +5418,63 @@ function useMcp(options) {
       addLog("debug", "BrowserOAuthClientProvider initialized in connect.");
     }
     if (!clientRef.current) {
-      clientRef.current = new import_client3.Client(
-        { name: clientConfig.name || "mcp-use", version: clientConfig.version || "0.1.0" },
-        { capabilities: {} }
-      );
-      addLog("debug", "MCP Client initialized in connect.");
+      clientRef.current = new BrowserMCPClient();
+      addLog("debug", "BrowserMCPClient initialized in connect.");
     }
     const tryConnectWithTransport = /* @__PURE__ */ __name(async (transportTypeParam, isAuthRetry = false) => {
-      addLog("info", `Attempting connection with ${transportTypeParam.toUpperCase()} transport${isAuthRetry ? " (after auth)" : ""}...`);
-      if (stateRef.current !== "authenticating") {
-        setState("connecting");
-      }
-      let transportInstance;
+      addLog(
+        "info",
+        `Attempting connection with transport: ${transportTypeParam}`
+      );
       try {
-        assert(authProviderRef.current, "Auth Provider must be initialized");
-        assert(clientRef.current, "Client must be initialized");
-        if (transportRef.current) {
-          await transportRef.current.close().catch((e) => addLog("warn", `Error closing previous transport: ${e.message}`));
-          transportRef.current = null;
-        }
-        const commonOptions = {
-          authProvider: authProviderRef.current,
-          requestInit: {
-            headers: {
-              Accept: "application/json, text/event-stream",
-              ...customHeaders
-            }
-          }
-          // Note: The MCP SDK's SSEClientTransport doesn't expose timeout configuration directly
-          // Timeout handling is managed by the underlying EventSource and browser/Node.js fetch implementations
-          // The timeout and sseReadTimeout options are preserved for future use or custom implementations
+        const serverName = "inspector-server";
+        const serverConfig = {
+          url,
+          transport: transportTypeParam === "sse" ? "http" : transportTypeParam
         };
-        const sanitizedUrl = (0, import_strict_url_sanitise2.sanitizeUrl)(url);
-        const targetUrl = new URL(sanitizedUrl);
-        addLog("debug", `Creating ${transportTypeParam.toUpperCase()} transport for URL: ${targetUrl.toString()}`);
-        if (transportTypeParam === "http") {
-          addLog("debug", "Creating StreamableHTTPClientTransport...");
-          transportInstance = new import_streamableHttp3.StreamableHTTPClientTransport(targetUrl, commonOptions);
-          addLog("debug", "StreamableHTTPClientTransport created successfully");
-        } else {
-          addLog("debug", "Creating SSEClientTransport...");
-          transportInstance = new import_sse3.SSEClientTransport(targetUrl, commonOptions);
-          addLog("debug", "SSEClientTransport created successfully");
-        }
-        transportRef.current = transportInstance;
-        addLog("debug", `${transportTypeParam.toUpperCase()} transport created and assigned to ref.`);
-      } catch (err) {
-        failConnection(
-          `Failed to create ${transportTypeParam.toUpperCase()} transport: ${err instanceof Error ? err.message : String(err)}`,
-          err instanceof Error ? err : void 0
-        );
-        return "failed";
-      }
-      transportInstance.onmessage = (message) => {
-        addLog("debug", `[Transport] Received: ${JSON.stringify(message)}`);
-        clientRef.current?.handleMessage?.(message);
-      };
-      transportInstance.onerror = (err) => {
-        addLog("warn", `Transport error event (${transportTypeParam.toUpperCase()}):`, err);
-        failConnection(`Transport error (${transportTypeParam.toUpperCase()}): ${err.message}`, err);
-      };
-      transportInstance.onclose = () => {
-        if (!isMountedRef.current || connectingRef.current) return;
-        addLog("info", `Transport connection closed (${successfulTransportRef.current || "unknown"} type).`);
-        const currentState = stateRef.current;
-        const currentAutoReconnect = autoReconnectRef.current;
-        if (currentState === "ready" && currentAutoReconnect) {
-          const delay = typeof currentAutoReconnect === "number" ? currentAutoReconnect : DEFAULT_RECONNECT_DELAY;
-          addLog("info", `Attempting to reconnect in ${delay}ms...`);
-          setState("connecting");
-          setTimeout(() => {
-            if (isMountedRef.current) {
-              connect();
-            }
-          }, delay);
-        } else if (currentState !== "failed" && currentState !== "authenticating") {
-          failConnection("Cannot connect to server");
+        if (customHeaders && Object.keys(customHeaders).length > 0) {
+          serverConfig.headers = customHeaders;
         }
-      };
-      try {
-        addLog("info", `Connecting client via ${transportTypeParam.toUpperCase()}...`);
-        await clientRef.current.connect(transportInstance);
-        addLog("info", `Client connected via ${transportTypeParam.toUpperCase()}. Loading tools, resources, and prompts...`);
-        successfulTransportRef.current = transportTypeParam;
-        setState("loading");
-        const toolsResponse = await clientRef.current.request({ method: "tools/list" }, import_types.ListToolsResultSchema);
-        let resourcesResponse = { resources: [], resourceTemplates: [] };
-        try {
-          resourcesResponse = await clientRef.current.request({ method: "resources/list" }, import_types.ListResourcesResultSchema);
-        } catch (err) {
-          addLog("debug", "Server does not support resources/list method", err);
-        }
-        let promptsResponse = { prompts: [] };
-        try {
-          promptsResponse = await clientRef.current.request({ method: "prompts/list" }, import_types.ListPromptsResultSchema);
-        } catch (err) {
-          addLog("debug", "Server does not support prompts/list method", err);
-        }
-        if (isMountedRef.current) {
-          setTools(toolsResponse.tools);
-          setResources(resourcesResponse.resources);
-          setResourceTemplates(Array.isArray(resourcesResponse.resourceTemplates) ? resourcesResponse.resourceTemplates : []);
-          setPrompts(promptsResponse.prompts);
-          const summary = [`Loaded ${toolsResponse.tools.length} tools`];
-          if (resourcesResponse.resources.length > 0 || resourcesResponse.resourceTemplates && resourcesResponse.resourceTemplates.length > 0) {
-            summary.push(`${resourcesResponse.resources.length} resources`);
-            if (Array.isArray(resourcesResponse.resourceTemplates) && resourcesResponse.resourceTemplates.length > 0) {
-              summary.push(`${resourcesResponse.resourceTemplates.length} resource templates`);
-            }
-          }
-          if (promptsResponse.prompts.length > 0) {
-            summary.push(`${promptsResponse.prompts.length} prompts`);
+        if (authProviderRef.current) {
+          const tokens = await authProviderRef.current.tokens();
+          if (tokens?.access_token) {
+            serverConfig.headers = {
+              ...serverConfig.headers,
+              Authorization: `Bearer ${tokens.access_token}`
+            };
           }
-          addLog("info", summary.join(", ") + ".");
-          setState("ready");
-          connectAttemptRef.current = 0;
-          return "success";
-        } else {
-          return "failed";
-        }
-      } catch (connectErr) {
-        addLog("debug", `Client connect error via ${transportTypeParam.toUpperCase()}:`, connectErr);
-        const errorInstance = connectErr instanceof Error ? connectErr : new Error(String(connectErr));
-        const errorMessage = errorInstance.message;
-        const is404 = errorMessage.includes("404") || errorMessage.includes("Not Found");
-        const is405 = errorMessage.includes("405") || errorMessage.includes("Method Not Allowed");
-        const isLikelyCors = errorMessage === "Failed to fetch" || errorMessage === "NetworkError when attempting to fetch resource." || errorMessage === "Load failed";
-        if (transportTypeParam === "http" && (is404 || is405 || isLikelyCors)) {
-          addLog("warn", `HTTP transport failed (${isLikelyCors ? "CORS" : is404 ? "404" : "405"}), will try fallback.`);
-          return "fallback";
         }
-        if (errorInstance instanceof import_auth2.UnauthorizedError || errorMessage.includes("Unauthorized") || errorMessage.includes("401")) {
-          if (isAuthRetry) {
-            addLog("error", "Authentication failed even after successful token refresh. This may indicate a server issue.");
-            failConnection("Authentication loop detected - auth succeeded but connection still unauthorized.");
-            return "failed";
-          }
-          addLog("info", "Authentication required.");
-          assert(authProviderRef.current, "Auth Provider not available for auth flow");
-          const existingTokens = await authProviderRef.current.tokens();
-          if (preventAutoAuth && !existingTokens) {
-            addLog("info", "Authentication required but auto-auth prevented. User action needed.");
-            setState("pending_auth");
-            return "auth_redirect";
-          }
-          if (stateRef.current !== "authenticating" && stateRef.current !== "pending_auth") {
-            setState("authenticating");
-            if (authTimeoutRef.current) clearTimeout(authTimeoutRef.current);
-            authTimeoutRef.current = setTimeout(() => {
-              if (isMountedRef.current) {
-                const currentState = stateRef.current;
-                if (currentState === "authenticating") {
-                  failConnection("Authentication timed out. Please try again.");
-                }
-              }
-            }, AUTH_TIMEOUT);
-          }
-          try {
-            assert(url, "Server URL is required for authentication");
-            const baseUrl = new URL(url).origin;
-            const authResult = await (0, import_auth2.auth)(authProviderRef.current, { serverUrl: baseUrl });
-            if (!isMountedRef.current) return "failed";
-            if (authResult === "AUTHORIZED") {
-              addLog("info", "Authentication successful via existing token or refresh. Retrying transport connection...");
-              if (authTimeoutRef.current) clearTimeout(authTimeoutRef.current);
-              authTimeoutRef.current = null;
-              return await tryConnectWithTransport(transportTypeParam, true);
-            } else if (authResult === "REDIRECT") {
-              addLog("info", "Redirecting for authentication. Waiting for callback...");
-              return "auth_redirect";
-            }
-          } catch (sdkAuthError) {
-            if (!isMountedRef.current) return "failed";
-            if (authTimeoutRef.current) clearTimeout(authTimeoutRef.current);
+        clientRef.current.addServer(serverName, {
+          ...serverConfig,
+          authProvider: authProviderRef.current
+          // ← SDK handles OAuth automatically!
+        });
+        const session = await clientRef.current.createSession(serverName);
+        await session.initialize();
+        addLog("info", "\u2705 Successfully connected to MCP server");
+        setState("ready");
+        successfulTransportRef.current = transportTypeParam;
+        setTools(session.connector.tools || []);
+        const resourcesResult = await session.connector.listAllResources();
+        setResources(resourcesResult.resources || []);
+        const promptsResult = await session.connector.listPrompts();
+        setPrompts(promptsResult.prompts || []);
+        return "success";
+      } catch (err) {
+        const errorMessage = err?.message || String(err);
+        if (err.code === 401 || errorMessage.includes("401") || errorMessage.includes("Unauthorized")) {
+          if (customHeaders && Object.keys(customHeaders).length > 0) {
             failConnection(
-              `Failed to initiate authentication: ${sdkAuthError instanceof Error ? sdkAuthError.message : String(sdkAuthError)}`,
-              sdkAuthError instanceof Error ? sdkAuthError : void 0
+              "Authentication failed: Server returned 401 Unauthorized. Check your Authorization header value is correct."
             );
             return "failed";
           }
+          failConnection(
+            "Authentication required: Server returned 401 Unauthorized. Add an Authorization header in the Custom Headers section (e.g., Authorization: Bearer YOUR_API_KEY)."
+          );
+          return "failed";
         }
-        failConnection(`Failed to connect via ${transportTypeParam.toUpperCase()}: ${errorMessage}`, errorInstance);
+        failConnection(errorMessage, err);
         return "failed";
       }
     }, "tryConnectWithTransport");
@@ -5199,66 +5522,36 @@ function useMcp(options) {
   const callTool = (0, import_react.useCallback)(
     async (name, args) => {
       if (stateRef.current !== "ready" || !clientRef.current) {
-        throw new Error(`MCP client is not ready (current state: ${state}). Cannot call tool "${name}".`);
+        throw new Error(
+          `MCP client is not ready (current state: ${state}). Cannot call tool "${name}".`
+        );
       }
       addLog("info", `Calling tool: ${name}`, args);
       try {
-        const result = await clientRef.current.request({ method: "tools/call", params: { name, arguments: args } }, import_types.CallToolResultSchema);
+        const serverName = "inspector-server";
+        const session = clientRef.current.getSession(serverName);
+        if (!session) {
+          throw new Error("No active session found");
+        }
+        const result = await session.connector.callTool(name, args || {});
         addLog("info", `Tool "${name}" call successful:`, result);
         return result;
       } catch (err) {
-        addLog("error", `Error calling tool "${name}": ${err instanceof Error ? err.message : String(err)}`, err);
-        const errorInstance = err instanceof Error ? err : new Error(String(err));
-        if (errorInstance instanceof import_auth2.UnauthorizedError || errorInstance.message.includes("Unauthorized") || errorInstance.message.includes("401")) {
-          addLog("warn", "Tool call unauthorized, attempting re-authentication...");
-          setState("authenticating");
-          if (authTimeoutRef.current) clearTimeout(authTimeoutRef.current);
-          authTimeoutRef.current = setTimeout(() => {
-            if (isMountedRef.current) {
-              const currentState2 = stateRef.current;
-              if (currentState2 === "authenticating") {
-                failConnection("Authentication timed out. Please try again.");
-              }
-            }
-          }, AUTH_TIMEOUT);
-          try {
-            assert(authProviderRef.current, "Auth Provider not available for tool re-auth");
-            assert(url, "Server URL is required for authentication");
-            const baseUrl = new URL(url).origin;
-            const authResult = await (0, import_auth2.auth)(authProviderRef.current, { serverUrl: baseUrl });
-            if (!isMountedRef.current) return;
-            if (authResult === "AUTHORIZED") {
-              addLog("info", "Re-authentication successful. Retrying tool call is recommended, or reconnecting.");
-              if (authTimeoutRef.current) clearTimeout(authTimeoutRef.current);
-              connectingRef.current = false;
-              connect();
-            } else if (authResult === "REDIRECT") {
-              addLog("info", "Redirecting for re-authentication for tool call.");
-            }
-          } catch (sdkAuthError) {
-            if (!isMountedRef.current) return;
-            if (authTimeoutRef.current) clearTimeout(authTimeoutRef.current);
-            failConnection(
-              `Re-authentication failed: ${sdkAuthError instanceof Error ? sdkAuthError.message : String(sdkAuthError)}`,
-              sdkAuthError instanceof Error ? sdkAuthError : void 0
-            );
-          }
-        }
-        const currentState = stateRef.current;
-        if (currentState !== "authenticating") {
-          throw err;
-        }
-        return void 0;
+        addLog("error", `Tool "${name}" call failed:`, err);
+        throw err;
       }
     },
-    [state, url, addLog, failConnection, connect]
+    [state]
   );
   const retry = (0, import_react.useCallback)(() => {
     if (stateRef.current === "failed") {
       addLog("info", "Retry requested...");
       connect();
     } else {
-      addLog("warn", `Retry called but state is not 'failed' (state: ${stateRef.current}). Ignoring.`);
+      addLog(
+        "warn",
+        `Retry called but state is not 'failed' (state: ${stateRef.current}). Ignoring.`
+      );
     }
   }, [addLog, connect]);
   const authenticate = (0, import_react.useCallback)(async () => {
@@ -5280,19 +5573,15 @@ function useMcp(options) {
         }
       }, AUTH_TIMEOUT);
       try {
-        assert(authProviderRef.current, "Auth Provider not available for manual auth");
+        assert(
+          authProviderRef.current,
+          "Auth Provider not available for manual auth"
+        );
         assert(url, "Server URL is required for authentication");
-        const baseUrl = new URL(url).origin;
-        const authResult = await (0, import_auth2.auth)(authProviderRef.current, { serverUrl: baseUrl });
-        if (!isMountedRef.current) return;
-        if (authResult === "AUTHORIZED") {
-          addLog("info", "Manual authentication successful. Re-attempting connection...");
-          if (authTimeoutRef.current) clearTimeout(authTimeoutRef.current);
-          connectingRef.current = false;
-          connect();
-        } else if (authResult === "REDIRECT") {
-          addLog("info", "Redirecting for manual authentication. Waiting for callback...");
-        }
+        addLog(
+          "info",
+          "Redirecting for manual authentication. Waiting for callback..."
+        );
       } catch (authError) {
         if (!isMountedRef.current) return;
         if (authTimeoutRef.current) clearTimeout(authTimeoutRef.current);
@@ -5302,7 +5591,10 @@ function useMcp(options) {
         );
       }
     } else if (currentState === "authenticating") {
-      addLog("warn", "Already attempting authentication. Check for blocked popups or wait for timeout.");
+      addLog(
+        "warn",
+        "Already attempting authentication. Check for blocked popups or wait for timeout."
+      );
       const manualUrl = authProviderRef.current?.getLastAttemptedAuthUrl();
       if (manualUrl && !authUrl) {
         setAuthUrl(manualUrl);
@@ -5327,73 +5619,93 @@ function useMcp(options) {
   }, [url, addLog, disconnect]);
   const listResources = (0, import_react.useCallback)(async () => {
     if (stateRef.current !== "ready" || !clientRef.current) {
-      throw new Error(`MCP client is not ready (current state: ${state}). Cannot list resources.`);
+      throw new Error(
+        `MCP client is not ready (current state: ${state}). Cannot list resources.`
+      );
     }
-    addLog("info", "Listing resources...");
+    addLog("info", "Listing resources");
     try {
-      const resourcesResponse = await clientRef.current.request({ method: "resources/list" }, import_types.ListResourcesResultSchema);
-      if (isMountedRef.current) {
-        setResources(resourcesResponse.resources);
-        setResourceTemplates(Array.isArray(resourcesResponse.resourceTemplates) ? resourcesResponse.resourceTemplates : []);
-        addLog(
-          "info",
-          `Listed ${resourcesResponse.resources.length} resources, ${Array.isArray(resourcesResponse.resourceTemplates) ? resourcesResponse.resourceTemplates.length : 0} resource templates.`
-        );
+      const serverName = "inspector-server";
+      const session = clientRef.current.getSession(serverName);
+      if (!session) {
+        throw new Error("No active session found");
       }
+      const resourcesResult = await session.connector.listAllResources();
+      setResources(resourcesResult.resources || []);
+      addLog("info", "Resources listed successfully");
     } catch (err) {
-      addLog("error", `Error listing resources: ${err instanceof Error ? err.message : String(err)}`, err);
+      addLog("error", "List resources failed:", err);
       throw err;
     }
-  }, [state, addLog]);
+  }, [state]);
   const readResource = (0, import_react.useCallback)(
     async (uri) => {
       if (stateRef.current !== "ready" || !clientRef.current) {
-        throw new Error(`MCP client is not ready (current state: ${state}). Cannot read resource "${uri}".`);
+        throw new Error(
+          `MCP client is not ready (current state: ${state}). Cannot read resource.`
+        );
       }
       addLog("info", `Reading resource: ${uri}`);
       try {
-        const result = await clientRef.current.request({ method: "resources/read", params: { uri } }, import_types.ReadResourceResultSchema);
-        addLog("info", `Resource "${uri}" read successfully`);
+        const serverName = "inspector-server";
+        const session = clientRef.current.getSession(serverName);
+        if (!session) {
+          throw new Error("No active session found");
+        }
+        const result = await session.connector.readResource(uri);
+        addLog("info", "Resource read successful:", result);
         return result;
       } catch (err) {
-        addLog("error", `Error reading resource "${uri}": ${err instanceof Error ? err.message : String(err)}`, err);
+        addLog("error", "Resource read failed:", err);
         throw err;
       }
     },
-    [state, addLog]
+    [state]
   );
   const listPrompts = (0, import_react.useCallback)(async () => {
     if (stateRef.current !== "ready" || !clientRef.current) {
-      throw new Error(`MCP client is not ready (current state: ${state}). Cannot list prompts.`);
+      throw new Error(
+        `MCP client is not ready (current state: ${state}). Cannot list prompts.`
+      );
     }
-    addLog("info", "Listing prompts...");
+    addLog("info", "Listing prompts");
     try {
-      const promptsResponse = await clientRef.current.request({ method: "prompts/list" }, import_types.ListPromptsResultSchema);
-      if (isMountedRef.current) {
-        setPrompts(promptsResponse.prompts);
-        addLog("info", `Listed ${promptsResponse.prompts.length} prompts.`);
+      const serverName = "inspector-server";
+      const session = clientRef.current.getSession(serverName);
+      if (!session) {
+        throw new Error("No active session found");
       }
+      const promptsResult = await session.connector.listPrompts();
+      setPrompts(promptsResult.prompts || []);
+      addLog("info", "Prompts listed successfully");
     } catch (err) {
-      addLog("error", `Error listing prompts: ${err instanceof Error ? err.message : String(err)}`, err);
+      addLog("error", "List prompts failed:", err);
       throw err;
     }
-  }, [state, addLog]);
+  }, [state]);
   const getPrompt = (0, import_react.useCallback)(
     async (name, args) => {
       if (stateRef.current !== "ready" || !clientRef.current) {
-        throw new Error(`MCP client is not ready (current state: ${state}). Cannot get prompt "${name}".`);
+        throw new Error(
+          `MCP client is not ready (current state: ${state}). Cannot get prompt.`
+        );
       }
       addLog("info", `Getting prompt: ${name}`, args);
       try {
-        const result = await clientRef.current.request({ method: "prompts/get", params: { name, arguments: args } }, import_types.GetPromptResultSchema);
-        addLog("info", `Prompt "${name}" retrieved successfully`);
+        const serverName = "inspector-server";
+        const session = clientRef.current.getSession(serverName);
+        if (!session) {
+          throw new Error("No active session found");
+        }
+        const result = await session.connector.getPrompt(name, args || {});
+        addLog("info", `Prompt "${name}" retrieved successfully:`, result);
         return result;
       } catch (err) {
-        addLog("error", `Error getting prompt "${name}": ${err instanceof Error ? err.message : String(err)}`, err);
+        addLog("error", `Prompt "${name}" retrieval failed:`, err);
         throw err;
       }
     },
-    [state, addLog]
+    [state]
   );
   const connectRef = (0, import_react.useRef)(connect);
   const failConnectionRef = (0, import_react.useRef)(failConnection);
@@ -5409,19 +5721,30 @@ function useMcp(options) {
         if (authTimeoutRef.current) clearTimeout(authTimeoutRef.current);
         authTimeoutRef.current = null;
         if (event.data.success) {
-          addLog("info", "Authentication successful via popup. Reconnecting client...");
+          addLog(
+            "info",
+            "Authentication successful via popup. Reconnecting client..."
+          );
           if (connectingRef.current) {
-            addLog("debug", "Connection attempt already in progress, resetting flag to allow reconnection.");
+            addLog(
+              "debug",
+              "Connection attempt already in progress, resetting flag to allow reconnection."
+            );
           }
           connectingRef.current = false;
           setTimeout(() => {
             if (isMountedRef.current) {
-              addLog("debug", "Initiating reconnection after successful auth callback.");
+              addLog(
+                "debug",
+                "Initiating reconnection after successful auth callback."
+              );
               connectRef.current();
             }
           }, 100);
         } else {
-          failConnectionRef.current(`Authentication failed in callback: ${event.data.error || "Unknown reason."}`);
+          failConnectionRef.current(
+            `Authentication failed in callback: ${event.data.error || "Unknown reason."}`
+          );
         }
       }
     }, "messageHandler");
@@ -5436,7 +5759,10 @@ function useMcp(options) {
   (0, import_react.useEffect)(() => {
     isMountedRef.current = true;
     if (!enabled || !url) {
-      addLog("debug", enabled ? "No server URL provided, skipping connection." : "Connection disabled via enabled flag.");
+      addLog(
+        "debug",
+        enabled ? "No server URL provided, skipping connection." : "Connection disabled via enabled flag."
+      );
       setState("discovering");
       return () => {
         isMountedRef.current = false;
@@ -5453,7 +5779,10 @@ function useMcp(options) {
         preventAutoAuth,
         onPopupWindow
       });
-      addLog("debug", "BrowserOAuthClientProvider initialized/updated on mount/option change.");
+      addLog(
+        "debug",
+        "BrowserOAuthClientProvider initialized/updated on mount/option change."
+      );
     }
     connect();
     return () => {
@@ -5461,7 +5790,16 @@ function useMcp(options) {
       addLog("debug", "useMcp unmounting, disconnecting.");
       disconnect(true);
     };
-  }, [url, enabled, storageKeyPrefix, callbackUrl, clientName, clientUri, clientConfig.name, clientConfig.version]);
+  }, [
+    url,
+    enabled,
+    storageKeyPrefix,
+    callbackUrl,
+    clientName,
+    clientUri,
+    clientConfig.name,
+    clientConfig.version
+  ]);
   (0, import_react.useEffect)(() => {
     let retryTimeoutId = null;
     if (state === "failed" && autoRetry && connectAttemptRef.current > 0) {
@@ -5486,9 +5824,10 @@ function useMcp(options) {
     error,
     log,
     authUrl,
+    client: clientRef.current,
     callTool,
-    listResources,
     readResource,
+    listResources,
     listPrompts,
     getPrompt,
     retry,
@@ -5518,17 +5857,11 @@ function useOpenAiGlobal(key) {
         onChange();
       }, "handleSetGlobal");
       if (typeof window !== "undefined") {
-        window.addEventListener(
-          SET_GLOBALS_EVENT_TYPE,
-          handleSetGlobal
-        );
+        window.addEventListener(SET_GLOBALS_EVENT_TYPE, handleSetGlobal);
       }
       return () => {
         if (typeof window !== "undefined") {
-          window.removeEventListener(
-            SET_GLOBALS_EVENT_TYPE,
-            handleSetGlobal
-          );
+          window.removeEventListener(SET_GLOBALS_EVENT_TYPE, handleSetGlobal);
         }
       };
     },
@@ -5538,7 +5871,10 @@ function useOpenAiGlobal(key) {
 __name(useOpenAiGlobal, "useOpenAiGlobal");
 function useWidget(defaultProps) {
   console.log(window?.location?.search, window.openai);
-  const isOpenAiAvailable = (0, import_react2.useMemo)(() => typeof window !== "undefined" && !!window.openai, []);
+  const isOpenAiAvailable = (0, import_react2.useMemo)(
+    () => typeof window !== "undefined" && !!window.openai,
+    []
+  );
   const provider = (0, import_react2.useMemo)(() => {
     return isOpenAiAvailable ? "openai" : "mcp-ui";
   }, [isOpenAiAvailable]);
@@ -5579,12 +5915,15 @@ function useWidget(defaultProps) {
     },
     []
   );
-  const sendFollowUpMessage = (0, import_react2.useCallback)(async (prompt) => {
-    if (!window.openai?.sendFollowUpMessage) {
-      throw new Error("window.openai.sendFollowUpMessage is not available");
-    }
-    return window.openai.sendFollowUpMessage({ prompt });
-  }, []);
+  const sendFollowUpMessage = (0, import_react2.useCallback)(
+    async (prompt) => {
+      if (!window.openai?.sendFollowUpMessage) {
+        throw new Error("window.openai.sendFollowUpMessage is not available");
+      }
+      return window.openai.sendFollowUpMessage({ prompt });
+    },
+    []
+  );
   const openExternal = (0, import_react2.useCallback)((href) => {
     if (!window.openai?.openExternal) {
       throw new Error("window.openai.openExternal is not available");