mcp-use 1.9.1-canary.0 → 1.10.0-canary.10

package/dist/{chunk-D22NUQTL.js → chunk-BFSVTG6G.js}

@@ -1,12 +1,13 @@
 import {
   BaseConnector
-} from "./chunk-ZQUCGISK.js";
+} from "./chunk-PL645KUX.js";
+import {
+  generateUUID,
+  getPackageVersion
+} from "./chunk-6EYDSXO6.js";
 import {
   logger
 } from "./chunk-34R6SIER.js";
-import {
-  generateUUID
-} from "./chunk-MTHLLDCX.js";
 import {
   __name
 } from "./chunk-3GQAWCBQ.js";
@@ -82,17 +83,201 @@ var MCPSession = class {
   getRoots() {
     return this.connector.getRoots();
   }
+  /**
+   * Get the cached list of tools from the server.
+   *
+   * @returns Array of available tools
+   *
+   * @example
+   * ```typescript
+   * const tools = session.tools;
+   * console.log(`Available tools: ${tools.map(t => t.name).join(", ")}`);
+   * ```
+   */
+  get tools() {
+    return this.connector.tools;
+  }
+  /**
+   * Get the server capabilities advertised during initialization.
+   *
+   * @returns Server capabilities object
+   */
+  get serverCapabilities() {
+    return this.connector.serverCapabilities;
+  }
+  /**
+   * Get the server information (name and version).
+   *
+   * @returns Server info object or null if not available
+   */
+  get serverInfo() {
+    return this.connector.serverInfo;
+  }
+  /**
+   * Call a tool on the server.
+   *
+   * @param name - Name of the tool to call
+   * @param args - Arguments to pass to the tool
+   * @param options - Optional request options (timeout, progress handlers, etc.)
+   * @returns Result from the tool execution
+   *
+   * @example
+   * ```typescript
+   * const result = await session.callTool("add", { a: 5, b: 3 });
+   * console.log(`Result: ${result.content[0].text}`);
+   * ```
+   */
+  async callTool(name, args, options) {
+    return this.connector.callTool(name, args, options);
+  }
+  /**
+   * 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
+   *
+   * @example
+   * ```typescript
+   * const result = await session.listResources();
+   * console.log(`Found ${result.resources.length} resources`);
+   * ```
+   */
+  async listResources(cursor, options) {
+    return this.connector.listResources(cursor, options);
+  }
+  /**
+   * List all resources from the server, automatically handling pagination.
+   *
+   * @param options - Request options
+   * @returns Complete list of all resources
+   *
+   * @example
+   * ```typescript
+   * const result = await session.listAllResources();
+   * console.log(`Total resources: ${result.resources.length}`);
+   * ```
+   */
+  async listAllResources(options) {
+    return this.connector.listAllResources(options);
+  }
+  /**
+   * List resource templates from the server.
+   *
+   * @param options - Request options
+   * @returns List of available resource templates
+   *
+   * @example
+   * ```typescript
+   * const result = await session.listResourceTemplates();
+   * console.log(`Available templates: ${result.resourceTemplates.length}`);
+   * ```
+   */
+  async listResourceTemplates(options) {
+    return this.connector.listResourceTemplates(options);
+  }
+  /**
+   * Read a resource by URI.
+   *
+   * @param uri - URI of the resource to read
+   * @param options - Request options
+   * @returns Resource content
+   *
+   * @example
+   * ```typescript
+   * const resource = await session.readResource("file:///path/to/file.txt");
+   * console.log(resource.contents);
+   * ```
+   */
+  async readResource(uri, options) {
+    return this.connector.readResource(uri, options);
+  }
+  /**
+   * Subscribe to resource updates.
+   *
+   * @param uri - URI of the resource to subscribe to
+   * @param options - Request options
+   *
+   * @example
+   * ```typescript
+   * await session.subscribeToResource("file:///path/to/file.txt");
+   * // Now you'll receive notifications when this resource changes
+   * ```
+   */
+  async subscribeToResource(uri, options) {
+    return this.connector.subscribeToResource(uri, options);
+  }
+  /**
+   * Unsubscribe from resource updates.
+   *
+   * @param uri - URI of the resource to unsubscribe from
+   * @param options - Request options
+   *
+   * @example
+   * ```typescript
+   * await session.unsubscribeFromResource("file:///path/to/file.txt");
+   * ```
+   */
+  async unsubscribeFromResource(uri, options) {
+    return this.connector.unsubscribeFromResource(uri, options);
+  }
+  /**
+   * List available prompts from the server.
+   *
+   * @returns List of available prompts
+   *
+   * @example
+   * ```typescript
+   * const result = await session.listPrompts();
+   * console.log(`Available prompts: ${result.prompts.length}`);
+   * ```
+   */
+  async listPrompts() {
+    return this.connector.listPrompts();
+  }
+  /**
+   * Get a specific prompt with arguments.
+   *
+   * @param name - Name of the prompt to get
+   * @param args - Arguments for the prompt
+   * @returns Prompt result
+   *
+   * @example
+   * ```typescript
+   * const prompt = await session.getPrompt("greeting", { name: "Alice" });
+   * console.log(prompt.messages);
+   * ```
+   */
+  async getPrompt(name, args) {
+    return this.connector.getPrompt(name, args);
+  }
+  /**
+   * Send a raw request through the client.
+   *
+   * @param method - MCP method name
+   * @param params - Request parameters
+   * @param options - Request options
+   * @returns Response from the server
+   *
+   * @example
+   * ```typescript
+   * const result = await session.request("custom/method", { key: "value" });
+   * ```
+   */
+  async request(method, params = null, options) {
+    return this.connector.request(method, params, options);
+  }
 };
 
 // src/connectors/http.ts
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { Client } from "@mcp-use/modelcontextprotocol-sdk/client/index.js";
 import {
   StreamableHTTPClientTransport,
   StreamableHTTPError
-} from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+} from "@mcp-use/modelcontextprotocol-sdk/client/streamableHttp.js";
 
 // src/task_managers/sse.ts
-import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
+import { SSEClientTransport } from "@mcp-use/modelcontextprotocol-sdk/client/sse.js";
 
 // src/task_managers/base.ts
 var ConnectionManager = class {
@@ -303,15 +488,16 @@ var HttpConnector = class extends BaseConnector {
       let fallbackReason = "Unknown error";
       let is401Error = false;
       if (err instanceof StreamableHTTPError) {
-        is401Error = err.code === 401;
-        if (err.code === 400 && err.message.includes("Missing session ID")) {
+        const streamableErr = err;
+        is401Error = streamableErr.code === 401;
+        if (streamableErr.code === 400 && streamableErr.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`;
+        } else if (streamableErr.code === 404 || streamableErr.code === 405) {
+          fallbackReason = `Server returned ${streamableErr.code} - server likely doesn't support streamable HTTP`;
           logger.debug(fallbackReason);
         } else {
-          fallbackReason = `Server returned ${err.code}: ${err.message}`;
+          fallbackReason = `Server returned ${streamableErr.code}: ${streamableErr.message}`;
           logger.debug(fallbackReason);
         }
       } else if (err instanceof Error) {
@@ -451,6 +637,10 @@ var HttpConnector = class extends BaseConnector {
       logger.debug(
         `Successfully connected to MCP implementation via streamable HTTP: ${baseUrl}`
       );
+      this.trackConnectorInit({
+        serverUrl: this.baseUrl,
+        publicIdentifier: `${this.baseUrl} (streamable-http)`
+      });
     } catch (err) {
       await this.cleanupResources();
       throw err;
@@ -498,6 +688,10 @@ var HttpConnector = class extends BaseConnector {
       logger.debug(
         `Successfully connected to MCP implementation via HTTP/SSE: ${baseUrl}`
       );
+      this.trackConnectorInit({
+        serverUrl: this.baseUrl,
+        publicIdentifier: `${this.baseUrl} (sse)`
+      });
     } catch (err) {
       await this.cleanupResources();
       throw err;
@@ -913,6 +1107,13 @@ var BrowserMCPClient = class _BrowserMCPClient extends BaseMCPClient {
   static {
     __name(this, "BrowserMCPClient");
   }
+  /**
+   * Get the mcp-use package version.
+   * Works in all environments (Node.js, browser, Cloudflare Workers, Deno, etc.)
+   */
+  static getPackageVersion() {
+    return getPackageVersion();
+  }
   constructor(config) {
     super(config);
   }

package/dist/{chunk-KHTTBIRP.js → chunk-BPP5XYP6.js}

@@ -2,14 +2,15 @@ import {
   ElicitationValidationError
 } from "./chunk-KUEVOU4M.js";
 import {
+  Telemetry,
   generateUUID
-} from "./chunk-MTHLLDCX.js";
+} from "./chunk-6EYDSXO6.js";
 import {
   __name
 } from "./chunk-3GQAWCBQ.js";
 
 // src/server/tools/tool-execution-helpers.ts
-import { toJsonSchemaCompat } from "@modelcontextprotocol/sdk/server/zod-json-schema-compat.js";
+import { toJsonSchemaCompat } from "@mcp-use/modelcontextprotocol-sdk/server/zod-json-schema-compat.js";
 function findSessionContext(sessions, initialRequestContext, extraProgressToken, extraSendNotification) {
   let requestContext = initialRequestContext;
   let session;
@@ -196,6 +197,9 @@ function createSampleMethod(createMessage, progressToken, sendNotification) {
         `Sampling timed out after ${timeout}ms`
       );
       console.log("[SAMPLING DEBUG] Got result:", result);
+      Telemetry.getInstance().trackServerContext({
+        contextType: "sample"
+      }).catch((e) => console.debug(`Failed to track sample context: ${e}`));
       return result;
     } catch (error) {
       console.error("[SAMPLING DEBUG] Error during sampling:", error);
@@ -219,6 +223,9 @@ function createElicitMethod(elicitInput) {
     const { timeout } = options ?? {};
     const sdkTimeout = timeout && timeout !== Infinity ? timeout : 2147483647;
     const result = await elicitInput(sdkParams, { timeout: sdkTimeout });
+    Telemetry.getInstance().trackServerContext({
+      contextType: "elicit"
+    }).catch((e) => console.debug(`Failed to track elicit context: ${e}`));
     if (zodSchema && result.action === "accept" && result.data) {
       try {
         const validatedData = zodSchema.parse(result.data);
@@ -227,9 +234,10 @@ function createElicitMethod(elicitInput) {
           data: validatedData
         };
       } catch (error) {
+        const err = error;
         throw new ElicitationValidationError(
-          `Elicitation data validation failed: ${error.message}`,
-          error
+          `Elicitation data validation failed: ${err.message}`,
+          err
         );
       }
     }
@@ -252,7 +260,129 @@ function createReportProgressMethod(progressToken, sendNotification) {
   return void 0;
 }
 __name(createReportProgressMethod, "createReportProgressMethod");
-function createEnhancedContext(baseContext, createMessage, elicitInput, progressToken, sendNotification) {
+var LOG_LEVELS = {
+  debug: 0,
+  info: 1,
+  notice: 2,
+  warning: 3,
+  error: 4,
+  critical: 5,
+  alert: 6,
+  emergency: 7
+};
+var VALID_LOG_LEVELS = [
+  "debug",
+  "info",
+  "notice",
+  "warning",
+  "error",
+  "critical",
+  "alert",
+  "emergency"
+];
+function isValidLogLevel(level) {
+  return VALID_LOG_LEVELS.includes(level);
+}
+__name(isValidLogLevel, "isValidLogLevel");
+function shouldLogMessage(messageLevel, minLevel) {
+  if (!minLevel) {
+    return true;
+  }
+  if (!isValidLogLevel(messageLevel) || !isValidLogLevel(minLevel)) {
+    return true;
+  }
+  return LOG_LEVELS[messageLevel] >= LOG_LEVELS[minLevel];
+}
+__name(shouldLogMessage, "shouldLogMessage");
+function createLogMethod(sendNotification, minLogLevel) {
+  if (!sendNotification) {
+    return void 0;
+  }
+  return async (level, message, logger) => {
+    if (!shouldLogMessage(level, minLogLevel)) {
+      return;
+    }
+    await sendNotification({
+      method: "notifications/message",
+      params: {
+        level,
+        data: message,
+        logger: logger || "tool"
+      }
+    });
+    Telemetry.getInstance().trackServerContext({
+      contextType: "notification",
+      notificationType: "message"
+    }).catch(
+      (e) => console.debug(`Failed to track notification context: ${e}`)
+    );
+  };
+}
+__name(createLogMethod, "createLogMethod");
+function createClientCapabilityChecker(clientCapabilities) {
+  const caps = clientCapabilities || {};
+  return {
+    can(capability) {
+      return capability in caps;
+    },
+    capabilities() {
+      return { ...caps };
+    }
+  };
+}
+__name(createClientCapabilityChecker, "createClientCapabilityChecker");
+function createSendNotificationMethod(sessionId, sessions) {
+  if (!sessionId || !sessions) {
+    return void 0;
+  }
+  return async (method, params) => {
+    const session = sessions.get(sessionId);
+    if (!session?.sendNotification) {
+      console.warn(
+        `[MCP] Cannot send notification to session ${sessionId} - no sendNotification function`
+      );
+      return;
+    }
+    try {
+      await session.sendNotification({
+        method,
+        params: params || {}
+      });
+    } catch (error) {
+      console.error(
+        `[MCP] Error sending notification to session ${sessionId}:`,
+        error
+      );
+    }
+  };
+}
+__name(createSendNotificationMethod, "createSendNotificationMethod");
+function createSendNotificationToSessionMethod(sessions) {
+  if (!sessions) {
+    return void 0;
+  }
+  return async (sessionId, method, params) => {
+    const session = sessions.get(sessionId);
+    if (!session?.sendNotification) {
+      return false;
+    }
+    try {
+      await session.sendNotification({
+        method,
+        params: params || {}
+      });
+      return true;
+    } catch (error) {
+      console.error(
+        `[MCP] Error sending notification to session ${sessionId}:`,
+        error
+      );
+      return false;
+    }
+  };
+}
+__name(createSendNotificationToSessionMethod, "createSendNotificationToSessionMethod");
+function createEnhancedContext(baseContext, createMessage, elicitInput, progressToken, sendNotification, minLogLevel, clientCapabilities, sessionId, sessions) {
   const enhancedContext = baseContext ? Object.create(baseContext) : {};
   enhancedContext.sample = createSampleMethod(
     createMessage,
@@ -264,6 +394,24 @@ function createEnhancedContext(baseContext, createMessage, elicitInput, progress
     progressToken,
     sendNotification
   );
+  enhancedContext.log = createLogMethod(sendNotification, minLogLevel);
+  enhancedContext.client = createClientCapabilityChecker(clientCapabilities);
+  if (sessionId) {
+    enhancedContext.session = {
+      sessionId
+    };
+  }
+  const sendNotificationMethod = createSendNotificationMethod(
+    sessionId,
+    sessions
+  );
+  if (sendNotificationMethod) {
+    enhancedContext.sendNotification = sendNotificationMethod;
+  }
+  const sendNotificationToSessionMethod = createSendNotificationToSessionMethod(sessions);
+  if (sendNotificationToSessionMethod) {
+    enhancedContext.sendNotificationToSession = sendNotificationToSessionMethod;
+  }
   return enhancedContext;
 }
 __name(createEnhancedContext, "createEnhancedContext");
@@ -276,5 +424,8 @@ export {
   createSampleMethod,
   createElicitMethod,
   createReportProgressMethod,
+  VALID_LOG_LEVELS,
+  isValidLogLevel,
+  shouldLogMessage,
   createEnhancedContext
 };

package/dist/{chunk-3R5PDYIN.js → chunk-J75I2C26.js}

@@ -261,7 +261,7 @@ var BrowserOAuthClientProvider = class {
 };
 
 // src/auth/callback.ts
-import { auth } from "@modelcontextprotocol/sdk/client/auth.js";
+import { auth } from "@mcp-use/modelcontextprotocol-sdk/client/auth.js";
 async function onMcpAuthorization() {
   const queryParams = new URLSearchParams(window.location.search);
   const code = queryParams.get("code");
@@ -369,16 +369,44 @@ async function onMcpAuthorization() {
       );
     }
     try {
-      document.body.innerHTML = `
-            <div style="font-family: sans-serif; padding: 20px;">
-            <h1>Authentication Error</h1>
-            <p style="color: red; background-color: #ffebeb; border: 1px solid red; padding: 10px; border-radius: 4px;">
-                ${errorMessage}
-            </p>
-            <p>You can close this window or <a href="#" onclick="window.close(); return false;">click here to close</a>.</p>
-            <pre style="font-size: 0.8em; color: #555; margin-top: 20px; white-space: pre-wrap;">${err instanceof Error ? err.stack : ""}</pre>
-            </div>
-        `;
+      document.body.innerHTML = "";
+      const container = document.createElement("div");
+      container.style.fontFamily = "sans-serif";
+      container.style.padding = "20px";
+      const heading = document.createElement("h1");
+      heading.textContent = "Authentication Error";
+      container.appendChild(heading);
+      const errorPara = document.createElement("p");
+      errorPara.style.color = "red";
+      errorPara.style.backgroundColor = "#ffebeb";
+      errorPara.style.border = "1px solid red";
+      errorPara.style.padding = "10px";
+      errorPara.style.borderRadius = "4px";
+      errorPara.textContent = errorMessage;
+      container.appendChild(errorPara);
+      const closePara = document.createElement("p");
+      closePara.textContent = "You can close this window or ";
+      const closeLink = document.createElement("a");
+      closeLink.href = "#";
+      closeLink.textContent = "click here to close";
+      closeLink.onclick = (e) => {
+        e.preventDefault();
+        window.close();
+        return false;
+      };
+      closePara.appendChild(closeLink);
+      closePara.appendChild(document.createTextNode("."));
+      container.appendChild(closePara);
+      if (err instanceof Error && err.stack) {
+        const stackPre = document.createElement("pre");
+        stackPre.style.fontSize = "0.8em";
+        stackPre.style.color = "#555";
+        stackPre.style.marginTop = "20px";
+        stackPre.style.whiteSpace = "pre-wrap";
+        stackPre.textContent = err.stack;
+        container.appendChild(stackPre);
+      }
+      document.body.appendChild(container);
     } catch (displayError) {
       console.error(
         `${logPrefix} Could not display error in callback window:`,

package/dist/{chunk-5URNFWCQ.js → chunk-LWVK6RXA.js}

@@ -5,14 +5,18 @@ import {
 // src/server/context-storage.ts
 import { AsyncLocalStorage } from "async_hooks";
 var requestContextStorage = new AsyncLocalStorage();
-async function runWithContext(context, fn) {
-  return requestContextStorage.run(context, fn);
+async function runWithContext(context, fn, sessionId) {
+  return requestContextStorage.run({ honoContext: context, sessionId }, fn);
 }
 __name(runWithContext, "runWithContext");
 function getRequestContext() {
-  return requestContextStorage.getStore();
+  return requestContextStorage.getStore()?.honoContext;
 }
 __name(getRequestContext, "getRequestContext");
+function getSessionId() {
+  return requestContextStorage.getStore()?.sessionId;
+}
+__name(getSessionId, "getSessionId");
 function hasRequestContext() {
   return requestContextStorage.getStore() !== void 0;
 }
@@ -21,5 +25,6 @@ __name(hasRequestContext, "hasRequestContext");
 export {
   runWithContext,
   getRequestContext,
+  getSessionId,
   hasRequestContext
 };

package/dist/{chunk-MUZ5WYE3.js → chunk-NBSNYHID.js}

@@ -1,10 +1,10 @@
 import {
   BrowserMCPClient
-} from "./chunk-D22NUQTL.js";
+} from "./chunk-BFSVTG6G.js";
 import {
   BrowserOAuthClientProvider,
   sanitizeUrl
-} from "./chunk-3R5PDYIN.js";
+} from "./chunk-J75I2C26.js";
 import {
   __name
 } from "./chunk-3GQAWCBQ.js";
@@ -260,15 +260,16 @@ function useMcp(options) {
         }
         return "success";
       } catch (err) {
-        const errorMessage = err?.message || String(err);
-        if (err.code === 401 || errorMessage.includes("401") || errorMessage.includes("Unauthorized")) {
+        const error2 = err;
+        const errorMessage = error2?.message || String(err);
+        if (error2.code === 401 || errorMessage.includes("401") || errorMessage.includes("Unauthorized")) {
           if (authProviderRef.current) {
             addLog(
               "info",
               "Authentication required. OAuth provider available."
             );
             try {
-              const { auth } = await import("@modelcontextprotocol/sdk/client/auth.js");
+              const { auth } = await import("@mcp-use/modelcontextprotocol-sdk/client/auth.js");
               const baseUrl = new URL(url).origin;
               auth(authProviderRef.current, { serverUrl: baseUrl }).catch(
                 () => {
@@ -309,7 +310,10 @@ function useMcp(options) {
           );
           return "failed";
         }
-        failConnection(errorMessage, err);
+        failConnection(
+          errorMessage,
+          error2 instanceof Error ? error2 : new Error(String(error2))
+        );
         return "failed";
       }
     }, "tryConnectWithTransport");
@@ -433,7 +437,7 @@ function useMcp(options) {
         });
         authProviderRef.current = freshAuthProvider;
         addLog("info", "Triggering fresh OAuth authorization...");
-        const { auth } = await import("@modelcontextprotocol/sdk/client/auth.js");
+        const { auth } = await import("@mcp-use/modelcontextprotocol-sdk/client/auth.js");
         const baseUrl = new URL(url).origin;
         auth(freshAuthProvider, {
           serverUrl: baseUrl
@@ -441,7 +445,7 @@ function useMcp(options) {
           addLog(
             "info",
             "OAuth flow initiated:",
-            err?.message || "Redirecting..."
+            err instanceof Error ? err.message : "Redirecting..."
           );
         });
       } catch (authError) {
@@ -1183,7 +1187,8 @@ function WidgetControls({
       const result = await callTool(toolName, args);
       setActionResult(`Success: ${JSON.stringify(result, null, 2)}`);
     } catch (error) {
-      setActionResult(`Error: ${error.message}`);
+      const err = error;
+      setActionResult(`Error: ${err.message}`);
     }
   }, "handleCallTool");
   const handleSendFollowUpMessage = /* @__PURE__ */ __name(async () => {
@@ -1192,7 +1197,8 @@ function WidgetControls({
       await sendFollowUpMessage(followUpMessage);
       setActionResult("Follow-up message sent successfully");
     } catch (error) {
-      setActionResult(`Error: ${error.message}`);
+      const err = error;
+      setActionResult(`Error: ${err.message}`);
     }
   }, "handleSendFollowUpMessage");
   const handleOpenExternal = /* @__PURE__ */ __name(() => {
@@ -1200,7 +1206,8 @@ function WidgetControls({
       openExternal(externalUrl);
       setActionResult(`Opened external link: ${externalUrl}`);
     } catch (error) {
-      setActionResult(`Error: ${error.message}`);
+      const err = error;
+      setActionResult(`Error: ${err.message}`);
     }
   }, "handleOpenExternal");
   const handleRequestDisplayMode = /* @__PURE__ */ __name(async (mode) => {
@@ -1209,7 +1216,8 @@ function WidgetControls({
       const result = await requestDisplayMode(mode);
       setActionResult(`Display mode granted: ${result.mode}`);
     } catch (error) {
-      setActionResult(`Error: ${error.message}`);
+      const err = error;
+      setActionResult(`Error: ${err.message}`);
     }
   }, "handleRequestDisplayMode");
   const handleSetState = /* @__PURE__ */ __name(async () => {
@@ -1219,7 +1227,8 @@ function WidgetControls({
       await setState(newState);
       setActionResult(`State updated: ${JSON.stringify(newState, null, 2)}`);
     } catch (error) {
-      setActionResult(`Error: ${error.message}`);
+      const err = error;
+      setActionResult(`Error: ${err.message}`);
     }
   }, "handleSetState");
   const handleFullscreen = /* @__PURE__ */ __name(async () => {