mcp-use 1.2.1 → 1.2.2-canary.1

package/dist/{chunk-MGUO7HXB.js → chunk-7UX634PO.js}

@@ -1,6 +1,6 @@
 import {
   logger
-} from "./chunk-ZUEQQ6YK.js";
+} from "./chunk-3RJENWH4.js";
 import {
   __name
 } from "./chunk-SHUYVCID.js";
@@ -152,9 +152,14 @@ var LangChainAdapter = class extends BaseAdapter {
       // Blank is acceptable but discouraged.
       schema: argsSchema,
       func: /* @__PURE__ */ __name(async (input) => {
-        logger.debug(`MCP tool "${mcpTool.name}" received input: ${JSON.stringify(input)}`);
+        logger.debug(
+          `MCP tool "${mcpTool.name}" received input: ${JSON.stringify(input)}`
+        );
         try {
-          const result = await connector.callTool(mcpTool.name, input);
+          const result = await connector.callTool(
+            mcpTool.name,
+            input
+          );
           return JSON.stringify(result);
         } catch (err) {
           logger.error(`Error executing MCP tool: ${err.message}`);
@@ -305,7 +310,9 @@ var ConnectMCPServerTool = class extends MCPServerTool {
       const numTools = serverTools.length;
       return `Connected to MCP server '${serverName}'. ${numTools} tools are now available.`;
     } catch (error) {
-      logger.error(`Error connecting to server '${serverName}': ${String(error)}`);
+      logger.error(
+        `Error connecting to server '${serverName}': ${String(error)}`
+      );
       return `Failed to connect to server '${serverName}': ${String(error)}`;
     }
   }
@@ -340,7 +347,9 @@ var ListMCPServersTool = class extends MCPServerTool {
         outputLines.push(`${numberOfTools} tools available for this server
 `);
       } catch (error) {
-        logger.error(`Unexpected error listing tools for server '${serverName}': ${String(error)}`);
+        logger.error(
+          `Unexpected error listing tools for server '${serverName}': ${String(error)}`
+        );
       }
     }
     return outputLines.join("\n");
@@ -402,10 +411,10 @@ var ServerManager = class {
     }
     const tableData = allServerNames.map((name) => ({
       "Server Name": name,
-      "Connected": activeSessionNames.includes(name) ? "\u2705" : "\u274C",
-      "Initialized": this.initializedServers[name] ? "\u2705" : "\u274C",
+      Connected: activeSessionNames.includes(name) ? "\u2705" : "\u274C",
+      Initialized: this.initializedServers[name] ? "\u2705" : "\u274C",
       "Tool Count": this.serverTools[name]?.length ?? 0,
-      "Active": this.activeServer === name ? "\u2705" : "\u274C"
+      Active: this.activeServer === name ? "\u2705" : "\u274C"
     }));
     logger.info(`Server Manager State: [${context}]`);
     console.table(tableData);
@@ -422,13 +431,19 @@ var ServerManager = class {
       try {
         let session = null;
         session = this.client.getSession(serverName);
-        logger.debug(`Using existing session for server '${serverName}' to prefetch tools.`);
+        logger.debug(
+          `Using existing session for server '${serverName}' to prefetch tools.`
+        );
         if (!session) {
           session = await this.client.createSession(serverName).catch((createSessionError) => {
-            logger.warn(`Could not create session for '${serverName}' during prefetch: ${createSessionError}`);
+            logger.warn(
+              `Could not create session for '${serverName}' during prefetch: ${createSessionError}`
+            );
             return null;
           });
-          logger.debug(`Temporarily created session for '${serverName}' to prefetch tools.`);
+          logger.debug(
+            `Temporarily created session for '${serverName}' to prefetch tools.`
+          );
         }
         if (session) {
           const connector = session.connector;
@@ -436,7 +451,9 @@ var ServerManager = class {
           try {
             tools = await this.adapter.createToolsFromConnectors([connector]);
           } catch (toolFetchError) {
-            logger.error(`Failed to create tools from connector for server '${serverName}': ${toolFetchError}`);
+            logger.error(
+              `Failed to create tools from connector for server '${serverName}': ${toolFetchError}`
+            );
             continue;
           }
           const cachedTools = this.serverTools[serverName];
@@ -444,7 +461,9 @@ var ServerManager = class {
           if (toolsChanged) {
             this.serverTools[serverName] = tools;
             this.initializedServers[serverName] = true;
-            logger.debug(`Prefetched ${tools.length} tools for server '${serverName}'.`);
+            logger.debug(
+              `Prefetched ${tools.length} tools for server '${serverName}'.`
+            );
           } else {
             logger.debug(
               `Tools for server '${serverName}' unchanged, using cached version.`
@@ -452,7 +471,9 @@ var ServerManager = class {
           }
         }
       } catch (outerError) {
-        logger.error(`Error prefetching tools for server '${serverName}': ${outerError}`);
+        logger.error(
+          `Error prefetching tools for server '${serverName}': ${outerError}`
+        );
       }
     }
   }
@@ -510,11 +531,18 @@ var ObservabilityManager = class {
       return;
     }
     try {
-      const { langfuseHandler: langfuseHandler2, langfuseInitPromise: langfuseInitPromise2 } = await import("./langfuse-6AJGHMAV.js");
+      const { langfuseHandler: langfuseHandler2, langfuseInitPromise: langfuseInitPromise2 } = await import("./langfuse-LCJ6VJEP.js");
       if (this.agentId || this.metadata || this.metadataProvider || this.tagsProvider) {
-        const { initializeLangfuse } = await import("./langfuse-6AJGHMAV.js");
-        await initializeLangfuse(this.agentId, this.metadata, this.metadataProvider, this.tagsProvider);
-        logger.debug(`ObservabilityManager: Reinitialized Langfuse with agent ID: ${this.agentId}, metadata: ${JSON.stringify(this.metadata)}`);
+        const { initializeLangfuse } = await import("./langfuse-LCJ6VJEP.js");
+        await initializeLangfuse(
+          this.agentId,
+          this.metadata,
+          this.metadataProvider,
+          this.tagsProvider
+        );
+        logger.debug(
+          `ObservabilityManager: Reinitialized Langfuse with agent ID: ${this.agentId}, metadata: ${JSON.stringify(this.metadata)}`
+        );
       } else {
         const initPromise = langfuseInitPromise2();
         if (initPromise) {
@@ -538,16 +566,22 @@ var ObservabilityManager = class {
    */
   async getCallbacks() {
     if (!this.observe) {
-      logger.debug("ObservabilityManager: Observability disabled via observe=false");
+      logger.debug(
+        "ObservabilityManager: Observability disabled via observe=false"
+      );
       return [];
     }
     if (this.customCallbacks) {
-      logger.debug(`ObservabilityManager: Using ${this.customCallbacks.length} custom callbacks`);
+      logger.debug(
+        `ObservabilityManager: Using ${this.customCallbacks.length} custom callbacks`
+      );
       return this.customCallbacks;
     }
     await this.collectAvailableHandlers();
     if (this.availableHandlers.length > 0) {
-      logger.debug(`ObservabilityManager: Using ${this.availableHandlers.length} handlers`);
+      logger.debug(
+        `ObservabilityManager: Using ${this.availableHandlers.length} handlers`
+      );
     } else {
       logger.debug("ObservabilityManager: No callbacks configured");
     }
@@ -604,7 +638,9 @@ var ObservabilityManager = class {
       this.customCallbacks = [];
     }
     this.customCallbacks.push(callback);
-    logger.debug(`ObservabilityManager: Added custom callback: ${callback.constructor.name}`);
+    logger.debug(
+      `ObservabilityManager: Added custom callback: ${callback.constructor.name}`
+    );
   }
   /**
    * Clear all custom callbacks.
@@ -735,7 +771,15 @@ function getModelName(llm) {
   if ("_identifyingParams" in llm) {
     const identifyingParams = llm._identifyingParams;
     if (typeof identifyingParams === "object" && identifyingParams !== null) {
-      for (const key of ["model", "modelName", "model_name", "modelId", "model_id", "deploymentName", "deployment_name"]) {
+      for (const key of [
+        "model",
+        "modelName",
+        "model_name",
+        "modelId",
+        "model_id",
+        "deploymentName",
+        "deployment_name"
+      ]) {
         if (key in identifyingParams) {
           return String(identifyingParams[key]);
         }
@@ -826,8 +870,16 @@ var Telemetry = class _Telemetry {
     __name(this, "Telemetry");
   }
   static instance = null;
-  USER_ID_PATH = path2.join(getCacheHome(), "mcp_use_3", "telemetry_user_id");
-  VERSION_DOWNLOAD_PATH = path2.join(getCacheHome(), "mcp_use", "download_version");
+  USER_ID_PATH = path2.join(
+    getCacheHome(),
+    "mcp_use_3",
+    "telemetry_user_id"
+  );
+  VERSION_DOWNLOAD_PATH = path2.join(
+    getCacheHome(),
+    "mcp_use",
+    "download_version"
+  );
   PROJECT_API_KEY = "phc_lyTtbYwvkdSbrcMQNPiKiiRWrrM1seyKIMjycSvItEI";
   HOST = "https://eu.i.posthog.com";
   SCARF_GATEWAY_URL = "https://mcpuse.gateway.scarf.sh/events-ts";
@@ -847,17 +899,18 @@ var Telemetry = class _Telemetry {
     } else if (!isNodeJS) {
       this._posthogClient = null;
       this._scarfClient = null;
-      logger.debug("Telemetry disabled - non-Node.js environment detected (e.g., Cloudflare Workers)");
+      logger.debug(
+        "Telemetry disabled - non-Node.js environment detected (e.g., Cloudflare Workers)"
+      );
     } else {
-      logger.info("Anonymized telemetry enabled. Set MCP_USE_ANONYMIZED_TELEMETRY=false to disable.");
+      logger.info(
+        "Anonymized telemetry enabled. Set MCP_USE_ANONYMIZED_TELEMETRY=false to disable."
+      );
       try {
-        this._posthogClient = new PostHog(
-          this.PROJECT_API_KEY,
-          {
-            host: this.HOST,
-            disableGeoip: false
-          }
-        );
+        this._posthogClient = new PostHog(this.PROJECT_API_KEY, {
+          host: this.HOST,
+          disableGeoip: false
+        });
       } catch (e) {
         logger.warn(`Failed to initialize PostHog telemetry: ${e}`);
         this._posthogClient = null;
@@ -967,7 +1020,9 @@ var Telemetry = class _Telemetry {
       if (!fs2.existsSync(this.VERSION_DOWNLOAD_PATH)) {
         shouldTrack = true;
         firstDownload = true;
-        fs2.mkdirSync(path2.dirname(this.VERSION_DOWNLOAD_PATH), { recursive: true });
+        fs2.mkdirSync(path2.dirname(this.VERSION_DOWNLOAD_PATH), {
+          recursive: true
+        });
         fs2.writeFileSync(this.VERSION_DOWNLOAD_PATH, currentVersion);
       } else {
         const savedVersion = fs2.readFileSync(this.VERSION_DOWNLOAD_PATH, "utf-8").trim();
@@ -978,7 +1033,9 @@ var Telemetry = class _Telemetry {
         }
       }
       if (shouldTrack) {
-        logger.debug(`Tracking package download event with properties: ${JSON.stringify(properties)}`);
+        logger.debug(
+          `Tracking package download event with properties: ${JSON.stringify(properties)}`
+        );
         const eventProperties = { ...properties || {} };
         eventProperties.mcp_use_version = currentVersion;
         eventProperties.user_id = this.userId;
@@ -1115,7 +1172,9 @@ var RemoteAgent = class {
             `Agent not found: Agent '${this.agentId}' does not exist or you don't have access to it. Please verify the agent ID and ensure it exists in your account.`
           );
         }
-        throw new Error(`Failed to create chat session: ${statusCode} - ${responseText}`);
+        throw new Error(
+          `Failed to create chat session: ${statusCode} - ${responseText}`
+        );
       }
       const chatData = await response.json();
       const chatId = chatData.id;
@@ -1188,8 +1247,12 @@ var RemoteAgent = class {
             "Internal server error occurred during agent execution. Please try again later or contact support if the issue persists."
           );
         } else {
-          logger.error(`\u274C Remote execution failed with status ${statusCode}: ${responseText}`);
-          throw new Error(`Remote agent execution failed: ${statusCode} - ${responseText}`);
+          logger.error(
+            `\u274C Remote execution failed with status ${statusCode}: ${responseText}`
+          );
+          throw new Error(
+            `Remote agent execution failed: ${statusCode} - ${responseText}`
+          );
         }
       }
       const result = await response.json();
@@ -1240,7 +1303,13 @@ Raw error: ${result}`
   }
   // eslint-disable-next-line require-yield
   async *stream(query, maxSteps, manageConnector, externalHistory, outputSchema) {
-    const result = await this.run(query, maxSteps, manageConnector, externalHistory, outputSchema);
+    const result = await this.run(
+      query,
+      maxSteps,
+      manageConnector,
+      externalHistory,
+      outputSchema
+    );
     return result;
   }
   async close() {
@@ -1249,7 +1318,14 @@ Raw error: ${result}`
 };
 
 // src/agents/mcp_agent.ts
-import { createAgent, modelCallLimitMiddleware, SystemMessage as SystemMessage2, AIMessage, HumanMessage, ToolMessage } from "langchain";
+import {
+  createAgent,
+  modelCallLimitMiddleware,
+  SystemMessage as SystemMessage2,
+  AIMessage,
+  HumanMessage,
+  ToolMessage
+} from "langchain";
 import { zodToJsonSchema as zodToJsonSchema2 } from "zod-to-json-schema";
 
 // src/agents/prompts/system_prompt_builder.ts
@@ -1258,8 +1334,7 @@ function generateToolDescriptions(tools, disallowedTools) {
   const disallowedSet = new Set(disallowedTools ?? []);
   const descriptions = [];
   for (const tool of tools) {
-    if (disallowedSet.has(tool.name))
-      continue;
+    if (disallowedSet.has(tool.name)) continue;
     const escaped = tool.description.replace(/\{/g, "{{").replace(/\}/g, "}}");
     descriptions.push(`- ${tool.name}: ${escaped}`);
   }
@@ -1272,7 +1347,9 @@ function buildSystemPromptContent(template, toolDescriptionLines, additionalInst
   if (template.includes("{tool_descriptions}")) {
     content = template.replace("{tool_descriptions}", block);
   } else {
-    console.warn("`{tool_descriptions}` placeholder not found; appending at end.");
+    console.warn(
+      "`{tool_descriptions}` placeholder not found; appending at end."
+    );
     content = `${template}
 
 Available tools:
@@ -1410,7 +1487,9 @@ var MCPAgent = class {
       return;
     }
     if (!options.llm) {
-      throw new Error("llm is required for local execution. For remote execution, provide agentId instead.");
+      throw new Error(
+        "llm is required for local execution. For remote execution, provide agentId instead."
+      );
     }
     this.llm = options.llm;
     this.client = options.client;
@@ -1428,11 +1507,15 @@ var MCPAgent = class {
     this.verbose = options.verbose ?? false;
     this.observe = options.observe ?? true;
     if (!this.client && this.connectors.length === 0) {
-      throw new Error("Either 'client' or at least one 'connector' must be provided.");
+      throw new Error(
+        "Either 'client' or at least one 'connector' must be provided."
+      );
     }
     if (this.useServerManager) {
       if (!this.client) {
-        throw new Error("'client' must be provided when 'useServerManager' is true.");
+        throw new Error(
+          "'client' must be provided when 'useServerManager' is true."
+        );
       }
       this.adapter = options.adapter ?? new LangChainAdapter(this.disallowedTools);
       this.serverManager = options.serverManagerFactory?.(this.client) ?? new ServerManager(this.client, this.adapter);
@@ -1492,25 +1575,37 @@ var MCPAgent = class {
     } else {
       if (this.client) {
         this.sessions = this.client.getAllActiveSessions();
-        logger.info(`\u{1F50C} Found ${Object.keys(this.sessions).length} existing sessions`);
+        logger.info(
+          `\u{1F50C} Found ${Object.keys(this.sessions).length} existing sessions`
+        );
         if (Object.keys(this.sessions).length === 0) {
           logger.info("\u{1F504} No active sessions found, creating new ones...");
           this.sessions = await this.client.createAllSessions();
-          logger.info(`\u2705 Created ${Object.keys(this.sessions).length} new sessions`);
+          logger.info(
+            `\u2705 Created ${Object.keys(this.sessions).length} new sessions`
+          );
         }
         this._tools = await LangChainAdapter.createTools(this.client);
         this._tools.push(...this.additionalTools);
-        logger.info(`\u{1F6E0}\uFE0F Created ${this._tools.length} LangChain tools from client`);
+        logger.info(
+          `\u{1F6E0}\uFE0F Created ${this._tools.length} LangChain tools from client`
+        );
       } else {
-        logger.info(`\u{1F517} Connecting to ${this.connectors.length} direct connectors...`);
+        logger.info(
+          `\u{1F517} Connecting to ${this.connectors.length} direct connectors...`
+        );
         for (const connector of this.connectors) {
           if (!connector.isClientConnected) {
             await connector.connect();
           }
         }
-        this._tools = await this.adapter.createToolsFromConnectors(this.connectors);
+        this._tools = await this.adapter.createToolsFromConnectors(
+          this.connectors
+        );
         this._tools.push(...this.additionalTools);
-        logger.info(`\u{1F6E0}\uFE0F Created ${this._tools.length} LangChain tools from connectors`);
+        logger.info(
+          `\u{1F6E0}\uFE0F Created ${this._tools.length} LangChain tools from connectors`
+        );
       }
       logger.info(`\u{1F9F0} Found ${this._tools.length} tools across all connectors`);
       await this.createSystemMessageFromTools(this._tools);
@@ -1520,7 +1615,9 @@ var MCPAgent = class {
     const mcpServerInfo = this.getMCPServerInfo();
     if (Object.keys(mcpServerInfo).length > 0) {
       this.setMetadata(mcpServerInfo);
-      logger.debug(`MCP server info added to metadata: ${JSON.stringify(mcpServerInfo)}`);
+      logger.debug(
+        `MCP server info added to metadata: ${JSON.stringify(mcpServerInfo)}`
+      );
     }
     logger.info("\u2728 Agent initialization complete");
   }
@@ -1538,7 +1635,9 @@ var MCPAgent = class {
     if (this.memoryEnabled) {
       this.conversationHistory = [
         this.systemMessage,
-        ...this.conversationHistory.filter((m) => !(m instanceof SystemMessage2))
+        ...this.conversationHistory.filter(
+          (m) => !(m instanceof SystemMessage2)
+        )
       ];
     }
   }
@@ -1556,7 +1655,9 @@ var MCPAgent = class {
       systemPrompt: systemContent,
       middleware
     });
-    logger.debug(`Created agent with max_steps=${this.maxSteps} (via ModelCallLimitMiddleware) and ${this.callbacks.length} callbacks`);
+    logger.debug(
+      `Created agent with max_steps=${this.maxSteps} (via ModelCallLimitMiddleware) and ${this.callbacks.length} callbacks`
+    );
     return agent;
   }
   getConversationHistory() {
@@ -1566,8 +1667,7 @@ var MCPAgent = class {
     this.conversationHistory = this.memoryEnabled && this.systemMessage ? [this.systemMessage] : [];
   }
   addToHistory(message) {
-    if (this.memoryEnabled)
-      this.conversationHistory.push(message);
+    if (this.memoryEnabled) this.conversationHistory.push(message);
   }
   getSystemMessage() {
     return this.systemMessage;
@@ -1575,7 +1675,9 @@ var MCPAgent = class {
   setSystemMessage(message) {
     this.systemMessage = new SystemMessage2(message);
     if (this.memoryEnabled) {
-      this.conversationHistory = this.conversationHistory.filter((m) => !(m instanceof SystemMessage2));
+      this.conversationHistory = this.conversationHistory.filter(
+        (m) => !(m instanceof SystemMessage2)
+      );
       this.conversationHistory.unshift(this.systemMessage);
     }
     if (this._initialized && this._tools.length) {
@@ -1587,7 +1689,9 @@ var MCPAgent = class {
     this.disallowedTools = disallowedTools;
     this.adapter = new LangChainAdapter(this.disallowedTools);
     if (this._initialized) {
-      logger.debug("Agent already initialized. Changes will take effect on next initialization.");
+      logger.debug(
+        "Agent already initialized. Changes will take effect on next initialization."
+      );
     }
   }
   getDisallowedTools() {
@@ -1653,16 +1757,22 @@ var MCPAgent = class {
         try {
           const serialized = JSON.stringify(value);
           if (serialized.length > 1e3) {
-            logger.warn(`Metadata value for key '${sanitizedKey}' is too large. Truncating.`);
+            logger.warn(
+              `Metadata value for key '${sanitizedKey}' is too large. Truncating.`
+            );
             sanitized[sanitizedKey] = `${serialized.substring(0, 1e3)}...`;
           } else {
             sanitized[sanitizedKey] = value;
           }
         } catch (error) {
-          logger.warn(`Failed to serialize metadata value for key '${sanitizedKey}': ${error}. Skipping.`);
+          logger.warn(
+            `Failed to serialize metadata value for key '${sanitizedKey}': ${error}. Skipping.`
+          );
         }
       } else {
-        logger.warn(`Unsupported metadata value type for key '${sanitizedKey}': ${typeof value}. Skipping.`);
+        logger.warn(
+          `Unsupported metadata value type for key '${sanitizedKey}': ${typeof value}. Skipping.`
+        );
       }
     }
     return sanitized;
@@ -1709,15 +1819,24 @@ var MCPAgent = class {
               };
             }
           } catch (error) {
-            logger.warn(`Failed to get config for server '${serverName}': ${error}`);
-            serverConfigs[serverName] = { type: "error", error: "config_unavailable" };
+            logger.warn(
+              `Failed to get config for server '${serverName}': ${error}`
+            );
+            serverConfigs[serverName] = {
+              type: "error",
+              error: "config_unavailable"
+            };
           }
         }
         serverInfo.mcp_server_configs = serverConfigs;
       } else if (this.connectors && this.connectors.length > 0) {
         serverInfo.mcp_servers_count = this.connectors.length;
-        serverInfo.mcp_server_names = this.connectors.map((c) => c.publicIdentifier);
-        serverInfo.mcp_server_types = this.connectors.map((c) => c.constructor.name);
+        serverInfo.mcp_server_names = this.connectors.map(
+          (c) => c.publicIdentifier
+        );
+        serverInfo.mcp_server_types = this.connectors.map(
+          (c) => c.constructor.name
+        );
       }
     } catch (error) {
       logger.warn(`Failed to collect MCP server info: ${error}`);
@@ -1771,7 +1890,13 @@ var MCPAgent = class {
   }
   async run(query, maxSteps, manageConnector, externalHistory, outputSchema) {
     if (this.isRemote && this.remoteAgent) {
-      return this.remoteAgent.run(query, maxSteps, manageConnector, externalHistory, outputSchema);
+      return this.remoteAgent.run(
+        query,
+        maxSteps,
+        manageConnector,
+        externalHistory,
+        outputSchema
+      );
     }
     const generator = this.stream(
       query,
@@ -1784,7 +1909,13 @@ var MCPAgent = class {
   }
   async *stream(query, maxSteps, manageConnector = true, externalHistory, outputSchema) {
     if (this.isRemote && this.remoteAgent) {
-      const result = await this.remoteAgent.run(query, maxSteps, manageConnector, externalHistory, outputSchema);
+      const result = await this.remoteAgent.run(
+        query,
+        maxSteps,
+        manageConnector,
+        externalHistory,
+        outputSchema
+      );
       return result;
     }
     let initializedHere = false;
@@ -1829,27 +1960,31 @@ var MCPAgent = class {
       logger.info("\u{1F3C1} Starting agent execution");
       const maxRestarts = 3;
       let restartCount = 0;
-      const accumulatedMessages = [...langchainHistory, new HumanMessage(query)];
+      const accumulatedMessages = [
+        ...langchainHistory,
+        new HumanMessage(query)
+      ];
       while (restartCount <= maxRestarts) {
         const inputs = { messages: accumulatedMessages };
         let shouldRestart = false;
-        const stream = await this._agentExecutor.stream(
-          inputs,
-          {
-            streamMode: "updates",
-            // Get updates as they happen
-            callbacks: this.callbacks,
-            metadata: this.getMetadata(),
-            tags: this.getTags(),
-            // Set trace name for LangChain/Langfuse
-            runName: this.metadata.trace_name || "mcp-use-agent",
-            // Pass sessionId for Langfuse if present in metadata
-            ...this.metadata.session_id && { sessionId: this.metadata.session_id }
+        const stream = await this._agentExecutor.stream(inputs, {
+          streamMode: "updates",
+          // Get updates as they happen
+          callbacks: this.callbacks,
+          metadata: this.getMetadata(),
+          tags: this.getTags(),
+          // Set trace name for LangChain/Langfuse
+          runName: this.metadata.trace_name || "mcp-use-agent",
+          // Pass sessionId for Langfuse if present in metadata
+          ...this.metadata.session_id && {
+            sessionId: this.metadata.session_id
           }
-        );
+        });
         for await (const chunk of stream) {
           for (const [nodeName, nodeOutput] of Object.entries(chunk)) {
-            logger.debug(`\u{1F4E6} Node '${nodeName}' output: ${JSON.stringify(nodeOutput)}`);
+            logger.debug(
+              `\u{1F4E6} Node '${nodeName}' output: ${JSON.stringify(nodeOutput)}`
+            );
             if (nodeOutput && typeof nodeOutput === "object" && "messages" in nodeOutput) {
               let messages = nodeOutput.messages;
               if (!Array.isArray(messages)) {
@@ -1871,7 +2006,9 @@ var MCPAgent = class {
                     if (toolInputStr.length > 100) {
                       toolInputStr = `${toolInputStr.slice(0, 97)}...`;
                     }
-                    logger.info(`\u{1F527} Tool call: ${toolName} with input: ${toolInputStr}`);
+                    logger.info(
+                      `\u{1F527} Tool call: ${toolName} with input: ${toolInputStr}`
+                    );
                     yield {
                       action: {
                         tool: toolName,
@@ -1893,9 +2030,15 @@ var MCPAgent = class {
                   logger.info(`\u{1F4C4} Tool result: ${observationStr}`);
                   if (this.useServerManager && this.serverManager) {
                     const currentTools = this.serverManager.tools;
-                    const currentToolNames = new Set(currentTools.map((t) => t.name));
-                    const existingToolNames = new Set(this._tools.map((t) => t.name));
-                    if (currentToolNames.size !== existingToolNames.size || [...currentToolNames].some((n) => !existingToolNames.has(n))) {
+                    const currentToolNames = new Set(
+                      currentTools.map((t) => t.name)
+                    );
+                    const existingToolNames = new Set(
+                      this._tools.map((t) => t.name)
+                    );
+                    if (currentToolNames.size !== existingToolNames.size || [...currentToolNames].some(
+                      (n) => !existingToolNames.has(n)
+                    )) {
                       logger.info(
                         `\u{1F504} Tools changed during execution. New tools: ${[...currentToolNames].join(", ")}`
                       );
@@ -1930,7 +2073,9 @@ var MCPAgent = class {
           break;
         }
         if (restartCount > maxRestarts) {
-          logger.warn(`\u26A0\uFE0F Max restarts (${maxRestarts}) reached. Continuing with current tools.`);
+          logger.warn(
+            `\u26A0\uFE0F Max restarts (${maxRestarts}) reached. Continuing with current tools.`
+          );
           break;
         }
       }
@@ -1949,17 +2094,25 @@ var MCPAgent = class {
             outputSchema
           );
           if (this.memoryEnabled) {
-            this.addToHistory(new AIMessage(`Structured result: ${JSON.stringify(structuredResult)}`));
+            this.addToHistory(
+              new AIMessage(
+                `Structured result: ${JSON.stringify(structuredResult)}`
+              )
+            );
           }
           logger.info("\u2705 Structured output successful");
           success = true;
           return structuredResult;
         } catch (e) {
           logger.error(`\u274C Structured output failed: ${e}`);
-          throw new Error(`Failed to generate structured output: ${e instanceof Error ? e.message : String(e)}`);
+          throw new Error(
+            `Failed to generate structured output: ${e instanceof Error ? e.message : String(e)}`
+          );
         }
       }
-      logger.info(`\u{1F389} Agent execution complete in ${((Date.now() - startTime) / 1e3).toFixed(2)} seconds`);
+      logger.info(
+        `\u{1F389} Agent execution complete in ${((Date.now() - startTime) / 1e3).toFixed(2)} seconds`
+      );
       success = true;
       return finalOutput || "No output generated";
     } catch (e) {
@@ -1986,7 +2139,9 @@ var MCPAgent = class {
         modelProvider: this.modelProvider,
         modelName: this.modelName,
         serverCount,
-        serverIdentifiers: this.connectors.map((connector) => connector.publicIdentifier),
+        serverIdentifiers: this.connectors.map(
+          (connector) => connector.publicIdentifier
+        ),
         totalToolsAvailable: toolsAvailable.length,
         toolsAvailableNames: toolsAvailable.map((t) => t.name),
         maxStepsConfigured: this.maxSteps,
@@ -2090,7 +2245,10 @@ var MCPAgent = class {
           logger.info(`\u26A0\uFE0F Skipped message of type: ${msg.constructor.name}`);
         }
       }
-      const inputs = [...langchainHistory, new HumanMessage(query)];
+      const inputs = [
+        ...langchainHistory,
+        new HumanMessage(query)
+      ];
       logger.info("callbacks", this.callbacks);
       const eventStream = agentExecutor.streamEvents(
         { messages: inputs },
@@ -2103,7 +2261,9 @@ var MCPAgent = class {
           // Set trace name for LangChain/Langfuse
           runName: this.metadata.trace_name || "mcp-use-agent",
           // Pass sessionId for Langfuse if present in metadata
-          ...this.metadata.session_id && { sessionId: this.metadata.session_id }
+          ...this.metadata.session_id && {
+            sessionId: this.metadata.session_id
+          }
         }
       );
       for await (const event of eventStream) {
@@ -2122,7 +2282,9 @@ var MCPAgent = class {
             }
             const normalizedContent = this._normalizeOutput(chunk.content);
             finalResponse += normalizedContent;
-            logger.debug(`\u{1F4DD} Accumulated response length: ${finalResponse.length}`);
+            logger.debug(
+              `\u{1F4DD} Accumulated response length: ${finalResponse.length}`
+            );
           }
         }
         yield event;
@@ -2179,7 +2341,11 @@ var MCPAgent = class {
               data: { output: conversionResult }
             };
             if (this.memoryEnabled) {
-              this.addToHistory(new AIMessage(`Structured result: ${JSON.stringify(conversionResult)}`));
+              this.addToHistory(
+                new AIMessage(
+                  `Structured result: ${JSON.stringify(conversionResult)}`
+                )
+              );
             }
             logger.info("\u2705 Structured output successful");
           }
@@ -2198,7 +2364,9 @@ var MCPAgent = class {
     } catch (e) {
       logger.error(`\u274C Error during streamEvents: ${e}`);
       if (initializedHere && manageConnector) {
-        logger.info("\u{1F9F9} Cleaning up resources after initialization error in streamEvents");
+        logger.info(
+          "\u{1F9F9} Cleaning up resources after initialization error in streamEvents"
+        );
         await this.close();
       }
       throw e;
@@ -2218,7 +2386,9 @@ var MCPAgent = class {
         modelProvider: this.modelProvider,
         modelName: this.modelName,
         serverCount,
-        serverIdentifiers: this.connectors.map((connector) => connector.publicIdentifier),
+        serverIdentifiers: this.connectors.map(
+          (connector) => connector.publicIdentifier
+        ),
         totalToolsAvailable: this._tools.length,
         toolsAvailableNames: this._tools.map((t) => t.name),
         maxStepsConfigured: this.maxSteps,
@@ -2246,11 +2416,15 @@ var MCPAgent = class {
    * @param outputSchema - The Zod schema to validate against
    */
   async _attemptStructuredOutput(rawResult, llm, outputSchema) {
-    logger.info(`\u{1F504} Attempting structured output with schema: ${JSON.stringify(outputSchema, null, 2)}`);
+    logger.info(
+      `\u{1F504} Attempting structured output with schema: ${JSON.stringify(outputSchema, null, 2)}`
+    );
     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(zodToJsonSchema2(outputSchema), null, 2)}`);
+    logger.debug(
+      `\u{1F504} Structured output requested, schema: ${JSON.stringify(zodToJsonSchema2(outputSchema), null, 2)}`
+    );
     if (llm && "withStructuredOutput" in llm && typeof llm.withStructuredOutput === "function") {
       structuredLlm = llm.withStructuredOutput(outputSchema);
     } else if (llm) {
@@ -2302,11 +2476,17 @@ var MCPAgent = class {
         `;
       }
       try {
-        logger.info(`\u{1F504} Structured output attempt ${attempt} - using streaming approach`);
+        logger.info(
+          `\u{1F504} Structured output attempt ${attempt} - using streaming approach`
+        );
         const contentPreview = textContent.length > 300 ? `${textContent.slice(0, 300)}...` : textContent;
-        logger.info(`\u{1F504} Content being formatted (${textContent.length} chars): ${contentPreview}`);
-        logger.info(`\u{1F504} Full format prompt (${formatPrompt.length} chars):
-${formatPrompt}`);
+        logger.info(
+          `\u{1F504} Content being formatted (${textContent.length} chars): ${contentPreview}`
+        );
+        logger.info(
+          `\u{1F504} Full format prompt (${formatPrompt.length} chars):
+${formatPrompt}`
+        );
         const stream = await structuredLlm.stream(formatPrompt);
         let structuredResult = null;
         let chunkCount = 0;
@@ -2332,19 +2512,30 @@ ${formatPrompt}`);
             logger.info(`\u{1F504} Structured output streaming: ${chunkCount} chunks`);
           }
         }
-        logger.info(`\u{1F504} Structured result attempt ${attempt}: ${JSON.stringify(structuredResult, null, 2)}`);
+        logger.info(
+          `\u{1F504} Structured result attempt ${attempt}: ${JSON.stringify(structuredResult, null, 2)}`
+        );
         if (!structuredResult) {
           throw new Error("No structured result received from stream");
         }
-        const validatedResult = this._validateStructuredResult(structuredResult, outputSchema);
+        const validatedResult = this._validateStructuredResult(
+          structuredResult,
+          outputSchema
+        );
         logger.info(`\u2705 Structured output successful on attempt ${attempt}`);
         return validatedResult;
       } catch (e) {
         lastError = e instanceof Error ? e.message : String(e);
-        logger.warn(`\u26A0\uFE0F Structured output attempt ${attempt} failed: ${lastError}`);
+        logger.warn(
+          `\u26A0\uFE0F Structured output attempt ${attempt} failed: ${lastError}`
+        );
         if (attempt === maxRetries) {
-          logger.error(`\u274C All ${maxRetries} structured output attempts failed`);
-          throw new Error(`Failed to generate valid structured output after ${maxRetries} attempts. Last error: ${lastError}`);
+          logger.error(
+            `\u274C All ${maxRetries} structured output attempts failed`
+          );
+          throw new Error(
+            `Failed to generate valid structured output after ${maxRetries} attempts. Last error: ${lastError}`
+          );
         }
         continue;
       }
@@ -2359,14 +2550,18 @@ ${formatPrompt}`);
       const validatedResult = outputSchema.parse(structuredResult);
       const schemaType = outputSchema;
       if (schemaType._def && schemaType._def.shape) {
-        for (const [fieldName, fieldSchema] of Object.entries(schemaType._def.shape)) {
+        for (const [fieldName, fieldSchema] of Object.entries(
+          schemaType._def.shape
+        )) {
           const field = fieldSchema;
           const isOptional = field.isOptional?.() ?? field._def?.typeName === "ZodOptional";
           const isNullable = field.isNullable?.() ?? field._def?.typeName === "ZodNullable";
           if (!isOptional && !isNullable) {
             const value = validatedResult[fieldName];
             if (value === null || value === void 0 || typeof value === "string" && !value.trim() || Array.isArray(value) && value.length === 0) {
-              throw new Error(`Required field '${fieldName}' is missing or empty`);
+              throw new Error(
+                `Required field '${fieldName}' is missing or empty`
+              );
             }
           }
         }
@@ -2403,841 +2598,6 @@ ${formatPrompt}`);
   }
 };
 
-// src/session.ts
-var MCPSession = class {
-  static {
-    __name(this, "MCPSession");
-  }
-  connector;
-  autoConnect;
-  constructor(connector, autoConnect = true) {
-    this.connector = connector;
-    this.autoConnect = autoConnect;
-  }
-  async connect() {
-    await this.connector.connect();
-  }
-  async disconnect() {
-    await this.connector.disconnect();
-  }
-  async initialize() {
-    if (!this.isConnected && this.autoConnect) {
-      await this.connect();
-    }
-    await this.connector.initialize();
-  }
-  get isConnected() {
-    return this.connector && this.connector.isClientConnected;
-  }
-};
-
-// src/connectors/base.ts
-var BaseConnector = class {
-  static {
-    __name(this, "BaseConnector");
-  }
-  client = null;
-  connectionManager = null;
-  toolsCache = null;
-  connected = false;
-  opts;
-  constructor(opts = {}) {
-    this.opts = opts;
-  }
-  /** Disconnect and release resources. */
-  async disconnect() {
-    if (!this.connected) {
-      logger.debug("Not connected to MCP implementation");
-      return;
-    }
-    logger.debug("Disconnecting from MCP implementation");
-    await this.cleanupResources();
-    this.connected = false;
-    logger.debug("Disconnected from MCP implementation");
-  }
-  /** Check if the client is connected */
-  get isClientConnected() {
-    return this.client != null;
-  }
-  /**
-   * Initialise the MCP session **after** `connect()` has succeeded.
-   *
-   * In the SDK, `Client.connect(transport)` automatically performs the
-   * protocol‑level `initialize` handshake, so we only need to cache the list of
-   * tools and expose some server info.
-   */
-  async initialize(defaultRequestOptions = this.opts.defaultRequestOptions ?? {}) {
-    if (!this.client) {
-      throw new Error("MCP client is not connected");
-    }
-    logger.debug("Caching server capabilities & tools");
-    const capabilities = this.client.getServerCapabilities();
-    const listToolsRes = await this.client.listTools(void 0, defaultRequestOptions);
-    this.toolsCache = listToolsRes.tools ?? [];
-    logger.debug(`Fetched ${this.toolsCache.length} tools from server`);
-    return capabilities;
-  }
-  /** Lazily expose the cached tools list. */
-  get tools() {
-    if (!this.toolsCache) {
-      throw new Error("MCP client is not initialized; call initialize() first");
-    }
-    return this.toolsCache;
-  }
-  /** Call a tool on the server. */
-  async callTool(name, args, options) {
-    if (!this.client) {
-      throw new Error("MCP client is not connected");
-    }
-    logger.debug(`Calling tool '${name}' with args`, args);
-    const res = await this.client.callTool({ name, arguments: args }, void 0, options);
-    logger.debug(`Tool '${name}' returned`, res);
-    return res;
-  }
-  /**
-   * List resources from the server with optional pagination
-   * 
-   * @param cursor - Optional cursor for pagination
-   * @param options - Request options
-   * @returns Resource list with optional nextCursor for pagination
-   */
-  async listResources(cursor, options) {
-    if (!this.client) {
-      throw new Error("MCP client is not connected");
-    }
-    logger.debug("Listing resources", cursor ? `with cursor: ${cursor}` : "");
-    return await this.client.listResources({ cursor }, options);
-  }
-  /**
-   * List all resources from the server, automatically handling pagination
-   * 
-   * @param options - Request options
-   * @returns Complete list of all resources
-   */
-  async listAllResources(options) {
-    if (!this.client) {
-      throw new Error("MCP client is not connected");
-    }
-    logger.debug("Listing all resources (with auto-pagination)");
-    const allResources = [];
-    let cursor = void 0;
-    do {
-      const result = await this.client.listResources({ cursor }, options);
-      allResources.push(...result.resources || []);
-      cursor = result.nextCursor;
-    } while (cursor);
-    return { resources: allResources };
-  }
-  /**
-   * List resource templates from the server
-   * 
-   * @param options - Request options
-   * @returns List of available resource templates
-   */
-  async listResourceTemplates(options) {
-    if (!this.client) {
-      throw new Error("MCP client is not connected");
-    }
-    logger.debug("Listing resource templates");
-    return await this.client.listResourceTemplates(void 0, options);
-  }
-  /** Read a resource by URI. */
-  async readResource(uri, options) {
-    if (!this.client) {
-      throw new Error("MCP client is not connected");
-    }
-    logger.debug(`Reading resource ${uri}`);
-    const res = await this.client.readResource({ uri }, options);
-    return { content: res.content, mimeType: res.mimeType };
-  }
-  /**
-   * Subscribe to resource updates
-   * 
-   * @param uri - URI of the resource to subscribe to
-   * @param options - Request options
-   */
-  async subscribeToResource(uri, options) {
-    if (!this.client) {
-      throw new Error("MCP client is not connected");
-    }
-    logger.debug(`Subscribing to resource: ${uri}`);
-    return await this.client.subscribeResource({ uri }, options);
-  }
-  /**
-   * Unsubscribe from resource updates
-   * 
-   * @param uri - URI of the resource to unsubscribe from
-   * @param options - Request options
-   */
-  async unsubscribeFromResource(uri, options) {
-    if (!this.client) {
-      throw new Error("MCP client is not connected");
-    }
-    logger.debug(`Unsubscribing from resource: ${uri}`);
-    return await this.client.unsubscribeResource({ uri }, options);
-  }
-  async listPrompts() {
-    if (!this.client) {
-      throw new Error("MCP client is not connected");
-    }
-    logger.debug("Listing prompt");
-    return await this.client.listPrompts();
-  }
-  async getPrompt(name, args) {
-    if (!this.client) {
-      throw new Error("MCP client is not connected");
-    }
-    logger.debug(`Getting prompt ${name}`);
-    return await this.client.getPrompt({ name, arguments: args });
-  }
-  /** Send a raw request through the client. */
-  async request(method, params = null, options) {
-    if (!this.client) {
-      throw new Error("MCP client is not connected");
-    }
-    logger.debug(`Sending raw request '${method}' with params`, params);
-    return await this.client.request({ method, params: params ?? {} }, void 0, options);
-  }
-  /**
-   * Helper to tear down the client & connection manager safely.
-   */
-  async cleanupResources() {
-    const issues = [];
-    if (this.client) {
-      try {
-        if (typeof this.client.close === "function") {
-          await this.client.close();
-        }
-      } catch (e) {
-        const msg = `Error closing client: ${e}`;
-        logger.warn(msg);
-        issues.push(msg);
-      } finally {
-        this.client = null;
-      }
-    }
-    if (this.connectionManager) {
-      try {
-        await this.connectionManager.stop();
-      } catch (e) {
-        const msg = `Error stopping connection manager: ${e}`;
-        logger.warn(msg);
-        issues.push(msg);
-      } finally {
-        this.connectionManager = null;
-      }
-    }
-    this.toolsCache = null;
-    if (issues.length) {
-      logger.warn(`Resource cleanup finished with ${issues.length} issue(s)`);
-    }
-  }
-};
-
-// src/connectors/http.ts
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import { StreamableHTTPError } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
-
-// src/task_managers/sse.ts
-import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
-
-// src/task_managers/base.ts
-var ConnectionManager = class {
-  static {
-    __name(this, "ConnectionManager");
-  }
-  _readyPromise;
-  _readyResolver;
-  _donePromise;
-  _doneResolver;
-  _exception = null;
-  _connection = null;
-  _task = null;
-  _abortController = null;
-  constructor() {
-    this.reset();
-  }
-  /**
-   * Start the connection manager and establish a connection.
-   *
-   * @returns The established connection.
-   * @throws If the connection cannot be established.
-   */
-  async start() {
-    this.reset();
-    logger.debug(`Starting ${this.constructor.name}`);
-    this._task = this.connectionTask();
-    await this._readyPromise;
-    if (this._exception) {
-      throw this._exception;
-    }
-    if (this._connection === null) {
-      throw new Error("Connection was not established");
-    }
-    return this._connection;
-  }
-  /**
-   * Stop the connection manager and close the connection.
-   */
-  async stop() {
-    if (this._task && this._abortController) {
-      logger.debug(`Cancelling ${this.constructor.name} task`);
-      this._abortController.abort();
-      try {
-        await this._task;
-      } catch (e) {
-        if (e instanceof Error && e.name === "AbortError") {
-          logger.debug(`${this.constructor.name} task aborted successfully`);
-        } else {
-          logger.warn(`Error stopping ${this.constructor.name} task: ${e}`);
-        }
-      }
-    }
-    await this._donePromise;
-    logger.debug(`${this.constructor.name} task completed`);
-  }
-  /**
-   * Reset all internal state.
-   */
-  reset() {
-    this._readyPromise = new Promise((res) => this._readyResolver = res);
-    this._donePromise = new Promise((res) => this._doneResolver = res);
-    this._exception = null;
-    this._connection = null;
-    this._task = null;
-    this._abortController = new AbortController();
-  }
-  /**
-   * The background task responsible for establishing and maintaining the
-   * connection until it is cancelled.
-   */
-  async connectionTask() {
-    logger.debug(`Running ${this.constructor.name} task`);
-    try {
-      this._connection = await this.establishConnection();
-      logger.debug(`${this.constructor.name} connected successfully`);
-      this._readyResolver();
-      await this.waitForAbort();
-    } catch (err) {
-      this._exception = err;
-      logger.error(`Error in ${this.constructor.name} task: ${err}`);
-      this._readyResolver();
-    } finally {
-      if (this._connection !== null) {
-        try {
-          await this.closeConnection(this._connection);
-        } catch (closeErr) {
-          logger.warn(`Error closing connection in ${this.constructor.name}: ${closeErr}`);
-        }
-        this._connection = null;
-      }
-      this._doneResolver();
-    }
-  }
-  /**
-   * Helper that returns a promise which resolves when the abort signal fires.
-   */
-  async waitForAbort() {
-    return new Promise((_resolve, _reject) => {
-      if (!this._abortController) {
-        return;
-      }
-      const signal = this._abortController.signal;
-      if (signal.aborted) {
-        _resolve();
-        return;
-      }
-      const onAbort = /* @__PURE__ */ __name(() => {
-        signal.removeEventListener("abort", onAbort);
-        _resolve();
-      }, "onAbort");
-      signal.addEventListener("abort", onAbort);
-    });
-  }
-};
-
-// src/task_managers/sse.ts
-var SseConnectionManager = class extends ConnectionManager {
-  static {
-    __name(this, "SseConnectionManager");
-  }
-  url;
-  opts;
-  _transport = null;
-  /**
-   * Create an SSE connection manager.
-   *
-   * @param url  The SSE endpoint URL.
-   * @param opts Optional transport options (auth, headers, etc.).
-   */
-  constructor(url, opts) {
-    super();
-    this.url = typeof url === "string" ? new URL(url) : url;
-    this.opts = opts;
-  }
-  /**
-   * Spawn a new `SSEClientTransport` and start the connection.
-   */
-  async establishConnection() {
-    this._transport = new SSEClientTransport(this.url, this.opts);
-    logger.debug(`${this.constructor.name} connected successfully`);
-    return this._transport;
-  }
-  /**
-   * Close the underlying transport and clean up resources.
-   */
-  async closeConnection(_connection) {
-    if (this._transport) {
-      try {
-        await this._transport.close();
-      } catch (e) {
-        logger.warn(`Error closing SSE transport: ${e}`);
-      } finally {
-        this._transport = null;
-      }
-    }
-  }
-};
-
-// src/task_managers/streamable_http.ts
-import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
-var StreamableHttpConnectionManager = class extends ConnectionManager {
-  static {
-    __name(this, "StreamableHttpConnectionManager");
-  }
-  url;
-  opts;
-  _transport = null;
-  /**
-   * Create a Streamable HTTP connection manager.
-   *
-   * @param url  The HTTP endpoint URL.
-   * @param opts Optional transport options (auth, headers, etc.).
-   */
-  constructor(url, opts) {
-    super();
-    this.url = typeof url === "string" ? new URL(url) : url;
-    this.opts = opts;
-  }
-  /**
-   * Spawn a new `StreamableHTTPClientTransport` and return it.
-   * The Client.connect() method will handle starting the transport.
-   */
-  async establishConnection() {
-    this._transport = new StreamableHTTPClientTransport(this.url, this.opts);
-    logger.debug(`${this.constructor.name} created successfully`);
-    return this._transport;
-  }
-  /**
-   * Close the underlying transport and clean up resources.
-   */
-  async closeConnection(_connection) {
-    if (this._transport) {
-      try {
-        await this._transport.close();
-      } catch (e) {
-        logger.warn(`Error closing Streamable HTTP transport: ${e}`);
-      } finally {
-        this._transport = null;
-      }
-    }
-  }
-  /**
-   * Get the session ID from the transport if available.
-   */
-  get sessionId() {
-    return this._transport?.sessionId;
-  }
-};
-
-// src/connectors/http.ts
-var HttpConnector = class extends BaseConnector {
-  static {
-    __name(this, "HttpConnector");
-  }
-  baseUrl;
-  headers;
-  timeout;
-  sseReadTimeout;
-  clientInfo;
-  preferSse;
-  transportType = null;
-  constructor(baseUrl, opts = {}) {
-    super(opts);
-    this.baseUrl = baseUrl.replace(/\/$/, "");
-    this.headers = { ...opts.headers ?? {} };
-    if (opts.authToken) {
-      this.headers.Authorization = `Bearer ${opts.authToken}`;
-    }
-    this.timeout = opts.timeout ?? 3e4;
-    this.sseReadTimeout = opts.sseReadTimeout ?? 3e5;
-    this.clientInfo = opts.clientInfo ?? { name: "http-connector", version: "1.0.0" };
-    this.preferSse = opts.preferSse ?? false;
-  }
-  /** Establish connection to the MCP implementation via HTTP (streamable or SSE). */
-  async connect() {
-    if (this.connected) {
-      logger.debug("Already connected to MCP implementation");
-      return;
-    }
-    const baseUrl = this.baseUrl;
-    if (this.preferSse) {
-      logger.debug(`Connecting to MCP implementation via HTTP/SSE: ${baseUrl}`);
-      await this.connectWithSse(baseUrl);
-      return;
-    }
-    logger.debug(`Connecting to MCP implementation via HTTP: ${baseUrl}`);
-    try {
-      logger.info("\u{1F504} Attempting streamable HTTP transport...");
-      await this.connectWithStreamableHttp(baseUrl);
-      logger.info("\u2705 Successfully connected via streamable HTTP");
-    } catch (err) {
-      let fallbackReason = "Unknown error";
-      if (err instanceof StreamableHTTPError) {
-        if (err.code === 400 && err.message.includes("Missing session ID")) {
-          fallbackReason = "Server requires session ID (FastMCP compatibility) - using SSE transport";
-          logger.warn(`\u26A0\uFE0F  ${fallbackReason}`);
-        } else if (err.code === 404 || err.code === 405) {
-          fallbackReason = `Server returned ${err.code} - server likely doesn't support streamable HTTP`;
-          logger.debug(fallbackReason);
-        } else {
-          fallbackReason = `Server returned ${err.code}: ${err.message}`;
-          logger.debug(fallbackReason);
-        }
-      } else if (err instanceof Error) {
-        const errorStr = err.toString();
-        const errorMsg = err.message || "";
-        if (errorStr.includes("Missing session ID") || errorStr.includes("Bad Request: Missing session ID") || errorMsg.includes("FastMCP session ID error")) {
-          fallbackReason = "Server requires session ID (FastMCP compatibility) - using SSE transport";
-          logger.warn(`\u26A0\uFE0F  ${fallbackReason}`);
-        } else if (errorStr.includes("405 Method Not Allowed") || errorStr.includes("404 Not Found")) {
-          fallbackReason = "Server doesn't support streamable HTTP (405/404)";
-          logger.debug(fallbackReason);
-        } else {
-          fallbackReason = `Streamable HTTP failed: ${err.message}`;
-          logger.debug(fallbackReason);
-        }
-      }
-      logger.info("\u{1F504} Falling back to SSE transport...");
-      try {
-        await this.connectWithSse(baseUrl);
-      } catch (sseErr) {
-        logger.error(`Failed to connect with both transports:`);
-        logger.error(`  Streamable HTTP: ${fallbackReason}`);
-        logger.error(`  SSE: ${sseErr}`);
-        await this.cleanupResources();
-        throw new Error("Could not connect to server with any available transport");
-      }
-    }
-  }
-  async connectWithStreamableHttp(baseUrl) {
-    try {
-      this.connectionManager = new StreamableHttpConnectionManager(
-        baseUrl,
-        {
-          requestInit: {
-            headers: this.headers
-          },
-          // Pass through timeout and other options
-          reconnectionOptions: {
-            maxReconnectionDelay: 3e4,
-            initialReconnectionDelay: 1e3,
-            reconnectionDelayGrowFactor: 1.5,
-            maxRetries: 2
-          }
-        }
-      );
-      const transport = await this.connectionManager.start();
-      this.client = new Client(this.clientInfo, this.opts.clientOptions);
-      try {
-        await this.client.connect(transport);
-      } catch (connectErr) {
-        if (connectErr instanceof Error) {
-          const errMsg = connectErr.message || connectErr.toString();
-          if (errMsg.includes("Missing session ID") || errMsg.includes("Bad Request: Missing session ID")) {
-            const wrappedError = new Error(`FastMCP session ID error: ${errMsg}`);
-            wrappedError.cause = connectErr;
-            throw wrappedError;
-          }
-        }
-        throw connectErr;
-      }
-      this.connected = true;
-      this.transportType = "streamable-http";
-      logger.debug(`Successfully connected to MCP implementation via streamable HTTP: ${baseUrl}`);
-    } catch (err) {
-      await this.cleanupResources();
-      throw err;
-    }
-  }
-  async connectWithSse(baseUrl) {
-    try {
-      this.connectionManager = new SseConnectionManager(
-        baseUrl,
-        {
-          requestInit: {
-            headers: this.headers
-          }
-        }
-      );
-      const transport = await this.connectionManager.start();
-      this.client = new Client(this.clientInfo, this.opts.clientOptions);
-      await this.client.connect(transport);
-      this.connected = true;
-      this.transportType = "sse";
-      logger.debug(`Successfully connected to MCP implementation via HTTP/SSE: ${baseUrl}`);
-    } catch (err) {
-      await this.cleanupResources();
-      throw err;
-    }
-  }
-  get publicIdentifier() {
-    return {
-      type: "http",
-      url: this.baseUrl,
-      transport: this.transportType || "unknown"
-    };
-  }
-  /**
-   * Get the transport type being used (streamable-http or sse)
-   */
-  getTransportType() {
-    return this.transportType;
-  }
-};
-
-// src/connectors/websocket.ts
-import { v4 as uuidv42 } from "uuid";
-
-// src/task_managers/websocket.ts
-import WS from "ws";
-var WebSocketConnectionManager = class extends ConnectionManager {
-  static {
-    __name(this, "WebSocketConnectionManager");
-  }
-  url;
-  headers;
-  _ws = null;
-  /**
-   * @param url     The WebSocket URL to connect to.
-   * @param headers Optional headers to include in the connection handshake.
-   */
-  constructor(url, headers = {}) {
-    super();
-    this.url = url;
-    this.headers = headers;
-  }
-  /** Establish a WebSocket connection and wait until it is open. */
-  async establishConnection() {
-    logger.debug(`Connecting to WebSocket: ${this.url}`);
-    return new Promise((resolve, reject) => {
-      const ws = new WS(this.url, { headers: this.headers });
-      this._ws = ws;
-      const onOpen = /* @__PURE__ */ __name(() => {
-        cleanup();
-        logger.debug("WebSocket connected successfully");
-        resolve(ws);
-      }, "onOpen");
-      const onError = /* @__PURE__ */ __name((err) => {
-        cleanup();
-        logger.error(`Failed to connect to WebSocket: ${err}`);
-        reject(err);
-      }, "onError");
-      const cleanup = /* @__PURE__ */ __name(() => {
-        ws.off("open", onOpen);
-        ws.off("error", onError);
-      }, "cleanup");
-      ws.on("open", onOpen);
-      ws.on("error", onError);
-    });
-  }
-  /** Cleanly close the WebSocket connection. */
-  async closeConnection(connection) {
-    logger.debug("Closing WebSocket connection");
-    return new Promise((resolve) => {
-      const onClose = /* @__PURE__ */ __name(() => {
-        connection.off("close", onClose);
-        this._ws = null;
-        resolve();
-      }, "onClose");
-      if (connection.readyState === WS.CLOSED) {
-        onClose();
-        return;
-      }
-      connection.on("close", onClose);
-      try {
-        connection.close();
-      } catch (e) {
-        logger.warn(`Error closing WebSocket connection: ${e}`);
-        onClose();
-      }
-    });
-  }
-};
-
-// src/connectors/websocket.ts
-var WebSocketConnector = class extends BaseConnector {
-  static {
-    __name(this, "WebSocketConnector");
-  }
-  url;
-  headers;
-  connectionManager = null;
-  ws = null;
-  receiverTask = null;
-  pending = /* @__PURE__ */ new Map();
-  toolsCache = null;
-  constructor(url, opts = {}) {
-    super();
-    this.url = url;
-    this.headers = { ...opts.headers ?? {} };
-    if (opts.authToken)
-      this.headers.Authorization = `Bearer ${opts.authToken}`;
-  }
-  async connect() {
-    if (this.connected) {
-      logger.debug("Already connected to MCP implementation");
-      return;
-    }
-    logger.debug(`Connecting via WebSocket: ${this.url}`);
-    try {
-      this.connectionManager = new WebSocketConnectionManager(this.url, this.headers);
-      this.ws = await this.connectionManager.start();
-      this.receiverTask = this.receiveLoop();
-      this.connected = true;
-      logger.debug("WebSocket connected successfully");
-    } catch (e) {
-      logger.error(`Failed to connect: ${e}`);
-      await this.cleanupResources();
-      throw e;
-    }
-  }
-  async disconnect() {
-    if (!this.connected) {
-      logger.debug("Not connected to MCP implementation");
-      return;
-    }
-    logger.debug("Disconnecting \u2026");
-    await this.cleanupResources();
-    this.connected = false;
-  }
-  sendRequest(method, params = null) {
-    if (!this.ws)
-      throw new Error("WebSocket is not connected");
-    const id = uuidv42();
-    const payload = JSON.stringify({ id, method, params: params ?? {} });
-    return new Promise((resolve, reject) => {
-      this.pending.set(id, { resolve, reject });
-      this.ws.send(payload, (err) => {
-        if (err) {
-          this.pending.delete(id);
-          reject(err);
-        }
-      });
-    });
-  }
-  async receiveLoop() {
-    if (!this.ws)
-      return;
-    const socket = this.ws;
-    const onMessage = /* @__PURE__ */ __name((msg) => {
-      let data;
-      try {
-        data = JSON.parse(msg.data ?? msg);
-      } catch (e) {
-        logger.warn("Received non\u2011JSON frame", e);
-        return;
-      }
-      const id = data.id;
-      if (id && this.pending.has(id)) {
-        const { resolve, reject } = this.pending.get(id);
-        this.pending.delete(id);
-        if ("result" in data)
-          resolve(data.result);
-        else if ("error" in data)
-          reject(data.error);
-      } else {
-        logger.debug("Received unsolicited message", data);
-      }
-    }, "onMessage");
-    if (socket.addEventListener) {
-      socket.addEventListener("message", onMessage);
-    } else {
-      socket.on("message", onMessage);
-    }
-    return new Promise((resolve) => {
-      const onClose = /* @__PURE__ */ __name(() => {
-        if (socket.removeEventListener) {
-          socket.removeEventListener("message", onMessage);
-        } else {
-          socket.off("message", onMessage);
-        }
-        this.rejectAll(new Error("WebSocket closed"));
-        resolve();
-      }, "onClose");
-      if (socket.addEventListener) {
-        socket.addEventListener("close", onClose);
-      } else {
-        socket.on("close", onClose);
-      }
-    });
-  }
-  rejectAll(err) {
-    for (const { reject } of this.pending.values()) reject(err);
-    this.pending.clear();
-  }
-  async initialize() {
-    logger.debug("Initializing MCP session over WebSocket");
-    const result = await this.sendRequest("initialize");
-    const toolsList = await this.listTools();
-    this.toolsCache = toolsList.map((t) => t);
-    logger.debug(`Initialized with ${this.toolsCache.length} tools`);
-    return result;
-  }
-  async listTools() {
-    const res = await this.sendRequest("tools/list");
-    return res.tools ?? [];
-  }
-  async callTool(name, args) {
-    return await this.sendRequest("tools/call", { name, arguments: args });
-  }
-  async listResources() {
-    const resources = await this.sendRequest("resources/list");
-    return { resources: Array.isArray(resources) ? resources : [] };
-  }
-  async readResource(uri) {
-    const res = await this.sendRequest("resources/read", { uri });
-    return { content: res.content, mimeType: res.mimeType };
-  }
-  async request(method, params = null) {
-    return await this.sendRequest(method, params);
-  }
-  get tools() {
-    if (!this.toolsCache)
-      throw new Error("MCP client is not initialized");
-    return this.toolsCache;
-  }
-  async cleanupResources() {
-    if (this.receiverTask)
-      await this.receiverTask.catch(() => {
-      });
-    this.receiverTask = null;
-    this.rejectAll(new Error("WebSocket disconnected"));
-    if (this.connectionManager) {
-      await this.connectionManager.stop();
-      this.connectionManager = null;
-      this.ws = null;
-    }
-    this.toolsCache = null;
-  }
-  get publicIdentifier() {
-    return {
-      type: "websocket",
-      url: this.url
-    };
-  }
-};
-
 // src/agents/utils/ai_sdk.ts
 async function* streamEventsToAISDK(streamEvents) {
   for await (const event of streamEvents) {
@@ -3293,119 +2653,6 @@ async function* streamEventsToAISDKWithTools(streamEvents) {
 }
 __name(streamEventsToAISDKWithTools, "streamEventsToAISDKWithTools");
 
-// src/client/base.ts
-var BaseMCPClient = class {
-  static {
-    __name(this, "BaseMCPClient");
-  }
-  config = {};
-  sessions = {};
-  activeSessions = [];
-  constructor(config) {
-    if (config) {
-      this.config = config;
-    }
-  }
-  static fromDict(_cfg) {
-    throw new Error("fromDict must be implemented by concrete class");
-  }
-  addServer(name, serverConfig) {
-    this.config.mcpServers = this.config.mcpServers || {};
-    this.config.mcpServers[name] = serverConfig;
-  }
-  removeServer(name) {
-    if (this.config.mcpServers?.[name]) {
-      delete this.config.mcpServers[name];
-      this.activeSessions = this.activeSessions.filter((n) => n !== name);
-    }
-  }
-  getServerNames() {
-    return Object.keys(this.config.mcpServers ?? {});
-  }
-  getServerConfig(name) {
-    return this.config.mcpServers?.[name];
-  }
-  getConfig() {
-    return this.config ?? {};
-  }
-  async createSession(serverName, autoInitialize = true) {
-    const servers = this.config.mcpServers ?? {};
-    if (Object.keys(servers).length === 0) {
-      logger.warn("No MCP servers defined in config");
-    }
-    if (!servers[serverName]) {
-      throw new Error(`Server '${serverName}' not found in config`);
-    }
-    const connector = this.createConnectorFromConfig(servers[serverName]);
-    const session = new MCPSession(connector);
-    if (autoInitialize) {
-      await session.initialize();
-    }
-    this.sessions[serverName] = session;
-    if (!this.activeSessions.includes(serverName)) {
-      this.activeSessions.push(serverName);
-    }
-    return session;
-  }
-  async createAllSessions(autoInitialize = true) {
-    const servers = this.config.mcpServers ?? {};
-    if (Object.keys(servers).length === 0) {
-      logger.warn("No MCP servers defined in config");
-    }
-    for (const name of Object.keys(servers)) {
-      await this.createSession(name, autoInitialize);
-    }
-    return this.sessions;
-  }
-  getSession(serverName) {
-    const session = this.sessions[serverName];
-    if (!session) {
-      return null;
-    }
-    return session;
-  }
-  getAllActiveSessions() {
-    return Object.fromEntries(
-      this.activeSessions.map((n) => [n, this.sessions[n]])
-    );
-  }
-  async closeSession(serverName) {
-    const session = this.sessions[serverName];
-    if (!session) {
-      logger.warn(`No session exists for server ${serverName}, nothing to close`);
-      return;
-    }
-    try {
-      logger.debug(`Closing session for server ${serverName}`);
-      await session.disconnect();
-    } catch (e) {
-      logger.error(`Error closing session for server '${serverName}': ${e}`);
-    } finally {
-      delete this.sessions[serverName];
-      this.activeSessions = this.activeSessions.filter((n) => n !== serverName);
-    }
-  }
-  async closeAllSessions() {
-    const serverNames = Object.keys(this.sessions);
-    const errors = [];
-    for (const serverName of serverNames) {
-      try {
-        logger.debug(`Closing session for server ${serverName}`);
-        await this.closeSession(serverName);
-      } catch (e) {
-        const errorMsg = `Failed to close session for server '${serverName}': ${e}`;
-        logger.error(errorMsg);
-        errors.push(errorMsg);
-      }
-    }
-    if (errors.length) {
-      logger.error(`Encountered ${errors.length} errors while closing sessions`);
-    } else {
-      logger.debug("All sessions closed successfully");
-    }
-  }
-};
-
 export {
   BaseAdapter,
   LangChainAdapter,
@@ -3420,12 +2667,6 @@ export {
   setTelemetrySource,
   RemoteAgent,
   MCPAgent,
-  MCPSession,
-  BaseMCPClient,
-  ConnectionManager,
-  BaseConnector,
-  HttpConnector,
-  WebSocketConnector,
   streamEventsToAISDK,
   createReadableStreamFromGenerator,
   streamEventsToAISDKWithTools