mcp-use 1.7.2 → 1.8.0-canary.0

package/dist/src/server/index.cjs

@@ -1148,39 +1148,45 @@ function createAppsSdkResource(uri, htmlTemplate, metadata) {
   };
 }
 __name(createAppsSdkResource, "createAppsSdkResource");
-function createUIResourceFromDefinition(definition, params, config) {
+async function createUIResourceFromDefinition(definition, params, config) {
   const buildIdPart = config.buildId ? `-${config.buildId}` : "";
   const uri = definition.type === "appsSdk" ? `ui://widget/${definition.name}${buildIdPart}.html` : `ui://widget/${definition.name}${buildIdPart}`;
   const encoding = definition.encoding || "text";
   switch (definition.type) {
     case "externalUrl": {
       const widgetUrl = buildWidgetUrl(definition.widget, params, config);
-      return createExternalUrlResource(
-        uri,
-        widgetUrl,
-        encoding,
-        definition.adapters,
-        definition.appsSdkMetadata
+      return await Promise.resolve(
+        createExternalUrlResource(
+          uri,
+          widgetUrl,
+          encoding,
+          definition.adapters,
+          definition.appsSdkMetadata
+        )
       );
     }
     case "rawHtml": {
-      return createRawHtmlResource(
-        uri,
-        definition.htmlContent,
-        encoding,
-        definition.adapters,
-        definition.appsSdkMetadata
+      return await Promise.resolve(
+        createRawHtmlResource(
+          uri,
+          definition.htmlContent,
+          encoding,
+          definition.adapters,
+          definition.appsSdkMetadata
+        )
       );
     }
     case "remoteDom": {
       const framework = definition.framework || "react";
-      return createRemoteDomResource(
-        uri,
-        definition.script,
-        framework,
-        encoding,
-        definition.adapters,
-        definition.appsSdkMetadata
+      return await Promise.resolve(
+        createRemoteDomResource(
+          uri,
+          definition.script,
+          framework,
+          encoding,
+          definition.adapters,
+          definition.appsSdkMetadata
+        )
       );
     }
     case "appsSdk": {
@@ -1819,7 +1825,32 @@ var McpServer = class {
             }
           }
         }
-        const progressToken = extra?._meta?.progressToken;
+        let progressToken = extra?._meta?.progressToken;
+        let sendNotification = extra?.sendNotification;
+        if (!progressToken || !sendNotification) {
+          let session;
+          if (requestContext) {
+            for (const [, s] of this.sessions.entries()) {
+              if (s.context === requestContext) {
+                session = s;
+                break;
+              }
+            }
+          } else {
+            const firstSession = this.sessions.values().next().value;
+            if (firstSession) {
+              session = firstSession;
+            }
+          }
+          if (session) {
+            if (!progressToken && session.progressToken) {
+              progressToken = session.progressToken;
+            }
+            if (!sendNotification && session.sendNotification) {
+              sendNotification = session.sendNotification;
+            }
+          }
+        }
         const enhancedContext = requestContext ? Object.create(requestContext) : {};
         enhancedContext.sample = async (sampleParams, options) => {
           const {
@@ -1830,7 +1861,7 @@ var McpServer = class {
           let progressCount = 0;
           let completed = false;
           let progressInterval = null;
-          if (progressToken && extra?.sendNotification) {
+          if (progressToken && sendNotification) {
             progressInterval = setInterval(async () => {
               if (completed) return;
               progressCount++;
@@ -1846,21 +1877,26 @@ var McpServer = class {
                 }
               }
               try {
-                await extra.sendNotification({
-                  method: "notifications/progress",
-                  params: {
-                    progressToken,
-                    progress: progressData.progress,
-                    total: progressData.total,
-                    message: progressData.message
-                  }
-                });
+                if (sendNotification) {
+                  await sendNotification({
+                    method: "notifications/progress",
+                    params: {
+                      progressToken,
+                      progress: progressData.progress,
+                      total: progressData.total,
+                      message: progressData.message
+                    }
+                  });
+                }
               } catch {
               }
             }, progressIntervalMs);
           }
           try {
-            const samplePromise = this.createMessage(sampleParams);
+            const sdkTimeout = timeout && timeout !== Infinity ? timeout : 2147483647;
+            const samplePromise = this.createMessage(sampleParams, {
+              timeout: sdkTimeout
+            });
             if (timeout && timeout !== Infinity) {
               const timeoutPromise = new Promise((_, reject) => {
                 setTimeout(
@@ -1878,16 +1914,18 @@ var McpServer = class {
             }
           }
         };
-        enhancedContext.reportProgress = progressToken && extra?.sendNotification ? async (progress, total, message) => {
-          await extra.sendNotification({
-            method: "notifications/progress",
-            params: {
-              progressToken,
-              progress,
-              total,
-              message
-            }
-          });
+        enhancedContext.reportProgress = progressToken && sendNotification ? async (progress, total, message) => {
+          if (sendNotification) {
+            await sendNotification({
+              method: "notifications/progress",
+              params: {
+                progressToken,
+                progress,
+                total,
+                message
+              }
+            });
+          }
         } : void 0;
         const executeCallback = /* @__PURE__ */ __name(async () => {
           if (actualCallback.length >= 2) {
@@ -1992,7 +2030,6 @@ var McpServer = class {
    * ```
    */
   async createMessage(params, options) {
-    console.log("createMessage", params, options);
     return await this.server.server.createMessage(params, options);
   }
   /**
@@ -2098,7 +2135,10 @@ var McpServer = class {
       annotations: definition.annotations,
       readCallback: /* @__PURE__ */ __name(async () => {
         const params = definition.type === "externalUrl" ? this.applyDefaultProps(definition.props) : {};
-        const uiResource = this.createWidgetUIResource(definition, params);
+        const uiResource = await this.createWidgetUIResource(
+          definition,
+          params
+        );
         uiResource.resource.uri = resourceUri;
         return {
           contents: [uiResource.resource]
@@ -2121,7 +2161,7 @@ var McpServer = class {
         description: definition.description,
         annotations: definition.annotations,
         readCallback: /* @__PURE__ */ __name(async (uri, params) => {
-          const uiResource = this.createWidgetUIResource(definition, {});
+          const uiResource = await this.createWidgetUIResource(definition, {});
           uiResource.resource.uri = uri.toString();
           return {
             contents: [uiResource.resource]
@@ -2151,7 +2191,10 @@ var McpServer = class {
       inputs: this.convertPropsToInputs(definition.props),
       _meta: Object.keys(toolMetadata).length > 0 ? toolMetadata : void 0,
       cb: /* @__PURE__ */ __name(async (params) => {
-        const uiResource = this.createWidgetUIResource(definition, params);
+        const uiResource = await this.createWidgetUIResource(
+          definition,
+          params
+        );
         if (definition.type === "appsSdk") {
           const randomId = Math.random().toString(36).substring(2, 15);
           const uniqueUri = this.generateWidgetUri(
@@ -2201,7 +2244,7 @@ var McpServer = class {
    * @param params - Parameters to pass to the widget via URL
    * @returns UIResource object compatible with MCP-UI
    */
-  createWidgetUIResource(definition, params) {
+  async createWidgetUIResource(definition, params) {
     let configBaseUrl = `http://${this.serverHost}`;
     let configPort = this.serverPort || 3001;
     if (this.serverBaseUrl) {
@@ -2218,7 +2261,7 @@ var McpServer = class {
       port: configPort,
       buildId: this.buildId
     };
-    const uiResource = createUIResourceFromDefinition(
+    const uiResource = await createUIResourceFromDefinition(
       definition,
       params,
       urlConfig
@@ -2822,7 +2865,15 @@ if (container && Component) {
         html = await fsHelpers.readFileSync(indexPath, "utf8");
         const mcpUrl = this.getServerBaseUrl();
         if (mcpUrl && html) {
-          const htmlWithoutComments = html.replace(/<!--[\s\S]*?-->/g, "");
+          let htmlWithoutComments = html;
+          let prevHtmlWithoutComments;
+          do {
+            prevHtmlWithoutComments = htmlWithoutComments;
+            htmlWithoutComments = htmlWithoutComments.replace(
+              /<!--[\s\S]*?-->/g,
+              ""
+            );
+          } while (prevHtmlWithoutComments !== htmlWithoutComments);
           const baseTagRegex = /<base\s+[^>]*\/?>/i;
           if (baseTagRegex.test(htmlWithoutComments)) {
             const actualBaseTagMatch = html.match(/<base\s+[^>]*\/?>/i);
@@ -2994,7 +3045,8 @@ if (container && Component) {
       const { allowedOrigins, enableDnsRebindingProtection } = getTransportConfig();
       const transport = new StreamableHTTPServerTransport({
         sessionIdGenerator: /* @__PURE__ */ __name(() => generateUUID(), "sessionIdGenerator"),
-        enableJsonResponse: true,
+        enableJsonResponse: false,
+        // Allow SSE streaming for progress notifications
         allowedOrigins,
         enableDnsRebindingProtection,
         onsessioninitialized: /* @__PURE__ */ __name((id) => {
@@ -3019,7 +3071,8 @@ if (container && Component) {
       const transport = new StreamableHTTPServerTransport({
         sessionIdGenerator: /* @__PURE__ */ __name(() => oldSessionId, "sessionIdGenerator"),
         // Reuse old session ID!
-        enableJsonResponse: true,
+        enableJsonResponse: false,
+        // Allow SSE streaming for progress notifications
         allowedOrigins,
         enableDnsRebindingProtection,
         // We'll manually store the session, so don't rely on onsessioninitialized
@@ -3132,6 +3185,13 @@ if (container && Component) {
       const headers = {};
       let ended = false;
       let headersSent = false;
+      let isSSEStream = false;
+      let streamWriter = null;
+      let streamingResponse = null;
+      let sseStreamReady = null;
+      const sseStreamPromise = new Promise((resolve) => {
+        sseStreamReady = resolve;
+      });
       const expressReq = {
         ...req,
         url: new URL(req.url).pathname + new URL(req.url).search,
@@ -3154,14 +3214,33 @@ if (container && Component) {
         }, "status"),
         setHeader: /* @__PURE__ */ __name((name, value) => {
           if (!headersSent) {
-            headers[name] = Array.isArray(value) ? value.join(", ") : value;
+            headers[name.toLowerCase()] = Array.isArray(value) ? value.join(", ") : value;
+            if (name.toLowerCase() === "content-type" && (Array.isArray(value) ? value.join(", ") : value).includes(
+              "text/event-stream"
+            )) {
+              isSSEStream = true;
+              const { readable, writable } = new globalThis.TransformStream();
+              streamWriter = writable.getWriter();
+              streamingResponse = new Response(readable, {
+                status: statusCode,
+                headers
+              });
+              if (sseStreamReady) {
+                sseStreamReady(streamingResponse);
+              }
+            }
           }
         }, "setHeader"),
-        getHeader: /* @__PURE__ */ __name((name) => headers[name], "getHeader"),
+        getHeader: /* @__PURE__ */ __name((name) => headers[name.toLowerCase()], "getHeader"),
         write: /* @__PURE__ */ __name((chunk, encoding, callback) => {
-          if (!ended) {
+          if (!ended || isSSEStream) {
             const data = typeof chunk === "string" ? new TextEncoder().encode(chunk) : chunk instanceof Uint8Array ? chunk : Buffer.from(chunk);
-            responseBody.push(data);
+            if (isSSEStream && streamWriter) {
+              streamWriter.write(data).catch(() => {
+              });
+            } else {
+              responseBody.push(data);
+            }
           }
           if (typeof encoding === "function") {
             encoding();
@@ -3173,9 +3252,16 @@ if (container && Component) {
         end: /* @__PURE__ */ __name((chunk, encoding, callback) => {
           if (chunk && !ended) {
             const data = typeof chunk === "string" ? new TextEncoder().encode(chunk) : chunk instanceof Uint8Array ? chunk : Buffer.from(chunk);
-            responseBody.push(data);
+            if (isSSEStream && streamWriter) {
+              streamWriter.write(data).catch(() => {
+              });
+            } else {
+              responseBody.push(data);
+            }
+          }
+          if (!isSSEStream) {
+            ended = true;
           }
-          ended = true;
           if (typeof encoding === "function") {
             encoding();
           } else if (callback) {
@@ -3196,7 +3282,28 @@ if (container && Component) {
           expressRes.statusCode = code;
           headersSent = true;
           if (_headers) {
-            Object.assign(headers, _headers);
+            if (Array.isArray(_headers)) {
+              for (const [name, value] of _headers) {
+                headers[name.toLowerCase()] = value;
+              }
+            } else {
+              for (const [key, value] of Object.entries(_headers)) {
+                headers[key.toLowerCase()] = value;
+              }
+            }
+            const contentType = headers["content-type"];
+            if (contentType && contentType.includes("text/event-stream")) {
+              isSSEStream = true;
+              const { readable, writable } = new globalThis.TransformStream();
+              streamWriter = writable.getWriter();
+              streamingResponse = new Response(readable, {
+                status: statusCode,
+                headers
+              });
+              if (sseStreamReady) {
+                sseStreamReady(streamingResponse);
+              }
+            }
           }
           return expressRes;
         }, "writeHead"),
@@ -3214,6 +3321,9 @@ if (container && Component) {
         expressReq,
         expressRes,
         getResponse: /* @__PURE__ */ __name(() => {
+          if (isSSEStream && streamingResponse) {
+            return streamingResponse;
+          }
           if (ended) {
             if (responseBody.length > 0) {
               const body = isDeno2 ? Buffer.concat(responseBody) : Buffer.concat(responseBody);
@@ -3229,12 +3339,20 @@ if (container && Component) {
             }
           }
           return null;
-        }, "getResponse")
+        }, "getResponse"),
+        isSSEStream: /* @__PURE__ */ __name(() => isSSEStream, "isSSEStream"),
+        waitForSSEStream: /* @__PURE__ */ __name(() => sseStreamPromise, "waitForSSEStream")
       };
     }, "createExpressLikeObjects");
     const mountEndpoint = /* @__PURE__ */ __name((endpoint) => {
       this.app.post(endpoint, async (c) => {
-        const { expressReq, expressRes, getResponse } = createExpressLikeObjects(c);
+        const {
+          expressReq,
+          expressRes,
+          getResponse,
+          isSSEStream,
+          waitForSSEStream
+        } = createExpressLikeObjects(c);
         let body = {};
         try {
           body = await c.req.json();
@@ -3277,20 +3395,82 @@ if (container && Component) {
           const session = this.sessions.get(sessionId);
           session.lastAccessedAt = Date.now();
           session.context = c;
+          session.honoContext = c;
+          session.expressRes = expressRes;
+          if (body?.method === "tools/call" && body?.params?._meta?.progressToken) {
+            session.progressToken = body.params._meta.progressToken;
+            console.log(
+              `Received progressToken ${session.progressToken} for tool call: ${body.params?.name}`
+            );
+          } else {
+            session.progressToken = void 0;
+            if (body?.method === "tools/call") {
+              console.log(
+                `No progressToken in tool call request: ${body.params?.name}`
+              );
+            }
+          }
         }
         if (expressRes._closeHandler) {
           c.req.raw.signal?.addEventListener("abort", () => {
             transport.close();
           });
         }
+        let streamingResponse = null;
+        let shouldReturnStream = false;
         await runWithContext(c, async () => {
-          await this.waitForRequestComplete(
-            transport,
+          const handleRequestPromise = transport.handleRequest(
             expressReq,
             expressRes,
             expressReq.body
           );
+          try {
+            const sseStream = await Promise.race([
+              waitForSSEStream(),
+              new Promise((resolve) => {
+                setTimeout(() => resolve(null), 50);
+              })
+            ]);
+            if (sseStream) {
+              streamingResponse = sseStream;
+              shouldReturnStream = true;
+              handleRequestPromise.catch((err) => {
+              });
+              return;
+            } else {
+              if (isSSEStream()) {
+                const response2 = getResponse();
+                if (response2) {
+                  streamingResponse = response2;
+                  shouldReturnStream = true;
+                  handleRequestPromise.catch(() => {
+                  });
+                  return;
+                }
+              }
+            }
+          } catch {
+          }
+          await new Promise((resolve) => {
+            const originalEnd = expressRes.end;
+            let ended = false;
+            expressRes.end = (...args) => {
+              if (!ended) {
+                originalEnd.apply(expressRes, args);
+                ended = true;
+                resolve();
+              }
+            };
+            handleRequestPromise.finally(() => {
+              if (!ended) {
+                expressRes.end();
+              }
+            });
+          });
         });
+        if (shouldReturnStream && streamingResponse) {
+          return streamingResponse;
+        }
         const response = getResponse();
         if (response) {
           return response;