mcp-use 1.2.1-canary.0 → 1.2.2-canary.0

package/dist/src/react/index.cjs

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 var __export = (target, all) => {
@@ -16,6 +18,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/react/index.ts
@@ -31,13 +41,1268 @@ __export(react_exports, {
 module.exports = __toCommonJS(react_exports);
 
 // src/react/useMcp.ts
-var import_types = require("@modelcontextprotocol/sdk/types.js");
 var import_react = require("react");
-var import_auth = require("@modelcontextprotocol/sdk/client/auth.js");
+var import_strict_url_sanitise2 = require("strict-url-sanitise");
+
+// src/connectors/http.ts
 var import_client = require("@modelcontextprotocol/sdk/client/index.js");
+var import_streamableHttp2 = require("@modelcontextprotocol/sdk/client/streamableHttp.js");
+
+// src/logging.ts
+var import_winston = require("winston");
+async function getNodeModules() {
+  if (typeof process !== "undefined" && process.platform) {
+    try {
+      const fs = await import("fs");
+      const path = await import("path");
+      return { fs: fs.default, path: path.default };
+    } catch {
+      return { fs: null, path: null };
+    }
+  }
+  return { fs: null, path: null };
+}
+__name(getNodeModules, "getNodeModules");
+var { combine, timestamp, label, printf, colorize, splat } = import_winston.format;
+var DEFAULT_LOGGER_NAME = "mcp-use";
+function isNodeJSEnvironment() {
+  try {
+    if (typeof navigator !== "undefined" && navigator.userAgent?.includes("Cloudflare-Workers")) {
+      return false;
+    }
+    if (typeof globalThis.EdgeRuntime !== "undefined" || typeof globalThis.Deno !== "undefined") {
+      return false;
+    }
+    const hasNodeGlobals = typeof process !== "undefined" && typeof process.platform !== "undefined" && typeof __dirname !== "undefined";
+    const hasNodeModules = typeof import_winston.createLogger === "function";
+    return hasNodeGlobals && hasNodeModules;
+  } catch {
+    return false;
+  }
+}
+__name(isNodeJSEnvironment, "isNodeJSEnvironment");
+var SimpleConsoleLogger = class {
+  static {
+    __name(this, "SimpleConsoleLogger");
+  }
+  _level;
+  name;
+  constructor(name = DEFAULT_LOGGER_NAME, level = "info") {
+    this.name = name;
+    this._level = level;
+  }
+  shouldLog(level) {
+    const levels = ["error", "warn", "info", "http", "verbose", "debug", "silly"];
+    const currentIndex = levels.indexOf(this._level);
+    const messageIndex = levels.indexOf(level);
+    return messageIndex <= currentIndex;
+  }
+  formatMessage(level, message) {
+    const timestamp2 = (/* @__PURE__ */ new Date()).toLocaleTimeString("en-US", { hour12: false });
+    return `${timestamp2} [${this.name}] ${level}: ${message}`;
+  }
+  error(message) {
+    if (this.shouldLog("error")) {
+      console.error(this.formatMessage("error", message));
+    }
+  }
+  warn(message) {
+    if (this.shouldLog("warn")) {
+      console.warn(this.formatMessage("warn", message));
+    }
+  }
+  info(message) {
+    if (this.shouldLog("info")) {
+      console.info(this.formatMessage("info", message));
+    }
+  }
+  debug(message) {
+    if (this.shouldLog("debug")) {
+      console.debug(this.formatMessage("debug", message));
+    }
+  }
+  http(message) {
+    if (this.shouldLog("http")) {
+      console.log(this.formatMessage("http", message));
+    }
+  }
+  verbose(message) {
+    if (this.shouldLog("verbose")) {
+      console.log(this.formatMessage("verbose", message));
+    }
+  }
+  silly(message) {
+    if (this.shouldLog("silly")) {
+      console.log(this.formatMessage("silly", message));
+    }
+  }
+  // Make it compatible with Winston interface
+  get level() {
+    return this._level;
+  }
+  set level(newLevel) {
+    this._level = newLevel;
+  }
+};
+function resolveLevel(env) {
+  const envValue = typeof process !== "undefined" && process.env ? env : void 0;
+  switch (envValue?.trim()) {
+    case "2":
+      return "debug";
+    case "1":
+      return "info";
+    default:
+      return "info";
+  }
+}
+__name(resolveLevel, "resolveLevel");
+var minimalFormatter = printf(({ level, message, label: label2, timestamp: timestamp2 }) => {
+  return `${timestamp2} [${label2}] ${level}: ${message}`;
+});
+var detailedFormatter = printf(({ level, message, label: label2, timestamp: timestamp2 }) => {
+  return `${timestamp2} [${label2}] ${level.toUpperCase()}: ${message}`;
+});
+var emojiFormatter = printf(({ level, message, label: label2, timestamp: timestamp2 }) => {
+  return `${timestamp2} [${label2}] ${level.toUpperCase()}: ${message}`;
+});
+var Logger = class {
+  static {
+    __name(this, "Logger");
+  }
+  static instances = {};
+  static simpleInstances = {};
+  static currentFormat = "minimal";
+  static get(name = DEFAULT_LOGGER_NAME) {
+    if (!isNodeJSEnvironment()) {
+      if (!this.simpleInstances[name]) {
+        const debugEnv = typeof process !== "undefined" && process.env?.DEBUG || void 0;
+        this.simpleInstances[name] = new SimpleConsoleLogger(name, resolveLevel(debugEnv));
+      }
+      return this.simpleInstances[name];
+    }
+    if (!this.instances[name]) {
+      this.instances[name] = (0, import_winston.createLogger)({
+        level: resolveLevel(process.env.DEBUG),
+        format: combine(
+          colorize(),
+          splat(),
+          label({ label: name }),
+          timestamp({ format: "HH:mm:ss" }),
+          this.getFormatter()
+        ),
+        transports: []
+      });
+    }
+    return this.instances[name];
+  }
+  static getFormatter() {
+    switch (this.currentFormat) {
+      case "minimal":
+        return minimalFormatter;
+      case "detailed":
+        return detailedFormatter;
+      case "emoji":
+        return emojiFormatter;
+      default:
+        return minimalFormatter;
+    }
+  }
+  static async configure(options = {}) {
+    const { level, console: console2 = true, file, format: format2 = "minimal" } = options;
+    const debugEnv = typeof process !== "undefined" && process.env?.DEBUG || void 0;
+    const resolvedLevel = level ?? resolveLevel(debugEnv);
+    this.currentFormat = format2;
+    const root = this.get();
+    root.level = resolvedLevel;
+    const winstonRoot = root;
+    if (!isNodeJSEnvironment()) {
+      Object.values(this.simpleInstances).forEach((logger2) => {
+        logger2.level = resolvedLevel;
+      });
+      return;
+    }
+    winstonRoot.clear();
+    if (console2) {
+      winstonRoot.add(new import_winston.transports.Console());
+    }
+    if (file) {
+      const { fs: nodeFs, path: nodePath } = await getNodeModules();
+      if (nodeFs && nodePath) {
+        const dir = nodePath.dirname(nodePath.resolve(file));
+        if (!nodeFs.existsSync(dir)) {
+          nodeFs.mkdirSync(dir, { recursive: true });
+        }
+        winstonRoot.add(new import_winston.transports.File({ filename: file }));
+      }
+    }
+    Object.values(this.instances).forEach((logger2) => {
+      if (logger2 && "format" in logger2) {
+        logger2.level = resolvedLevel;
+        logger2.format = combine(
+          colorize(),
+          splat(),
+          label({ label: DEFAULT_LOGGER_NAME }),
+          timestamp({ format: "HH:mm:ss" }),
+          this.getFormatter()
+        );
+      }
+    });
+  }
+  static setDebug(enabled) {
+    let level;
+    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;
+    });
+    Object.values(this.instances).forEach((logger2) => {
+      if (logger2) {
+        logger2.level = level;
+      }
+    });
+    if (typeof process !== "undefined" && process.env) {
+      process.env.DEBUG = enabled ? enabled === true ? "2" : String(enabled) : "0";
+    }
+  }
+  static setFormat(format2) {
+    this.currentFormat = format2;
+    this.configure({ format: format2 });
+  }
+};
+if (isNodeJSEnvironment()) {
+  Logger.configure();
+} else {
+  Logger.configure({ console: true });
+}
+var logger = Logger.get();
+
+// src/task_managers/sse.ts
 var import_sse = require("@modelcontextprotocol/sdk/client/sse.js");
+
+// src/task_managers/base.ts
+var ConnectionManager = class {
+  static {
+    __name(this, "ConnectionManager");
+  }
+  _readyPromise;
+  _readyResolver;
+  _donePromise;
+  _doneResolver;
+  _exception = null;
+  _connection = null;
+  _task = null;
+  _abortController = null;
+  constructor() {
+    this.reset();
+  }
+  /**
+   * Start the connection manager and establish a connection.
+   *
+   * @returns The established connection.
+   * @throws If the connection cannot be established.
+   */
+  async start() {
+    this.reset();
+    logger.debug(`Starting ${this.constructor.name}`);
+    this._task = this.connectionTask();
+    await this._readyPromise;
+    if (this._exception) {
+      throw this._exception;
+    }
+    if (this._connection === null) {
+      throw new Error("Connection was not established");
+    }
+    return this._connection;
+  }
+  /**
+   * Stop the connection manager and close the connection.
+   */
+  async stop() {
+    if (this._task && this._abortController) {
+      logger.debug(`Cancelling ${this.constructor.name} task`);
+      this._abortController.abort();
+      try {
+        await this._task;
+      } catch (e) {
+        if (e instanceof Error && e.name === "AbortError") {
+          logger.debug(`${this.constructor.name} task aborted successfully`);
+        } else {
+          logger.warn(`Error stopping ${this.constructor.name} task: ${e}`);
+        }
+      }
+    }
+    await this._donePromise;
+    logger.debug(`${this.constructor.name} task completed`);
+  }
+  /**
+   * Reset all internal state.
+   */
+  reset() {
+    this._readyPromise = new Promise((res) => this._readyResolver = res);
+    this._donePromise = new Promise((res) => this._doneResolver = res);
+    this._exception = null;
+    this._connection = null;
+    this._task = null;
+    this._abortController = new AbortController();
+  }
+  /**
+   * The background task responsible for establishing and maintaining the
+   * connection until it is cancelled.
+   */
+  async connectionTask() {
+    logger.debug(`Running ${this.constructor.name} task`);
+    try {
+      this._connection = await this.establishConnection();
+      logger.debug(`${this.constructor.name} connected successfully`);
+      this._readyResolver();
+      await this.waitForAbort();
+    } catch (err) {
+      this._exception = err;
+      logger.error(`Error in ${this.constructor.name} task: ${err}`);
+      this._readyResolver();
+    } finally {
+      if (this._connection !== null) {
+        try {
+          await this.closeConnection(this._connection);
+        } catch (closeErr) {
+          logger.warn(`Error closing connection in ${this.constructor.name}: ${closeErr}`);
+        }
+        this._connection = null;
+      }
+      this._doneResolver();
+    }
+  }
+  /**
+   * Helper that returns a promise which resolves when the abort signal fires.
+   */
+  async waitForAbort() {
+    return new Promise((_resolve, _reject) => {
+      if (!this._abortController) {
+        return;
+      }
+      const signal = this._abortController.signal;
+      if (signal.aborted) {
+        _resolve();
+        return;
+      }
+      const onAbort = /* @__PURE__ */ __name(() => {
+        signal.removeEventListener("abort", onAbort);
+        _resolve();
+      }, "onAbort");
+      signal.addEventListener("abort", onAbort);
+    });
+  }
+};
+
+// src/task_managers/sse.ts
+var SseConnectionManager = class extends ConnectionManager {
+  static {
+    __name(this, "SseConnectionManager");
+  }
+  url;
+  opts;
+  _transport = null;
+  /**
+   * Create an SSE connection manager.
+   *
+   * @param url  The SSE endpoint URL.
+   * @param opts Optional transport options (auth, headers, etc.).
+   */
+  constructor(url, opts) {
+    super();
+    this.url = typeof url === "string" ? new URL(url) : url;
+    this.opts = opts;
+  }
+  /**
+   * Spawn a new `SSEClientTransport` and start the connection.
+   */
+  async establishConnection() {
+    this._transport = new import_sse.SSEClientTransport(this.url, this.opts);
+    logger.debug(`${this.constructor.name} connected successfully`);
+    return this._transport;
+  }
+  /**
+   * Close the underlying transport and clean up resources.
+   */
+  async closeConnection(_connection) {
+    if (this._transport) {
+      try {
+        await this._transport.close();
+      } catch (e) {
+        logger.warn(`Error closing SSE transport: ${e}`);
+      } finally {
+        this._transport = null;
+      }
+    }
+  }
+};
+
+// src/task_managers/streamable_http.ts
 var import_streamableHttp = require("@modelcontextprotocol/sdk/client/streamableHttp.js");
-var import_strict_url_sanitise2 = require("strict-url-sanitise");
+var StreamableHttpConnectionManager = class extends ConnectionManager {
+  static {
+    __name(this, "StreamableHttpConnectionManager");
+  }
+  url;
+  opts;
+  _transport = null;
+  /**
+   * Create a Streamable HTTP connection manager.
+   *
+   * @param url  The HTTP endpoint URL.
+   * @param opts Optional transport options (auth, headers, etc.).
+   */
+  constructor(url, opts) {
+    super();
+    this.url = typeof url === "string" ? new URL(url) : url;
+    this.opts = opts;
+  }
+  /**
+   * Spawn a new `StreamableHTTPClientTransport` and return it.
+   * The Client.connect() method will handle starting the transport.
+   */
+  async establishConnection() {
+    this._transport = new import_streamableHttp.StreamableHTTPClientTransport(this.url, this.opts);
+    logger.debug(`${this.constructor.name} created successfully`);
+    return this._transport;
+  }
+  /**
+   * Close the underlying transport and clean up resources.
+   */
+  async closeConnection(_connection) {
+    if (this._transport) {
+      try {
+        await this._transport.close();
+      } catch (e) {
+        logger.warn(`Error closing Streamable HTTP transport: ${e}`);
+      } finally {
+        this._transport = null;
+      }
+    }
+  }
+  /**
+   * Get the session ID from the transport if available.
+   */
+  get sessionId() {
+    return this._transport?.sessionId;
+  }
+};
+
+// src/connectors/base.ts
+var BaseConnector = class {
+  static {
+    __name(this, "BaseConnector");
+  }
+  client = null;
+  connectionManager = null;
+  toolsCache = null;
+  capabilitiesCache = null;
+  connected = false;
+  opts;
+  constructor(opts = {}) {
+    this.opts = opts;
+  }
+  /** Disconnect and release resources. */
+  async disconnect() {
+    if (!this.connected) {
+      logger.debug("Not connected to MCP implementation");
+      return;
+    }
+    logger.debug("Disconnecting from MCP implementation");
+    await this.cleanupResources();
+    this.connected = false;
+    logger.debug("Disconnected from MCP implementation");
+  }
+  /** Check if the client is connected */
+  get isClientConnected() {
+    return this.client != null;
+  }
+  /**
+   * Initialise the MCP session **after** `connect()` has succeeded.
+   *
+   * In the SDK, `Client.connect(transport)` automatically performs the
+   * protocol‑level `initialize` handshake, so we only need to cache the list of
+   * tools and expose some server info.
+   */
+  async initialize(defaultRequestOptions = this.opts.defaultRequestOptions ?? {}) {
+    if (!this.client) {
+      throw new Error("MCP client is not connected");
+    }
+    logger.debug("Caching server capabilities & tools");
+    const capabilities = this.client.getServerCapabilities();
+    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. */
+  get tools() {
+    if (!this.toolsCache) {
+      throw new Error("MCP client is not initialized; call initialize() first");
+    }
+    return this.toolsCache;
+  }
+  /** Call a tool on the server. */
+  async callTool(name, args, options) {
+    if (!this.client) {
+      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);
+    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
+   */
+  async listResources(cursor, options) {
+    if (!this.client) {
+      throw new Error("MCP client is not connected");
+    }
+    logger.debug("Listing resources", cursor ? `with cursor: ${cursor}` : "");
+    return await this.client.listResources({ cursor }, options);
+  }
+  /**
+   * List all resources from the server, automatically handling pagination
+   *
+   * @param options - Request options
+   * @returns Complete list of all resources
+   */
+  async listAllResources(options) {
+    if (!this.client) {
+      throw new Error("MCP client is not connected");
+    }
+    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
+   */
+  async listResourceTemplates(options) {
+    if (!this.client) {
+      throw new Error("MCP client is not connected");
+    }
+    logger.debug("Listing resource templates");
+    return await this.client.listResourceTemplates(void 0, options);
+  }
+  /** Read a resource by URI. */
+  async readResource(uri, options) {
+    if (!this.client) {
+      throw new Error("MCP client is not connected");
+    }
+    logger.debug(`Reading resource ${uri}`);
+    const res = await this.client.readResource({ uri }, options);
+    return res;
+  }
+  /**
+   * Subscribe to resource updates
+   *
+   * @param uri - URI of the resource to subscribe to
+   * @param options - Request options
+   */
+  async subscribeToResource(uri, options) {
+    if (!this.client) {
+      throw new Error("MCP client is not connected");
+    }
+    logger.debug(`Subscribing to resource: ${uri}`);
+    return await this.client.subscribeResource({ uri }, options);
+  }
+  /**
+   * Unsubscribe from resource updates
+   *
+   * @param uri - URI of the resource to unsubscribe from
+   * @param options - Request options
+   */
+  async unsubscribeFromResource(uri, options) {
+    if (!this.client) {
+      throw new Error("MCP client is not connected");
+    }
+    logger.debug(`Unsubscribing from resource: ${uri}`);
+    return await this.client.unsubscribeResource({ uri }, options);
+  }
+  async listPrompts() {
+    if (!this.client) {
+      throw new Error("MCP client is not connected");
+    }
+    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) {
+      throw new Error("MCP client is not connected");
+    }
+    logger.debug(`Getting prompt ${name}`);
+    return await this.client.getPrompt({ name, arguments: args });
+  }
+  /** Send a raw request through the client. */
+  async request(method, params = null, options) {
+    if (!this.client) {
+      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);
+  }
+  /**
+   * Helper to tear down the client & connection manager safely.
+   */
+  async cleanupResources() {
+    const issues = [];
+    if (this.client) {
+      try {
+        if (typeof this.client.close === "function") {
+          await this.client.close();
+        }
+      } catch (e) {
+        const msg = `Error closing client: ${e}`;
+        logger.warn(msg);
+        issues.push(msg);
+      } finally {
+        this.client = null;
+      }
+    }
+    if (this.connectionManager) {
+      try {
+        await this.connectionManager.stop();
+      } catch (e) {
+        const msg = `Error stopping connection manager: ${e}`;
+        logger.warn(msg);
+        issues.push(msg);
+      } finally {
+        this.connectionManager = null;
+      }
+    }
+    this.toolsCache = null;
+    if (issues.length) {
+      logger.warn(`Resource cleanup finished with ${issues.length} issue(s)`);
+    }
+  }
+};
+
+// src/connectors/http.ts
+var HttpConnector = class extends BaseConnector {
+  static {
+    __name(this, "HttpConnector");
+  }
+  baseUrl;
+  headers;
+  timeout;
+  sseReadTimeout;
+  clientInfo;
+  preferSse;
+  transportType = null;
+  constructor(baseUrl, opts = {}) {
+    super(opts);
+    this.baseUrl = baseUrl.replace(/\/$/, "");
+    this.headers = { ...opts.headers ?? {} };
+    if (opts.authToken) {
+      this.headers.Authorization = `Bearer ${opts.authToken}`;
+    }
+    this.timeout = opts.timeout ?? 3e4;
+    this.sseReadTimeout = opts.sseReadTimeout ?? 3e5;
+    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). */
+  async connect() {
+    if (this.connected) {
+      logger.debug("Already connected to MCP implementation");
+      return;
+    }
+    const baseUrl = this.baseUrl;
+    if (this.preferSse) {
+      logger.debug(`Connecting to MCP implementation via HTTP/SSE: ${baseUrl}`);
+      await this.connectWithSse(baseUrl);
+      return;
+    }
+    logger.debug(`Connecting to MCP implementation via HTTP: ${baseUrl}`);
+    try {
+      logger.info("\u{1F504} Attempting streamable HTTP transport...");
+      await this.connectWithStreamableHttp(baseUrl);
+      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}`);
+        } else if (err.code === 404 || err.code === 405) {
+          fallbackReason = `Server returned ${err.code} - server likely doesn't support streamable HTTP`;
+          logger.debug(fallbackReason);
+        } else {
+          fallbackReason = `Server returned ${err.code}: ${err.message}`;
+          logger.debug(fallbackReason);
+        }
+      } 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}`);
+        } else if (errorStr.includes("405 Method Not Allowed") || errorStr.includes("404 Not Found")) {
+          fallbackReason = "Server doesn't support streamable HTTP (405/404)";
+          logger.debug(fallbackReason);
+        } else {
+          fallbackReason = `Streamable HTTP failed: ${err.message}`;
+          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);
+      } catch (sseErr) {
+        logger.error(`Failed to connect with both transports:`);
+        logger.error(`  Streamable HTTP: ${fallbackReason}`);
+        logger.error(`  SSE: ${sseErr}`);
+        await this.cleanupResources();
+        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,
+        {
+          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 {
+        await this.client.connect(transport);
+      } catch (connectErr) {
+        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}`);
+            wrappedError.cause = connectErr;
+            throw wrappedError;
+          }
+        }
+        throw connectErr;
+      }
+      this.connected = true;
+      this.transportType = "streamable-http";
+      logger.debug(`Successfully connected to MCP implementation via streamable HTTP: ${baseUrl}`);
+    } catch (err) {
+      await this.cleanupResources();
+      throw err;
+    }
+  }
+  async connectWithSse(baseUrl) {
+    try {
+      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}`);
+    } catch (err) {
+      await this.cleanupResources();
+      throw err;
+    }
+  }
+  get publicIdentifier() {
+    return {
+      type: "http",
+      url: this.baseUrl,
+      transport: this.transportType || "unknown"
+    };
+  }
+  /**
+   * Get the transport type being used (streamable-http or sse)
+   */
+  getTransportType() {
+    return this.transportType;
+  }
+};
+
+// src/connectors/websocket.ts
+var import_uuid = require("uuid");
+
+// src/task_managers/websocket.ts
+var import_ws = __toESM(require("ws"), 1);
+var WebSocketConnectionManager = class extends ConnectionManager {
+  static {
+    __name(this, "WebSocketConnectionManager");
+  }
+  url;
+  headers;
+  _ws = null;
+  /**
+   * @param url     The WebSocket URL to connect to.
+   * @param headers Optional headers to include in the connection handshake.
+   */
+  constructor(url, headers = {}) {
+    super();
+    this.url = url;
+    this.headers = headers;
+  }
+  /** Establish a WebSocket connection and wait until it is open. */
+  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 });
+      this._ws = ws;
+      const onOpen = /* @__PURE__ */ __name(() => {
+        cleanup();
+        logger.debug("WebSocket connected successfully");
+        resolve(ws);
+      }, "onOpen");
+      const onError = /* @__PURE__ */ __name((err) => {
+        cleanup();
+        logger.error(`Failed to connect to WebSocket: ${err}`);
+        reject(err);
+      }, "onError");
+      const cleanup = /* @__PURE__ */ __name(() => {
+        ws.off("open", onOpen);
+        ws.off("error", onError);
+      }, "cleanup");
+      ws.on("open", onOpen);
+      ws.on("error", onError);
+    });
+  }
+  /** Cleanly close the WebSocket connection. */
+  async closeConnection(connection) {
+    logger.debug("Closing WebSocket connection");
+    return new Promise((resolve) => {
+      const onClose = /* @__PURE__ */ __name(() => {
+        connection.off("close", onClose);
+        this._ws = null;
+        resolve();
+      }, "onClose");
+      if (connection.readyState === import_ws.default.CLOSED) {
+        onClose();
+        return;
+      }
+      connection.on("close", onClose);
+      try {
+        connection.close();
+      } catch (e) {
+        logger.warn(`Error closing WebSocket connection: ${e}`);
+        onClose();
+      }
+    });
+  }
+};
+
+// src/connectors/websocket.ts
+var WebSocketConnector = class extends BaseConnector {
+  static {
+    __name(this, "WebSocketConnector");
+  }
+  url;
+  headers;
+  connectionManager = null;
+  ws = null;
+  receiverTask = null;
+  pending = /* @__PURE__ */ new Map();
+  toolsCache = null;
+  constructor(url, opts = {}) {
+    super();
+    this.url = url;
+    this.headers = { ...opts.headers ?? {} };
+    if (opts.authToken)
+      this.headers.Authorization = `Bearer ${opts.authToken}`;
+  }
+  async connect() {
+    if (this.connected) {
+      logger.debug("Already connected to MCP implementation");
+      return;
+    }
+    logger.debug(`Connecting via WebSocket: ${this.url}`);
+    try {
+      this.connectionManager = new WebSocketConnectionManager(this.url, this.headers);
+      this.ws = await this.connectionManager.start();
+      this.receiverTask = this.receiveLoop();
+      this.connected = true;
+      logger.debug("WebSocket connected successfully");
+    } catch (e) {
+      logger.error(`Failed to connect: ${e}`);
+      await this.cleanupResources();
+      throw e;
+    }
+  }
+  async disconnect() {
+    if (!this.connected) {
+      logger.debug("Not connected to MCP implementation");
+      return;
+    }
+    logger.debug("Disconnecting \u2026");
+    await this.cleanupResources();
+    this.connected = false;
+  }
+  sendRequest(method, params = null) {
+    if (!this.ws)
+      throw new Error("WebSocket is not connected");
+    const id = (0, import_uuid.v4)();
+    const payload = JSON.stringify({ id, method, params: params ?? {} });
+    return new Promise((resolve, reject) => {
+      this.pending.set(id, { resolve, reject });
+      this.ws.send(payload, (err) => {
+        if (err) {
+          this.pending.delete(id);
+          reject(err);
+        }
+      });
+    });
+  }
+  async receiveLoop() {
+    if (!this.ws)
+      return;
+    const socket = this.ws;
+    const onMessage = /* @__PURE__ */ __name((msg) => {
+      let data;
+      try {
+        data = JSON.parse(msg.data ?? msg);
+      } catch (e) {
+        logger.warn("Received non\u2011JSON frame", e);
+        return;
+      }
+      const id = data.id;
+      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);
+      } else {
+        logger.debug("Received unsolicited message", data);
+      }
+    }, "onMessage");
+    if (socket.addEventListener) {
+      socket.addEventListener("message", onMessage);
+    } else {
+      socket.on("message", onMessage);
+    }
+    return new Promise((resolve) => {
+      const onClose = /* @__PURE__ */ __name(() => {
+        if (socket.removeEventListener) {
+          socket.removeEventListener("message", onMessage);
+        } else {
+          socket.off("message", onMessage);
+        }
+        this.rejectAll(new Error("WebSocket closed"));
+        resolve();
+      }, "onClose");
+      if (socket.addEventListener) {
+        socket.addEventListener("close", onClose);
+      } else {
+        socket.on("close", onClose);
+      }
+    });
+  }
+  rejectAll(err) {
+    for (const { reject } of this.pending.values()) reject(err);
+    this.pending.clear();
+  }
+  async initialize() {
+    logger.debug("Initializing MCP session over WebSocket");
+    const result = await this.sendRequest("initialize");
+    const toolsList = await this.listTools();
+    this.toolsCache = toolsList.map((t) => t);
+    logger.debug(`Initialized with ${this.toolsCache.length} tools`);
+    return result;
+  }
+  async listTools() {
+    const res = await this.sendRequest("tools/list");
+    return res.tools ?? [];
+  }
+  async callTool(name, args) {
+    return await this.sendRequest("tools/call", { name, arguments: args });
+  }
+  async listResources() {
+    const resources = await this.sendRequest("resources/list");
+    return { resources: Array.isArray(resources) ? resources : [] };
+  }
+  async readResource(uri) {
+    const res = await this.sendRequest("resources/read", { uri });
+    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");
+    return this.toolsCache;
+  }
+  async cleanupResources() {
+    if (this.receiverTask)
+      await this.receiverTask.catch(() => {
+      });
+    this.receiverTask = null;
+    this.rejectAll(new Error("WebSocket disconnected"));
+    if (this.connectionManager) {
+      await this.connectionManager.stop();
+      this.connectionManager = null;
+      this.ws = null;
+    }
+    this.toolsCache = null;
+  }
+  get publicIdentifier() {
+    return {
+      type: "websocket",
+      url: this.url
+    };
+  }
+};
+
+// src/session.ts
+var MCPSession = class {
+  static {
+    __name(this, "MCPSession");
+  }
+  connector;
+  autoConnect;
+  constructor(connector, autoConnect = true) {
+    this.connector = connector;
+    this.autoConnect = autoConnect;
+  }
+  async connect() {
+    await this.connector.connect();
+  }
+  async disconnect() {
+    await this.connector.disconnect();
+  }
+  async initialize() {
+    if (!this.isConnected && this.autoConnect) {
+      await this.connect();
+    }
+    await this.connector.initialize();
+  }
+  get isConnected() {
+    return this.connector && this.connector.isClientConnected;
+  }
+};
+
+// src/client/base.ts
+var BaseMCPClient = class {
+  static {
+    __name(this, "BaseMCPClient");
+  }
+  config = {};
+  sessions = {};
+  activeSessions = [];
+  constructor(config) {
+    if (config) {
+      this.config = config;
+    }
+  }
+  static fromDict(_cfg) {
+    throw new Error("fromDict must be implemented by concrete class");
+  }
+  addServer(name, serverConfig) {
+    this.config.mcpServers = this.config.mcpServers || {};
+    this.config.mcpServers[name] = serverConfig;
+  }
+  removeServer(name) {
+    if (this.config.mcpServers?.[name]) {
+      delete this.config.mcpServers[name];
+      this.activeSessions = this.activeSessions.filter((n) => n !== name);
+    }
+  }
+  getServerNames() {
+    return Object.keys(this.config.mcpServers ?? {});
+  }
+  getServerConfig(name) {
+    return this.config.mcpServers?.[name];
+  }
+  getConfig() {
+    return this.config ?? {};
+  }
+  async createSession(serverName, autoInitialize = true) {
+    const servers = this.config.mcpServers ?? {};
+    if (Object.keys(servers).length === 0) {
+      logger.warn("No MCP servers defined in config");
+    }
+    if (!servers[serverName]) {
+      throw new Error(`Server '${serverName}' not found in config`);
+    }
+    const connector = this.createConnectorFromConfig(servers[serverName]);
+    const session = new MCPSession(connector);
+    if (autoInitialize) {
+      await session.initialize();
+    }
+    this.sessions[serverName] = session;
+    if (!this.activeSessions.includes(serverName)) {
+      this.activeSessions.push(serverName);
+    }
+    return session;
+  }
+  async createAllSessions(autoInitialize = true) {
+    const servers = this.config.mcpServers ?? {};
+    if (Object.keys(servers).length === 0) {
+      logger.warn("No MCP servers defined in config");
+    }
+    for (const name of Object.keys(servers)) {
+      await this.createSession(name, autoInitialize);
+    }
+    return this.sessions;
+  }
+  getSession(serverName) {
+    const session = this.sessions[serverName];
+    if (!session) {
+      return null;
+    }
+    return session;
+  }
+  getAllActiveSessions() {
+    return Object.fromEntries(
+      this.activeSessions.map((n) => [n, this.sessions[n]])
+    );
+  }
+  async closeSession(serverName) {
+    const session = this.sessions[serverName];
+    if (!session) {
+      logger.warn(`No session exists for server ${serverName}, nothing to close`);
+      return;
+    }
+    try {
+      logger.debug(`Closing session for server ${serverName}`);
+      await session.disconnect();
+    } catch (e) {
+      logger.error(`Error closing session for server '${serverName}': ${e}`);
+    } finally {
+      delete this.sessions[serverName];
+      this.activeSessions = this.activeSessions.filter((n) => n !== serverName);
+    }
+  }
+  async closeAllSessions() {
+    const serverNames = Object.keys(this.sessions);
+    const errors = [];
+    for (const serverName of serverNames) {
+      try {
+        logger.debug(`Closing session for server ${serverName}`);
+        await this.closeSession(serverName);
+      } catch (e) {
+        const errorMsg = `Failed to close session for server '${serverName}': ${e}`;
+        logger.error(errorMsg);
+        errors.push(errorMsg);
+      }
+    }
+    if (errors.length) {
+      logger.error(`Encountered ${errors.length} errors while closing sessions`);
+    } else {
+      logger.debug("All sessions closed successfully");
+    }
+  }
+};
+
+// src/client/browser.ts
+var BrowserMCPClient = class _BrowserMCPClient extends BaseMCPClient {
+  static {
+    __name(this, "BrowserMCPClient");
+  }
+  constructor(config) {
+    super(config);
+  }
+  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/auth/browser-provider.ts
 var import_strict_url_sanitise = require("strict-url-sanitise");
@@ -281,7 +1546,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);
@@ -310,9 +1574,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([]);
@@ -322,14 +1592,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]
   );
@@ -381,187 +1643,60 @@ function useMcp(options) {
       addLog("debug", "BrowserOAuthClientProvider initialized in connect.");
     }
     if (!clientRef.current) {
-      clientRef.current = new import_client.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_streamableHttp.StreamableHTTPClientTransport(targetUrl, commonOptions);
-          addLog("debug", "StreamableHTTPClientTransport created successfully");
-        } else {
-          addLog("debug", "Creating SSEClientTransport...");
-          transportInstance = new import_sse.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");
-        }
-      };
-      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);
+        if (customHeaders && Object.keys(customHeaders).length > 0) {
+          serverConfig.headers = customHeaders;
         }
-        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_auth.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_auth.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");
@@ -613,55 +1748,20 @@ function useMcp(options) {
       }
       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_auth.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_auth.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") {
@@ -692,17 +1792,7 @@ function useMcp(options) {
       try {
         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_auth.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);
@@ -735,75 +1825,93 @@ function useMcp(options) {
       addLog("warn", "Auth provider not initialized, cannot clear storage.");
     }
   }, [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.`);
-    }
-    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 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.`);
       }
-    } catch (err) {
-      addLog("error", `Error listing resources: ${err instanceof Error ? err.message : String(err)}`, err);
-      throw err;
-    }
-  }, [state, addLog]);
+      addLog("info", "Listing resources");
+      try {
+        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", "List resources failed:", err);
+        throw err;
+      }
+    },
+    [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.`);
-    }
-    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 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.`);
       }
-    } catch (err) {
-      addLog("error", `Error listing prompts: ${err instanceof Error ? err.message : String(err)}`, err);
-      throw err;
-    }
-  }, [state, addLog]);
+      addLog("info", "Listing prompts");
+      try {
+        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", "List prompts failed:", err);
+        throw err;
+      }
+    },
+    [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);
@@ -896,9 +2004,10 @@ function useMcp(options) {
     error,
     log,
     authUrl,
+    client: clientRef.current,
     callTool,
-    listResources,
     readResource,
+    listResources,
     listPrompts,
     getPrompt,
     retry,
@@ -910,7 +2019,7 @@ function useMcp(options) {
 __name(useMcp, "useMcp");
 
 // src/auth/callback.ts
-var import_auth2 = require("@modelcontextprotocol/sdk/client/auth.js");
+var import_auth = require("@modelcontextprotocol/sdk/client/auth.js");
 async function onMcpAuthorization() {
   const queryParams = new URLSearchParams(window.location.search);
   const code = queryParams.get("code");
@@ -953,7 +2062,7 @@ async function onMcpAuthorization() {
     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_auth2.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...`);
       if (window.opener && !window.opener.closed) {