mcp-use 1.11.0-canary.9 → 1.11.0

package/dist/src/server/index.cjs

@@ -761,7 +761,7 @@ var VERSION;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    VERSION = "1.11.0-canary.9";
+    VERSION = "1.11.0";
     __name(getPackageVersion, "getPackageVersion");
   }
 });
@@ -775,6 +775,19 @@ var init_utils = __esm({
 });
 
 // src/telemetry/telemetry.ts
+function secureRandomString() {
+  if (typeof window !== "undefined" && window.crypto && typeof window.crypto.getRandomValues === "function") {
+    const array2 = new Uint8Array(8);
+    window.crypto.getRandomValues(array2);
+    return Array.from(array2, (v) => v.toString(16).padStart(2, "0")).join("");
+  }
+  try {
+    const crypto = require("crypto");
+    return crypto.randomBytes(8).toString("hex");
+  } catch (e) {
+    return Math.random().toString(36).substring(2, 15);
+  }
+}
 function detectRuntimeEnvironment() {
   try {
     if (typeof globalThis.Bun !== "undefined") {
@@ -835,6 +848,7 @@ var init_telemetry = __esm({
     init_logging();
     init_events();
     init_utils();
+    __name(secureRandomString, "secureRandomString");
     USER_ID_STORAGE_KEY = "mcp_use_user_id";
     __name(detectRuntimeEnvironment, "detectRuntimeEnvironment");
     __name(getStorageCapability, "getStorageCapability");
@@ -914,12 +928,26 @@ var init_telemetry = __esm({
             "Anonymized telemetry enabled. Set MCP_USE_ANONYMIZED_TELEMETRY=false to disable."
           );
           this._posthogLoading = this._initPostHog();
-          try {
-            this._scarfClient = new ScarfEventLogger(this.SCARF_GATEWAY_URL, 3e3);
-          } catch (e) {
-            logger.warn(`Failed to initialize Scarf telemetry: ${e}`);
+          if (this._runtimeEnvironment !== "browser") {
+            try {
+              this._scarfClient = new ScarfEventLogger(
+                this.SCARF_GATEWAY_URL,
+                3e3
+              );
+            } catch (e) {
+              logger.warn(`Failed to initialize Scarf telemetry: ${e}`);
+              this._scarfClient = null;
+            }
+          } else {
             this._scarfClient = null;
           }
+          if (this._storageCapability === "filesystem" && this._scarfClient) {
+            setTimeout(() => {
+              this.trackPackageDownload({ triggered_by: "initialization" }).catch(
+                (e) => logger.debug(`Failed to track package download: ${e}`)
+              );
+            }, 0);
+          }
         }
       }
       _checkTelemetryDisabled() {
@@ -1044,47 +1072,65 @@ var init_telemetry = __esm({
               break;
             case "session-only":
             default:
-              this._currUserId = `session-${generateUUID()}`;
-              logger.debug(
-                `Using session-based user ID (${this._runtimeEnvironment} environment)`
-              );
+              try {
+                this._currUserId = `session-${generateUUID()}`;
+              } catch (uuidError) {
+                this._currUserId = `session-${Date.now()}-${Math.random().toString(36).substring(2, 15)}`;
+              }
               break;
           }
-          if (this._storageCapability === "filesystem" && this._currUserId) {
-            this._trackPackageDownloadInternal(this._currUserId, {
-              triggered_by: "user_id_property"
-            }).catch((e) => logger.debug(`Failed to track package download: ${e}`));
-          }
         } catch (e) {
-          logger.debug(`Failed to get/create user ID: ${e}`);
           this._currUserId = this.UNKNOWN_USER_ID;
         }
         return this._currUserId;
       }
       /**
        * Get or create user ID from filesystem (Node.js/Bun)
+       * Falls back to session ID if filesystem operations fail
        */
       _getUserIdFromFilesystem() {
-        const fs = require("fs");
-        const os = require("os");
-        const path = require("path");
-        if (!this._userIdPath) {
-          this._userIdPath = path.join(
-            this._getCacheHome(os, path),
-            "mcp_use_3",
-            "telemetry_user_id"
-          );
-        }
-        const isFirstTime = !fs.existsSync(this._userIdPath);
-        if (isFirstTime) {
-          logger.debug(`Creating user ID path: ${this._userIdPath}`);
-          fs.mkdirSync(path.dirname(this._userIdPath), { recursive: true });
-          const newUserId = generateUUID();
-          fs.writeFileSync(this._userIdPath, newUserId);
-          logger.debug(`User ID path created: ${this._userIdPath}`);
-          return newUserId;
+        try {
+          let fs, os, path;
+          try {
+            fs = require("fs");
+            os = require("os");
+            path = require("path");
+          } catch (requireError) {
+            try {
+              const sessionId = `session-${generateUUID()}`;
+              return sessionId;
+            } catch (uuidError) {
+              return `session-${Date.now()}-${Math.random().toString(36).substring(2, 15)}`;
+            }
+          }
+          if (!this._userIdPath) {
+            this._userIdPath = path.join(
+              this._getCacheHome(os, path),
+              "mcp_use_3",
+              "telemetry_user_id"
+            );
+          }
+          const isFirstTime = !fs.existsSync(this._userIdPath);
+          if (isFirstTime) {
+            fs.mkdirSync(path.dirname(this._userIdPath), { recursive: true });
+            let newUserId;
+            try {
+              newUserId = generateUUID();
+            } catch (uuidError) {
+              newUserId = `${Date.now()}-${Math.random().toString(36).substring(2, 15)}`;
+            }
+            fs.writeFileSync(this._userIdPath, newUserId);
+            return newUserId;
+          }
+          const userId = fs.readFileSync(this._userIdPath, "utf-8").trim();
+          return userId;
+        } catch (e) {
+          try {
+            return `session-${generateUUID()}`;
+          } catch (uuidError) {
+            return `session-${Date.now()}-${secureRandomString()}`;
+          }
         }
-        return fs.readFileSync(this._userIdPath, "utf-8").trim();
       }
       /**
        * Get or create user ID from localStorage (Browser)
@@ -1093,14 +1139,22 @@ var init_telemetry = __esm({
         try {
           let userId = localStorage.getItem(USER_ID_STORAGE_KEY);
           if (!userId) {
-            userId = generateUUID();
+            try {
+              userId = generateUUID();
+            } catch (uuidError) {
+              userId = `${Date.now()}-${secureRandomString()}`;
+            }
             localStorage.setItem(USER_ID_STORAGE_KEY, userId);
-            logger.debug(`Created new browser user ID`);
           }
           return userId;
         } catch (e) {
-          logger.debug(`localStorage access failed: ${e}`);
-          return `session-${generateUUID()}`;
+          let sessionId;
+          try {
+            sessionId = `session-${generateUUID()}`;
+          } catch (uuidError) {
+            sessionId = `session-${Date.now()}-${secureRandomString()}`;
+          }
+          return sessionId;
         }
       }
       _getCacheHome(os, path) {
@@ -1129,6 +1183,7 @@ var init_telemetry = __esm({
         if (!this._posthogNodeClient && !this._posthogBrowserClient && !this._scarfClient) {
           return;
         }
+        const currentUserId = this.userId;
         const properties = { ...event.properties };
         properties.mcp_use_version = getPackageVersion();
         properties.language = "typescript";
@@ -1136,9 +1191,8 @@ var init_telemetry = __esm({
         properties.runtime = this._runtimeEnvironment;
         if (this._posthogNodeClient) {
           try {
-            logger.debug(`CAPTURE: PostHog Node Event ${event.name}`);
             this._posthogNodeClient.capture({
-              distinctId: this.userId,
+              distinctId: currentUserId,
               event: event.name,
               properties
             });
@@ -1148,10 +1202,9 @@ var init_telemetry = __esm({
         }
         if (this._posthogBrowserClient) {
           try {
-            logger.debug(`CAPTURE: PostHog Browser Event ${event.name}`);
             this._posthogBrowserClient.capture(event.name, {
               ...properties,
-              distinct_id: this.userId
+              distinct_id: currentUserId
             });
           } catch (e) {
             logger.debug(
@@ -1163,7 +1216,7 @@ var init_telemetry = __esm({
           try {
             const scarfProperties = {
               ...properties,
-              user_id: this.userId,
+              user_id: currentUserId,
               event: event.name
             };
             await this._scarfClient.logEvent(scarfProperties);
@@ -2221,7 +2274,7 @@ module.exports = __toCommonJS(server_exports);
 // src/server/mcp-server.ts
 var import_mcp2 = require("@mcp-use/modelcontextprotocol-sdk/server/mcp.js");
 var import_types2 = require("@mcp-use/modelcontextprotocol-sdk/types.js");
-var import_zod2 = require("zod");
+var import_zod3 = require("zod");
 init_telemetry2();
 init_version();
 
@@ -3705,12 +3758,16 @@ export default PostHog;
       const mod = await viteServer.ssrLoadModule(widget2.entry);
       if (mod.widgetMetadata) {
         metadata = mod.widgetMetadata;
-        if (metadata.inputs) {
+        const schemaField = metadata.props || metadata.inputs;
+        if (schemaField) {
           try {
-            metadata.inputs = metadata.inputs.shape || metadata.inputs;
+            metadata.props = schemaField;
+            if (!metadata.inputs) {
+              metadata.inputs = schemaField;
+            }
           } catch (error2) {
             console.warn(
-              `[WIDGET] Failed to extract props schema for ${widget2.name}:`,
+              `[WIDGET] Failed to extract schema for ${widget2.name}:`,
               error2
             );
           }
@@ -3900,6 +3957,7 @@ function setupWidgetRoutes(app, serverConfig) {
 __name(setupWidgetRoutes, "setupWidgetRoutes");
 
 // src/server/widgets/ui-resource-registration.ts
+var import_zod = __toESM(require("zod"), 1);
 function uiResourceRegistration(server, definition) {
   const displayName = definition.title || definition.name;
   if (definition.type === "appsSdk" && definition._meta) {
@@ -4005,69 +4063,76 @@ function uiResourceRegistration(server, definition) {
         }
       }
     }
-    server.tool(
-      {
-        name: definition.name,
-        title: definition.title,
-        description: definition.description,
-        inputs: convertPropsToInputs(definition.props),
-        annotations: definition.toolAnnotations,
-        _meta: Object.keys(toolMetadata).length > 0 ? toolMetadata : void 0
-      },
-      async (params) => {
-        const uiResource = await createWidgetUIResource(
-          definition,
-          params,
-          serverConfig
+    const widgetMetadata2 = definition._meta?.["mcp-use/widget"];
+    const propsOrSchema = definition.props || widgetMetadata2?.props || widgetMetadata2?.inputs || widgetMetadata2?.schema;
+    const isZodSchema = propsOrSchema && typeof propsOrSchema === "object" && propsOrSchema instanceof import_zod.default.ZodObject;
+    const toolDefinition = {
+      name: definition.name,
+      title: definition.title,
+      description: definition.description,
+      annotations: definition.toolAnnotations,
+      _meta: Object.keys(toolMetadata).length > 0 ? toolMetadata : void 0
+    };
+    if (isZodSchema) {
+      toolDefinition.schema = propsOrSchema;
+    } else if (propsOrSchema) {
+      toolDefinition.inputs = convertPropsToInputs(
+        propsOrSchema
+      );
+    }
+    server.tool(toolDefinition, async (params) => {
+      const uiResource = await createWidgetUIResource(
+        definition,
+        params,
+        serverConfig
+      );
+      if (definition.type === "appsSdk") {
+        const randomId = Math.random().toString(36).substring(2, 15);
+        const uniqueUri = generateWidgetUri(
+          definition.name,
+          server.buildId,
+          ".html",
+          randomId
         );
-        if (definition.type === "appsSdk") {
-          const randomId = Math.random().toString(36).substring(2, 15);
-          const uniqueUri = generateWidgetUri(
-            definition.name,
-            server.buildId,
-            ".html",
-            randomId
-          );
-          const uniqueToolMetadata = {
-            ...toolMetadata,
-            "openai/outputTemplate": uniqueUri,
-            "mcp-use/props": params
-            // Pass params as widget props
-          };
-          let toolOutputResult;
-          if (definition.toolOutput) {
-            toolOutputResult = typeof definition.toolOutput === "function" ? definition.toolOutput(params) : definition.toolOutput;
-          } else {
-            toolOutputResult = {
-              content: [
-                {
-                  type: "text",
-                  text: `Displaying ${displayName}`
-                }
-              ]
-            };
-          }
-          const content = toolOutputResult.content || [
-            { type: "text", text: `Displaying ${displayName}` }
-          ];
-          return {
-            _meta: uniqueToolMetadata,
-            content,
-            structuredContent: toolOutputResult.structuredContent
+        const uniqueToolMetadata = {
+          ...toolMetadata,
+          "openai/outputTemplate": uniqueUri,
+          "mcp-use/props": params
+          // Pass params as widget props
+        };
+        let toolOutputResult;
+        if (definition.toolOutput) {
+          toolOutputResult = typeof definition.toolOutput === "function" ? definition.toolOutput(params) : definition.toolOutput;
+        } else {
+          toolOutputResult = {
+            content: [
+              {
+                type: "text",
+                text: `Displaying ${displayName}`
+              }
+            ]
           };
         }
+        const content = toolOutputResult.content || [
+          { type: "text", text: `Displaying ${displayName}` }
+        ];
         return {
-          content: [
-            {
-              type: "text",
-              text: `Displaying ${displayName}`,
-              description: `Show MCP-UI widget for ${displayName}`
-            },
-            uiResource
-          ]
+          _meta: uniqueToolMetadata,
+          content,
+          structuredContent: toolOutputResult.structuredContent
         };
       }
-    );
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Displaying ${displayName}`,
+            description: `Show MCP-UI widget for ${displayName}`
+          },
+          uiResource
+        ]
+      };
+    });
   }
   return server;
 }
@@ -4129,9 +4194,9 @@ async function mountInspectorUI(app, serverHost, serverPort, isProduction) {
 __name(mountInspectorUI, "mountInspectorUI");
 
 // src/server/tools/schema-helpers.ts
-var import_zod = require("zod");
+var import_zod2 = require("zod");
 function convertZodSchemaToParams(zodSchema) {
-  if (!(zodSchema instanceof import_zod.z.ZodObject)) {
+  if (!(zodSchema instanceof import_zod2.z.ZodObject)) {
     throw new Error("schema must be a Zod object schema (z.object({...}))");
   }
   const shape = zodSchema.shape;
@@ -4148,22 +4213,22 @@ function createParamsSchema(inputs) {
     let zodType;
     switch (input.type) {
       case "string":
-        zodType = import_zod.z.string();
+        zodType = import_zod2.z.string();
         break;
       case "number":
-        zodType = import_zod.z.number();
+        zodType = import_zod2.z.number();
         break;
       case "boolean":
-        zodType = import_zod.z.boolean();
+        zodType = import_zod2.z.boolean();
         break;
       case "object":
-        zodType = import_zod.z.object({});
+        zodType = import_zod2.z.object({});
         break;
       case "array":
-        zodType = import_zod.z.array(import_zod.z.any());
+        zodType = import_zod2.z.array(import_zod2.z.any());
         break;
       default:
-        zodType = import_zod.z.any();
+        zodType = import_zod2.z.any();
     }
     if (input.description) {
       zodType = zodType.describe(input.description);
@@ -6663,7 +6728,7 @@ var MCPServerClass = class {
       );
     }
     newServer.server.setRequestHandler(
-      import_zod2.z.object({ method: import_zod2.z.literal("logging/setLevel") }).passthrough(),
+      import_zod3.z.object({ method: import_zod3.z.literal("logging/setLevel") }).passthrough(),
       (async (request, extra) => {
         const level = request.params?.level;
         if (!level) {