mcp-use 1.0.4 → 1.0.6

package/dist/index.cjs

@@ -496,7 +496,6 @@ __export(index_exports, {
   Telemetry: () => Telemetry,
   ToolMessage: () => import_messages3.ToolMessage,
   WebSocketConnector: () => WebSocketConnector,
-  createMCPServer: () => createMCPServer,
   createOAuthMCPConfig: () => createOAuthMCPConfig,
   createReadableStreamFromGenerator: () => createReadableStreamFromGenerator,
   loadConfigFile: () => loadConfigFile,
@@ -2277,7 +2276,8 @@ var MCPAgent = class {
     const startTime = Date.now();
     const toolsUsedNames = [];
     let stepsTaken = 0;
-    let success = false;
+    const structuredOutputSuccess = false;
+    const structuredOutputSuccessRef = { value: structuredOutputSuccess };
     let structuredLlm = null;
     let schemaDescription = "";
     if (outputSchema) {
@@ -2367,28 +2367,26 @@ var MCPAgent = class {
             result = nextStepOutput.returnValues?.output ?? "No output generated";
             runManager?.handleChainEnd({ output: result });
             if (outputSchema && structuredLlm) {
-              try {
-                logger.info("\u{1F527} Attempting structured output...");
-                const structuredResult = await this._attemptStructuredOutput(
-                  result,
-                  structuredLlm,
-                  outputSchema,
-                  schemaDescription
-                );
-                logger.debug(`\u{1F504} Structured result: ${JSON.stringify(structuredResult)}`);
+              logger.info("\u{1F527} Attempting structured output...");
+              const currentResult = result;
+              this._attemptStructuredOutput(
+                currentResult,
+                this.llm,
+                outputSchema
+              ).then((structuredResult) => {
                 if (this.memoryEnabled) {
                   this.addToHistory(new import_messages2.AIMessage(`Structured result: ${JSON.stringify(structuredResult)}`));
                 }
                 logger.info("\u2705 Structured output successful");
-                success = true;
+                structuredOutputSuccessRef.value = true;
                 return structuredResult;
-              } catch (e) {
+              }).catch((e) => {
                 logger.warn(`\u26A0\uFE0F Structured output failed: ${e}`);
                 const failedStructuredOutputPrompt = `
                 The current result cannot be formatted into the required structure.
                 Error: ${String(e)}
                 
-                Current information: ${result}
+                Current information: ${currentResult}
                 
                 If information is missing, please continue working to gather the missing information needed for:
                 ${schemaDescription}
@@ -2400,36 +2398,35 @@ var MCPAgent = class {
                   this.addToHistory(new import_messages2.HumanMessage(failedStructuredOutputPrompt));
                 }
                 logger.info("\u{1F504} Continuing execution to gather missing information...");
-                continue;
-              }
-            } else {
-              break;
+              });
             }
           }
-          const stepArray = nextStepOutput;
-          intermediateSteps.push(...stepArray);
-          for (const step of stepArray) {
-            yield step;
-            const { action, observation } = step;
-            const toolName = action.tool;
-            toolsUsedNames.push(toolName);
-            let toolInputStr = typeof action.toolInput === "string" ? action.toolInput : JSON.stringify(action.toolInput, null, 2);
-            if (toolInputStr.length > 100)
-              toolInputStr = `${toolInputStr.slice(0, 97)}...`;
-            logger.info(`\u{1F527} Tool call: ${toolName} with input: ${toolInputStr}`);
-            let outputStr = String(observation);
-            if (outputStr.length > 100)
-              outputStr = `${outputStr.slice(0, 97)}...`;
-            outputStr = outputStr.replace(/\n/g, " ");
-            logger.info(`\u{1F4C4} Tool result: ${outputStr}`);
-          }
-          if (stepArray.length) {
-            const lastStep = stepArray[stepArray.length - 1];
-            const toolReturn = await this._agentExecutor._getToolReturn(lastStep);
-            if (toolReturn) {
-              logger.info(`\u{1F3C6} Tool returned directly at step ${stepNum + 1}`);
-              result = toolReturn.returnValues?.output ?? "No output generated";
-              break;
+          if (Array.isArray(nextStepOutput)) {
+            const stepArray = nextStepOutput;
+            intermediateSteps.push(...stepArray);
+            for (const step of stepArray) {
+              yield step;
+              const { action, observation } = step;
+              const toolName = action.tool;
+              toolsUsedNames.push(toolName);
+              let toolInputStr = typeof action.toolInput === "string" ? action.toolInput : JSON.stringify(action.toolInput, null, 2);
+              if (toolInputStr.length > 100)
+                toolInputStr = `${toolInputStr.slice(0, 97)}...`;
+              logger.info(`\u{1F527} Tool call: ${toolName} with input: ${toolInputStr}`);
+              let outputStr = String(observation);
+              if (outputStr.length > 100)
+                outputStr = `${outputStr.slice(0, 97)}...`;
+              outputStr = outputStr.replace(/\n/g, " ");
+              logger.info(`\u{1F4C4} Tool result: ${outputStr}`);
+            }
+            if (stepArray.length) {
+              const lastStep = stepArray[stepArray.length - 1];
+              const toolReturn = await this._agentExecutor._getToolReturn(lastStep);
+              if (toolReturn) {
+                logger.info(`\u{1F3C6} Tool returned directly at step ${stepNum + 1}`);
+                result = toolReturn.returnValues?.output ?? "No output generated";
+                break;
+              }
             }
           }
         } catch (e) {
@@ -2452,7 +2449,7 @@ var MCPAgent = class {
         runManager?.handleChainEnd({ output: result });
       }
       logger.info("\u{1F389} Agent execution complete");
-      success = true;
+      structuredOutputSuccessRef.value = true;
       return result;
     } catch (e) {
       logger.error(`\u274C Error running query: ${e}`);
@@ -2473,7 +2470,7 @@ var MCPAgent = class {
       await this.telemetry.trackAgentExecution({
         executionMethod: "stream",
         query,
-        success,
+        success: structuredOutputSuccess,
         modelProvider: this.modelProvider,
         modelName: this.modelName,
         serverCount,
@@ -2491,7 +2488,7 @@ var MCPAgent = class {
         toolsUsedNames,
         response: result,
         executionTimeMs,
-        errorType: success ? null : "execution_error",
+        errorType: structuredOutputSuccess ? null : "execution_error",
         conversationHistoryLength
       });
       if (manageConnector && !this.client && initializedHere) {
@@ -2532,13 +2529,16 @@ var MCPAgent = class {
    * Yields LangChain StreamEvent objects from the underlying streamEvents() method.
    * This provides token-level streaming and fine-grained event updates.
    */
-  async *streamEvents(query, maxSteps, manageConnector = true, externalHistory) {
+  async *streamEvents(query, maxSteps, manageConnector = true, externalHistory, outputSchema) {
     let initializedHere = false;
     const startTime = Date.now();
     let success = false;
     let eventCount = 0;
     let totalResponseLength = 0;
     let finalResponse = "";
+    if (outputSchema) {
+      query = this._enhanceQueryWithSchema(query, outputSchema);
+    }
     try {
       if (manageConnector && !this._initialized) {
         await this.initialize();
@@ -2586,15 +2586,71 @@ var MCPAgent = class {
           totalResponseLength += event.data.chunk.content.length;
         }
         yield event;
-        await new Promise((resolve) => setTimeout(resolve, 0));
         if (event.event === "on_chain_end" && event.data?.output) {
           const output = event.data.output;
           if (Array.isArray(output) && output.length > 0 && output[0]?.text) {
             finalResponse = output[0].text;
+          } else if (typeof output === "string") {
+            finalResponse = output;
+          } else if (output && typeof output === "object" && "output" in output) {
+            finalResponse = output.output;
           }
         }
       }
-      if (this.memoryEnabled && finalResponse) {
+      if (outputSchema && finalResponse) {
+        logger.info("\u{1F527} Attempting structured output conversion...");
+        try {
+          let conversionCompleted = false;
+          let conversionResult = null;
+          let conversionError = null;
+          const _conversionPromise = this._attemptStructuredOutput(
+            finalResponse,
+            this.llm,
+            outputSchema
+          ).then((result) => {
+            conversionCompleted = true;
+            conversionResult = result;
+            return result;
+          }).catch((error) => {
+            conversionCompleted = true;
+            conversionError = error;
+            throw error;
+          });
+          let progressCount = 0;
+          while (!conversionCompleted) {
+            await new Promise((resolve) => setTimeout(resolve, 2e3));
+            if (!conversionCompleted) {
+              progressCount++;
+              yield {
+                event: "on_structured_output_progress",
+                data: {
+                  message: `Converting to structured output... (${progressCount * 2}s)`,
+                  elapsed: progressCount * 2
+                }
+              };
+            }
+          }
+          if (conversionError) {
+            throw conversionError;
+          }
+          if (conversionResult) {
+            yield {
+              event: "on_structured_output",
+              data: { output: conversionResult }
+            };
+            if (this.memoryEnabled) {
+              this.addToHistory(new import_messages2.AIMessage(`Structured result: ${JSON.stringify(conversionResult)}`));
+            }
+            logger.info("\u2705 Structured output successful");
+          }
+        } catch (e) {
+          logger.warn(`\u26A0\uFE0F Structured output failed: ${e}`);
+          yield {
+            event: "on_structured_output_error",
+            data: { error: e instanceof Error ? e.message : String(e) }
+          };
+        }
+      } else if (this.memoryEnabled && finalResponse) {
         this.addToHistory(new import_messages2.AIMessage(finalResponse));
       }
       logger.info(`\u{1F389} StreamEvents complete - ${eventCount} events emitted`);
@@ -2645,10 +2701,21 @@ var MCPAgent = class {
   /**
    * Attempt to create structured output from raw result with validation and retry logic.
    */
-  async _attemptStructuredOutput(rawResult, structuredLlm, outputSchema, schemaDescription) {
+  async _attemptStructuredOutput(rawResult, llm, outputSchema) {
     logger.info(`\u{1F504} Attempting structured output with schema: ${outputSchema}`);
-    logger.info(`\u{1F504} Schema description: ${schemaDescription}`);
     logger.info(`\u{1F504} Raw result: ${JSON.stringify(rawResult, null, 2)}`);
+    let structuredLlm = null;
+    let schemaDescription = "";
+    logger.debug(`\u{1F504} Structured output requested, schema: ${JSON.stringify((0, import_zod_to_json_schema2.zodToJsonSchema)(outputSchema), null, 2)}`);
+    if (llm && "withStructuredOutput" in llm && typeof llm.withStructuredOutput === "function") {
+      structuredLlm = llm.withStructuredOutput(outputSchema);
+    } else if (llm) {
+      structuredLlm = llm;
+    } else {
+      throw new Error("LLM is required for structured output");
+    }
+    schemaDescription = JSON.stringify((0, import_zod_to_json_schema2.zodToJsonSchema)(outputSchema), null, 2);
+    logger.info(`\u{1F504} Schema description: ${schemaDescription}`);
     let textContent = "";
     if (typeof rawResult === "string") {
       textContent = rawResult;
@@ -2692,6 +2759,7 @@ var MCPAgent = class {
         let chunkCount = 0;
         for await (const chunk of stream) {
           chunkCount++;
+          logger.info(`Chunk ${chunkCount}: ${JSON.stringify(chunk, null, 2)}`);
           if (typeof chunk === "string") {
             try {
               structuredResult = JSON.parse(chunk);
@@ -2707,7 +2775,6 @@ var MCPAgent = class {
               logger.warn(`\u{1F504} Failed to parse chunk as JSON: ${chunk}`);
             }
           }
-          await new Promise((resolve) => setTimeout(resolve, 0));
           if (chunkCount % 10 === 0) {
             logger.info(`\u{1F504} Structured output streaming: ${chunkCount} chunks`);
           }
@@ -4001,643 +4068,6 @@ async function* streamEventsToAISDKWithTools(streamEvents) {
 }
 __name(streamEventsToAISDKWithTools, "streamEventsToAISDKWithTools");
 
-// src/server/mcp-server.ts
-var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
-var import_zod7 = require("zod");
-var import_express = __toESM(require("express"), 1);
-var import_node_fs3 = require("fs");
-var import_node_path2 = require("path");
-
-// src/server/logging.ts
-function requestLogger(req, res, next) {
-  const timestamp2 = (/* @__PURE__ */ new Date()).toISOString().substring(11, 23);
-  const method = req.method;
-  const url = req.url;
-  const originalEnd = res.end.bind(res);
-  res.end = function(chunk, encoding, cb) {
-    const statusCode = res.statusCode;
-    let statusColor = "";
-    if (statusCode >= 200 && statusCode < 300) {
-      statusColor = "\x1B[32m";
-    } else if (statusCode >= 300 && statusCode < 400) {
-      statusColor = "\x1B[33m";
-    } else if (statusCode >= 400 && statusCode < 500) {
-      statusColor = "\x1B[31m";
-    } else if (statusCode >= 500) {
-      statusColor = "\x1B[35m";
-    }
-    let logMessage = `[${timestamp2}] ${method} \x1B[1m${url}\x1B[0m`;
-    if (method === "POST" && url === "/mcp" && req.body?.method) {
-      logMessage += ` \x1B[1m[${req.body.method}]\x1B[0m`;
-    }
-    logMessage += ` ${statusColor}${statusCode}\x1B[0m`;
-    console.log(logMessage);
-    return originalEnd(chunk, encoding, cb);
-  };
-  next();
-}
-__name(requestLogger, "requestLogger");
-
-// src/server/mcp-server.ts
-var McpServer = class {
-  static {
-    __name(this, "McpServer");
-  }
-  server;
-  config;
-  app;
-  mcpMounted = false;
-  inspectorMounted = false;
-  serverPort;
-  /**
-   * Creates a new MCP server instance with Express integration
-   * 
-   * Initializes the server with the provided configuration, sets up CORS headers,
-   * configures widget serving routes, and creates a proxy that allows direct
-   * access to Express methods while preserving MCP server functionality.
-   * 
-   * @param config - Server configuration including name, version, and description
-   * @returns A proxied McpServer instance that supports both MCP and Express methods
-   */
-  constructor(config2) {
-    this.config = config2;
-    this.server = new import_mcp.McpServer({
-      name: config2.name,
-      version: config2.version
-    });
-    this.app = (0, import_express.default)();
-    this.app.use(import_express.default.json());
-    this.app.use((req, res, next) => {
-      res.header("Access-Control-Allow-Origin", "*");
-      res.header("Access-Control-Allow-Methods", "GET, POST, DELETE, OPTIONS");
-      res.header("Access-Control-Allow-Headers", "Content-Type");
-      next();
-    });
-    this.app.use(requestLogger);
-    this.setupWidgetRoutes();
-    return new Proxy(this, {
-      get(target, prop) {
-        if (prop in target) {
-          return target[prop];
-        }
-        const value = target.app[prop];
-        return typeof value === "function" ? value.bind(target.app) : value;
-      }
-    });
-  }
-  /**
-   * Define a static resource that can be accessed by clients
-   * 
-   * Registers a resource with the MCP server that clients can access via HTTP.
-   * Resources are static content like files, data, or pre-computed results that
-   * can be retrieved by clients without requiring parameters.
-   * 
-   * @param resourceDefinition - Configuration object containing resource metadata and handler function
-   * @param resourceDefinition.name - Unique identifier for the resource
-   * @param resourceDefinition.uri - URI pattern for accessing the resource
-   * @param resourceDefinition.title - Optional human-readable title for the resource
-   * @param resourceDefinition.description - Optional description of the resource
-   * @param resourceDefinition.mimeType - MIME type of the resource content
-   * @param resourceDefinition.annotations - Optional annotations (audience, priority, lastModified)
-   * @param resourceDefinition.fn - Async function that returns the resource content
-   * @returns The server instance for method chaining
-   * 
-   * @example
-   * ```typescript
-   * server.resource({
-   *   name: 'config',
-   *   uri: 'config://app-settings',
-   *   title: 'Application Settings',
-   *   mimeType: 'application/json',
-   *   description: 'Current application configuration',
-   *   annotations: {
-   *     audience: ['user'],
-   *     priority: 0.8
-   *   },
-   *   fn: async () => ({
-   *     contents: [{
-   *       uri: 'config://app-settings',
-   *       mimeType: 'application/json',
-   *       text: JSON.stringify({ theme: 'dark', language: 'en' })
-   *     }]
-   *   })
-   * })
-   * ```
-   */
-  resource(resourceDefinition) {
-    this.server.resource(
-      resourceDefinition.name,
-      resourceDefinition.uri,
-      {
-        name: resourceDefinition.name,
-        title: resourceDefinition.title,
-        description: resourceDefinition.description,
-        mimeType: resourceDefinition.mimeType,
-        annotations: resourceDefinition.annotations
-      },
-      async () => {
-        return await resourceDefinition.fn();
-      }
-    );
-    return this;
-  }
-  /**
-   * Define a dynamic resource template with parameters
-   * 
-   * Registers a parameterized resource template with the MCP server. Templates use URI
-   * patterns with placeholders that can be filled in at request time, allowing dynamic
-   * resource generation based on parameters.
-   * 
-   * @param resourceTemplateDefinition - Configuration object for the resource template
-   * @param resourceTemplateDefinition.name - Unique identifier for the template
-   * @param resourceTemplateDefinition.resourceTemplate - ResourceTemplate object with uriTemplate and metadata
-   * @param resourceTemplateDefinition.fn - Async function that generates resource content from URI and params
-   * @returns The server instance for method chaining
-   * 
-   * @example
-   * ```typescript
-   * server.resourceTemplate({
-   *   name: 'user-profile',
-   *   resourceTemplate: {
-   *     uriTemplate: 'user://{userId}/profile',
-   *     name: 'User Profile',
-   *     mimeType: 'application/json'
-   *   },
-   *   fn: async (uri, params) => ({
-   *     contents: [{
-   *       uri: uri.toString(),
-   *       mimeType: 'application/json',
-   *       text: JSON.stringify({ userId: params.userId, name: 'John Doe' })
-   *     }]
-   *   })
-   * })
-   * ```
-   */
-  resourceTemplate(resourceTemplateDefinition) {
-    const template = new import_mcp.ResourceTemplate(
-      resourceTemplateDefinition.resourceTemplate.uriTemplate,
-      {
-        list: void 0,
-        // Optional: callback to list all matching resources
-        complete: void 0
-        // Optional: callback for auto-completion
-      }
-    );
-    const metadata = {};
-    if (resourceTemplateDefinition.resourceTemplate.name) {
-      metadata.name = resourceTemplateDefinition.resourceTemplate.name;
-    }
-    if (resourceTemplateDefinition.title) {
-      metadata.title = resourceTemplateDefinition.title;
-    }
-    if (resourceTemplateDefinition.description || resourceTemplateDefinition.resourceTemplate.description) {
-      metadata.description = resourceTemplateDefinition.description || resourceTemplateDefinition.resourceTemplate.description;
-    }
-    if (resourceTemplateDefinition.resourceTemplate.mimeType) {
-      metadata.mimeType = resourceTemplateDefinition.resourceTemplate.mimeType;
-    }
-    if (resourceTemplateDefinition.annotations) {
-      metadata.annotations = resourceTemplateDefinition.annotations;
-    }
-    this.server.resource(
-      resourceTemplateDefinition.name,
-      template,
-      metadata,
-      async (uri) => {
-        const params = this.parseTemplateUri(
-          resourceTemplateDefinition.resourceTemplate.uriTemplate,
-          uri.toString()
-        );
-        return await resourceTemplateDefinition.fn(uri, params);
-      }
-    );
-    return this;
-  }
-  /**
-   * Define a tool that can be called by clients
-   * 
-   * Registers a tool with the MCP server that clients can invoke with parameters.
-   * Tools are functions that perform actions, computations, or operations and
-   * return results. They accept structured input parameters and return structured output.
-   * 
-   * @param toolDefinition - Configuration object containing tool metadata and handler function
-   * @param toolDefinition.name - Unique identifier for the tool
-   * @param toolDefinition.description - Human-readable description of what the tool does
-   * @param toolDefinition.inputs - Array of input parameter definitions with types and validation
-   * @param toolDefinition.fn - Async function that executes the tool logic with provided parameters
-   * @returns The server instance for method chaining
-   * 
-   * @example
-   * ```typescript
-   * server.tool({
-   *   name: 'calculate',
-   *   description: 'Performs mathematical calculations',
-   *   inputs: [
-   *     { name: 'expression', type: 'string', required: true },
-   *     { name: 'precision', type: 'number', required: false }
-   *   ],
-   *   fn: async ({ expression, precision = 2 }) => {
-   *     const result = eval(expression)
-   *     return { result: Number(result.toFixed(precision)) }
-   *   }
-   * })
-   * ```
-   */
-  tool(toolDefinition) {
-    const inputSchema = this.createToolInputSchema(toolDefinition.inputs || []);
-    this.server.tool(
-      toolDefinition.name,
-      toolDefinition.description ?? "",
-      inputSchema,
-      async (params) => {
-        return await toolDefinition.fn(params);
-      }
-    );
-    return this;
-  }
-  /**
-   * Define a prompt template
-   * 
-   * Registers a prompt template with the MCP server that clients can use to generate
-   * structured prompts for AI models. Prompt templates accept parameters and return
-   * formatted text that can be used as input to language models or other AI systems.
-   * 
-   * @param promptDefinition - Configuration object containing prompt metadata and handler function
-   * @param promptDefinition.name - Unique identifier for the prompt template
-   * @param promptDefinition.description - Human-readable description of the prompt's purpose
-   * @param promptDefinition.args - Array of argument definitions with types and validation
-   * @param promptDefinition.fn - Async function that generates the prompt from provided arguments
-   * @returns The server instance for method chaining
-   * 
-   * @example
-   * ```typescript
-   * server.prompt({
-   *   name: 'code-review',
-   *   description: 'Generates a code review prompt',
-   *   args: [
-   *     { name: 'language', type: 'string', required: true },
-   *     { name: 'focus', type: 'string', required: false }
-   *   ],
-   *   fn: async ({ language, focus = 'general' }) => {
-   *     return {
-   *       messages: [{
-   *         role: 'user',
-   *         content: `Please review this ${language} code with focus on ${focus}...`
-   *       }]
-   *     }
-   *   }
-   * })
-   * ```
-   */
-  prompt(promptDefinition) {
-    const argsSchema = this.createPromptArgsSchema(promptDefinition.args || []);
-    this.server.prompt(
-      promptDefinition.name,
-      promptDefinition.description ?? "",
-      argsSchema,
-      async (params) => {
-        return await promptDefinition.fn(params);
-      }
-    );
-    return this;
-  }
-  /**
-   * Mount MCP server endpoints at /mcp
-   * 
-   * Sets up the HTTP transport layer for the MCP server, creating endpoints for
-   * Server-Sent Events (SSE) streaming, POST message handling, and DELETE session cleanup.
-   * Uses stateless mode for session management, making it suitable for stateless deployments.
-   * 
-   * This method is called automatically when the server starts listening and ensures
-   * that MCP clients can communicate with the server over HTTP.
-   * 
-   * @private
-   * @returns Promise that resolves when MCP endpoints are successfully mounted
-   * 
-   * @example
-   * Endpoints created:
-   * - GET /mcp - SSE streaming endpoint for real-time communication
-   * - POST /mcp - Message handling endpoint for MCP protocol messages
-   * - DELETE /mcp - Session cleanup endpoint
-   */
-  async mountMcp() {
-    if (this.mcpMounted) return;
-    const { StreamableHTTPServerTransport } = await import("@modelcontextprotocol/sdk/server/streamableHttp.js");
-    const httpTransport = new StreamableHTTPServerTransport({
-      sessionIdGenerator: void 0
-      // Stateless mode
-    });
-    await this.server.connect(httpTransport);
-    const endpoint = "/mcp";
-    this.app.get(endpoint, async (req, res) => {
-      await httpTransport.handleRequest(req, res);
-    });
-    this.app.post(endpoint, import_express.default.json(), async (req, res) => {
-      await httpTransport.handleRequest(req, res, req.body);
-    });
-    this.app.delete(endpoint, async (req, res) => {
-      await httpTransport.handleRequest(req, res);
-    });
-    this.mcpMounted = true;
-    console.log(`[MCP] Server mounted at ${endpoint}`);
-  }
-  /**
-   * Start the Express server with MCP endpoints
-   * 
-   * Initiates the server startup process by mounting MCP endpoints, configuring
-   * the inspector UI (if available), and starting the Express server to listen
-   * for incoming connections. This is the main entry point for running the server.
-   * 
-   * The server will be accessible at the specified port with MCP endpoints at /mcp
-   * and inspector UI at /inspector (if the inspector package is installed).
-   * 
-   * @param port - Port number to listen on (defaults to 3001 if not specified)
-   * @returns Promise that resolves when the server is successfully listening
-   * 
-   * @example
-   * ```typescript
-   * await server.listen(8080)
-   * // Server now running at http://localhost:8080
-   * // MCP endpoints: http://localhost:8080/mcp
-   * // Inspector UI: http://localhost:8080/inspector
-   * ```
-   */
-  async listen(port) {
-    await this.mountMcp();
-    this.serverPort = port || 3001;
-    this.mountInspector();
-    this.app.listen(this.serverPort, () => {
-      console.log(`[SERVER] Listening on http://localhost:${this.serverPort}`);
-      console.log(`[MCP] Endpoints: http://localhost:${this.serverPort}/mcp`);
-    });
-  }
-  /**
-   * Mount MCP Inspector UI at /inspector
-   * 
-   * Dynamically loads and mounts the MCP Inspector UI package if available, providing
-   * a web-based interface for testing and debugging MCP servers. The inspector
-   * automatically connects to the local MCP server endpoints.
-   * 
-   * This method gracefully handles cases where the inspector package is not installed,
-   * allowing the server to function without the inspector in production environments.
-   * 
-   * @private
-   * @returns void
-   * 
-   * @example
-   * If @mcp-use/inspector is installed:
-   * - Inspector UI available at http://localhost:PORT/inspector
-   * - Automatically connects to http://localhost:PORT/mcp
-   * 
-   * If not installed:
-   * - Server continues to function normally
-   * - No inspector UI available
-   */
-  mountInspector() {
-    if (this.inspectorMounted) return;
-    import("@mcp-use/inspector").then(({ mountInspector }) => {
-      const mcpServerUrl = `http://localhost:${this.serverPort}/mcp`;
-      mountInspector(this.app, "/inspector", mcpServerUrl);
-      this.inspectorMounted = true;
-      console.log(`[INSPECTOR] UI available at http://localhost:${this.serverPort}/inspector`);
-    }).catch(() => {
-    });
-  }
-  /**
-   * Setup default widget serving routes
-   * 
-   * Configures Express routes to serve MCP UI widgets and their static assets.
-   * Widgets are served from the dist/resources/mcp-use/widgets directory and can
-   * be accessed via HTTP endpoints for embedding in web applications.
-   * 
-   * Routes created:
-   * - GET /mcp-use/widgets/:widget - Serves widget's index.html
-   * - GET /mcp-use/widgets/:widget/assets/* - Serves widget-specific assets
-   * - GET /mcp-use/widgets/assets/* - Fallback asset serving with auto-discovery
-   * 
-   * @private
-   * @returns void
-   * 
-   * @example
-   * Widget routes:
-   * - http://localhost:3001/mcp-use/widgets/kanban-board
-   * - http://localhost:3001/mcp-use/widgets/todo-list/assets/style.css
-   * - http://localhost:3001/mcp-use/widgets/assets/script.js (auto-discovered)
-   */
-  setupWidgetRoutes() {
-    this.app.get("/mcp-use/widgets/:widget/assets/*", (req, res, next) => {
-      const widget = req.params.widget;
-      const assetFile = req.params[0];
-      const assetPath = (0, import_node_path2.join)(process.cwd(), "dist", "resources", "mcp-use", "widgets", widget, "assets", assetFile);
-      res.sendFile(assetPath, (err) => err ? next() : void 0);
-    });
-    this.app.get("/mcp-use/widgets/assets/*", (req, res, next) => {
-      const assetFile = req.params[0];
-      const widgetsDir = (0, import_node_path2.join)(process.cwd(), "dist", "resources", "mcp-use", "widgets");
-      try {
-        const widgets = (0, import_node_fs3.readdirSync)(widgetsDir);
-        for (const widget of widgets) {
-          const assetPath = (0, import_node_path2.join)(widgetsDir, widget, "assets", assetFile);
-          if ((0, import_node_fs3.existsSync)(assetPath)) {
-            return res.sendFile(assetPath);
-          }
-        }
-        next();
-      } catch {
-        next();
-      }
-    });
-    this.app.get("/mcp-use/widgets/:widget", (req, res, next) => {
-      const filePath = (0, import_node_path2.join)(process.cwd(), "dist", "resources", "mcp-use", "widgets", req.params.widget, "index.html");
-      res.sendFile(filePath, (err) => err ? next() : void 0);
-    });
-  }
-  /**
-   * Create input schema for resource templates
-   * 
-   * Parses a URI template string to extract parameter names and generates a Zod
-   * validation schema for those parameters. Used internally for validating resource
-   * template parameters before processing requests.
-   * 
-   * @param uriTemplate - URI template string with parameter placeholders (e.g., "/users/{id}/posts/{postId}")
-   * @returns Object mapping parameter names to Zod string schemas
-   * 
-   * @example
-   * ```typescript
-   * const schema = this.createInputSchema("/users/{id}/posts/{postId}")
-   * // Returns: { id: z.string(), postId: z.string() }
-   * ```
-   */
-  createInputSchema(uriTemplate) {
-    const params = this.extractTemplateParams(uriTemplate);
-    const schema = {};
-    params.forEach((param) => {
-      schema[param] = import_zod7.z.string();
-    });
-    return schema;
-  }
-  /**
-   * Create input schema for tools
-   * 
-   * Converts tool input definitions into Zod validation schemas for runtime validation.
-   * Supports common data types (string, number, boolean, object, array) and optional
-   * parameters. Used internally when registering tools with the MCP server.
-   * 
-   * @param inputs - Array of input parameter definitions with name, type, and optional flag
-   * @returns Object mapping parameter names to Zod validation schemas
-   * 
-   * @example
-   * ```typescript
-   * const schema = this.createToolInputSchema([
-   *   { name: 'query', type: 'string', required: true },
-   *   { name: 'limit', type: 'number', required: false }
-   * ])
-   * // Returns: { query: z.string(), limit: z.number().optional() }
-   * ```
-   */
-  createToolInputSchema(inputs) {
-    const schema = {};
-    inputs.forEach((input) => {
-      let zodType;
-      switch (input.type) {
-        case "string":
-          zodType = import_zod7.z.string();
-          break;
-        case "number":
-          zodType = import_zod7.z.number();
-          break;
-        case "boolean":
-          zodType = import_zod7.z.boolean();
-          break;
-        case "object":
-          zodType = import_zod7.z.object({});
-          break;
-        case "array":
-          zodType = import_zod7.z.array(import_zod7.z.any());
-          break;
-        default:
-          zodType = import_zod7.z.any();
-      }
-      if (!input.required) {
-        zodType = zodType.optional();
-      }
-      schema[input.name] = zodType;
-    });
-    return schema;
-  }
-  /**
-   * Create arguments schema for prompts
-   * 
-   * Converts prompt argument definitions into Zod validation schemas for runtime validation.
-   * Supports common data types (string, number, boolean, object, array) and optional
-   * parameters. Used internally when registering prompt templates with the MCP server.
-   * 
-   * @param inputs - Array of argument definitions with name, type, and optional flag
-   * @returns Object mapping argument names to Zod validation schemas
-   * 
-   * @example
-   * ```typescript
-   * const schema = this.createPromptArgsSchema([
-   *   { name: 'topic', type: 'string', required: true },
-   *   { name: 'style', type: 'string', required: false }
-   * ])
-   * // Returns: { topic: z.string(), style: z.string().optional() }
-   * ```
-   */
-  createPromptArgsSchema(inputs) {
-    const schema = {};
-    inputs.forEach((input) => {
-      let zodType;
-      switch (input.type) {
-        case "string":
-          zodType = import_zod7.z.string();
-          break;
-        case "number":
-          zodType = import_zod7.z.number();
-          break;
-        case "boolean":
-          zodType = import_zod7.z.boolean();
-          break;
-        case "object":
-          zodType = import_zod7.z.object({});
-          break;
-        case "array":
-          zodType = import_zod7.z.array(import_zod7.z.any());
-          break;
-        default:
-          zodType = import_zod7.z.any();
-      }
-      if (!input.required) {
-        zodType = zodType.optional();
-      }
-      schema[input.name] = zodType;
-    });
-    return schema;
-  }
-  /**
-   * Extract parameter names from URI template
-   * 
-   * Parses a URI template string to extract parameter names enclosed in curly braces.
-   * Used internally to identify dynamic parameters in resource templates and generate
-   * appropriate validation schemas.
-   * 
-   * @param uriTemplate - URI template string with parameter placeholders (e.g., "/users/{id}/posts/{postId}")
-   * @returns Array of parameter names found in the template
-   * 
-   * @example
-   * ```typescript
-   * const params = this.extractTemplateParams("/users/{id}/posts/{postId}")
-   * // Returns: ["id", "postId"]
-   * ```
-   */
-  extractTemplateParams(uriTemplate) {
-    const matches = uriTemplate.match(/\{([^}]+)\}/g);
-    return matches ? matches.map((match) => match.slice(1, -1)) : [];
-  }
-  /**
-   * Parse parameter values from a URI based on a template
-   * 
-   * Extracts parameter values from an actual URI by matching it against a URI template.
-   * The template contains placeholders like {param} which are extracted as key-value pairs.
-   * 
-   * @param template - URI template with placeholders (e.g., "user://{userId}/posts/{postId}")
-   * @param uri - Actual URI to parse (e.g., "user://123/posts/456")
-   * @returns Object mapping parameter names to their values
-   * 
-   * @example
-   * ```typescript
-   * const params = this.parseTemplateUri("user://{userId}/posts/{postId}", "user://123/posts/456")
-   * // Returns: { userId: "123", postId: "456" }
-   * ```
-   */
-  parseTemplateUri(template, uri) {
-    const params = {};
-    let regexPattern = template.replace(/[.*+?^$()[\]\\|]/g, "\\$&");
-    const paramNames = [];
-    regexPattern = regexPattern.replace(/\\\{([^}]+)\\\}/g, (_, paramName) => {
-      paramNames.push(paramName);
-      return "([^/]+)";
-    });
-    const regex = new RegExp(`^${regexPattern}$`);
-    const match = uri.match(regex);
-    if (match) {
-      paramNames.forEach((paramName, index) => {
-        params[paramName] = match[index + 1];
-      });
-    }
-    return params;
-  }
-};
-function createMCPServer(name, config2 = {}) {
-  const instance = new McpServer({
-    name,
-    version: config2.version || "1.0.0",
-    description: config2.description
-  });
-  return instance;
-}
-__name(createMCPServer, "createMCPServer");
-
 // src/oauth-helper.ts
 var OAuthHelper = class {
   static {
@@ -5986,7 +5416,6 @@ var import_messages3 = require("@langchain/core/messages");
   Telemetry,
   ToolMessage,
   WebSocketConnector,
-  createMCPServer,
   createOAuthMCPConfig,
   createReadableStreamFromGenerator,
   loadConfigFile,