mcp-use 1.1.8-canary.1 → 1.2.0-canary.0

package/dist/src/browser.cjs

@@ -280,7 +280,7 @@ async function initializeLangfuse(agentId, metadata, metadataProvider, tagsProvi
   try {
     const langfuseModule = await import("langfuse-langchain").catch(() => null);
     if (!langfuseModule) {
-      logger.debug("Langfuse package not installed - tracing disabled. Install with: npm install langfuse-langchain");
+      logger.debug("Langfuse package not installed - tracing disabled. Install with: npm install @langfuse/langchain");
       return;
     }
     const { CallbackHandler } = langfuseModule;
@@ -407,6 +407,8 @@ async function initializeLangfuse(agentId, metadata, metadataProvider, tagsProvi
         return super.handleAgentEnd(...args);
       }
     }
+    const initialMetadata = metadata || (metadataProvider ? metadataProvider() : {});
+    const initialTags = tagsProvider ? tagsProvider() : [];
     const config2 = {
       publicKey: process.env.LANGFUSE_PUBLIC_KEY,
       secretKey: process.env.LANGFUSE_SECRET_KEY,
@@ -415,8 +417,21 @@ async function initializeLangfuse(agentId, metadata, metadataProvider, tagsProvi
       flushInterval: Number.parseInt(process.env.LANGFUSE_FLUSH_INTERVAL || "10000"),
       release: process.env.LANGFUSE_RELEASE,
       requestTimeout: Number.parseInt(process.env.LANGFUSE_REQUEST_TIMEOUT || "10000"),
-      enabled: process.env.LANGFUSE_ENABLED !== "false"
+      enabled: process.env.LANGFUSE_ENABLED !== "false",
+      // Set trace name - can be customized via metadata.trace_name or defaults to 'mcp-use-agent'
+      traceName: initialMetadata.trace_name || process.env.LANGFUSE_TRACE_NAME || "mcp-use-agent",
+      // Pass sessionId, userId, and tags to the handler
+      sessionId: initialMetadata.session_id || void 0,
+      userId: initialMetadata.user_id || void 0,
+      tags: initialTags.length > 0 ? initialTags : void 0,
+      metadata: initialMetadata || void 0
     };
+    logger.debug("Langfuse handler config:", JSON.stringify({
+      traceName: config2.traceName,
+      sessionId: config2.sessionId,
+      userId: config2.userId,
+      tags: config2.tags
+    }, null, 2));
     langfuseState.handler = new LoggingCallbackHandler(config2, agentId, metadata, metadataProvider, tagsProvider);
     logger.debug("Langfuse observability initialized successfully with logging enabled");
     try {
@@ -469,13 +484,13 @@ var init_langfuse = __esm({
 // src/browser.ts
 var browser_exports = {};
 __export(browser_exports, {
-  AIMessage: () => import_messages3.AIMessage,
+  AIMessage: () => import_messages2.AIMessage,
   BaseAdapter: () => BaseAdapter,
   BaseConnector: () => BaseConnector,
-  BaseMessage: () => import_messages3.BaseMessage,
+  BaseMessage: () => import_messages2.BaseMessage,
   BrowserOAuthClientProvider: () => BrowserOAuthClientProvider,
   HttpConnector: () => HttpConnector,
-  HumanMessage: () => import_messages3.HumanMessage,
+  HumanMessage: () => import_messages2.HumanMessage,
   LangChainAdapter: () => LangChainAdapter,
   Logger: () => Logger,
   MCPAgent: () => MCPAgent,
@@ -483,8 +498,8 @@ __export(browser_exports, {
   MCPSession: () => MCPSession,
   ObservabilityManager: () => ObservabilityManager,
   RemoteAgent: () => RemoteAgent,
-  SystemMessage: () => import_messages3.SystemMessage,
-  ToolMessage: () => import_messages3.ToolMessage,
+  SystemMessage: () => import_messages2.SystemMessage,
+  ToolMessage: () => import_messages2.ToolMessage,
   WebSocketConnector: () => WebSocketConnector,
   createReadableStreamFromGenerator: () => createReadableStreamFromGenerator,
   logger: () => logger,
@@ -1487,11 +1502,8 @@ var BrowserMCPClient = class _BrowserMCPClient extends BaseMCPClient {
 };
 
 // src/agents/mcp_agent.ts
-var import_manager2 = require("@langchain/core/callbacks/manager");
-var import_messages2 = require("@langchain/core/messages");
-var import_output_parsers = require("@langchain/core/output_parsers");
-var import_prompts = require("@langchain/core/prompts");
-var import_agents = require("langchain/agents");
+var import_messages = require("@langchain/core/messages");
+var import_langchain2 = require("langchain");
 var import_zod_to_json_schema2 = require("zod-to-json-schema");
 
 // src/adapters/langchain_adapter.ts
@@ -1712,7 +1724,7 @@ var AcquireActiveMCPServerTool = class extends MCPServerTool {
 };
 
 // src/managers/tools/add_server_from_config.ts
-var import_tools3 = require("langchain/tools");
+var import_tools3 = require("@langchain/core/tools");
 var import_zod3 = require("zod");
 init_logging();
 var AddMCPServerFromConfigTool = class extends import_tools3.StructuredTool {
@@ -2085,6 +2097,23 @@ var ObservabilityManager = class {
     const callbacks = await this.getCallbacks();
     return callbacks.length > 0;
   }
+  /**
+   * Get the current observability status including metadata and tags.
+   * @returns Object containing enabled status, callback count, handler names, metadata, and tags.
+   */
+  async getStatus() {
+    const callbacks = await this.getCallbacks();
+    const handlerNames = await this.getHandlerNames();
+    const currentMetadata = this.metadataProvider ? this.metadataProvider() : this.metadata || {};
+    const currentTags = this.tagsProvider ? this.tagsProvider() : [];
+    return {
+      enabled: this.observe && callbacks.length > 0,
+      callbackCount: callbacks.length,
+      handlerNames,
+      metadata: currentMetadata,
+      tags: currentTags
+    };
+  }
   /**
    * Add a callback to the custom callbacks list.
    * @param callback The callback to add.
@@ -2516,7 +2545,7 @@ var Telemetry = class _Telemetry {
 };
 
 // src/agents/prompts/system_prompt_builder.ts
-var import_messages = require("@langchain/core/messages");
+var import_langchain = require("langchain");
 function generateToolDescriptions(tools, disallowedTools) {
   const disallowedSet = new Set(disallowedTools ?? []);
   const descriptions = [];
@@ -2551,7 +2580,7 @@ ${additionalInstructions}`;
 __name(buildSystemPromptContent, "buildSystemPromptContent");
 function createSystemMessage(tools, systemPromptTemplate, serverManagerTemplate, useServerManager, disallowedTools, userProvidedPrompt, additionalInstructions) {
   if (userProvidedPrompt) {
-    return new import_messages.SystemMessage({ content: userProvidedPrompt });
+    return new import_langchain.SystemMessage({ content: userProvidedPrompt });
   }
   const template = useServerManager ? serverManagerTemplate : systemPromptTemplate;
   const toolLines = generateToolDescriptions(tools, disallowedTools);
@@ -2560,7 +2589,7 @@ function createSystemMessage(tools, systemPromptTemplate, serverManagerTemplate,
     toolLines,
     additionalInstructions
   );
-  return new import_messages.SystemMessage({ content: finalContent });
+  return new import_langchain.SystemMessage({ content: finalContent });
 }
 __name(createSystemMessage, "createSystemMessage");
 
@@ -2837,6 +2866,7 @@ var MCPAgent = class {
   memoryEnabled;
   disallowedTools;
   additionalTools;
+  toolsUsedNames = [];
   useServerManager;
   verbose;
   observe;
@@ -2904,6 +2934,7 @@ var MCPAgent = class {
     this.additionalInstructions = options.additionalInstructions ?? null;
     this.disallowedTools = options.disallowedTools ?? [];
     this.additionalTools = options.additionalTools ?? [];
+    this.toolsUsedNames = options.toolsUsedNames ?? [];
     this.useServerManager = options.useServerManager ?? false;
     this.verbose = options.verbose ?? false;
     this.observe = options.observe ?? true;
@@ -3018,7 +3049,7 @@ var MCPAgent = class {
     if (this.memoryEnabled) {
       this.conversationHistory = [
         this.systemMessage,
-        ...this.conversationHistory.filter((m) => !(m instanceof import_messages2.SystemMessage))
+        ...this.conversationHistory.filter((m) => !(m instanceof import_langchain2.SystemMessage))
       ];
     }
   }
@@ -3027,25 +3058,17 @@ var MCPAgent = class {
       throw new Error("LLM is required to create agent");
     }
     const systemContent = this.systemMessage?.content ?? "You are a helpful assistant.";
-    const prompt = import_prompts.ChatPromptTemplate.fromMessages([
-      ["system", systemContent],
-      new import_prompts.MessagesPlaceholder("chat_history"),
-      ["human", "{input}"],
-      new import_prompts.MessagesPlaceholder("agent_scratchpad")
-    ]);
-    const agent = (0, import_agents.createToolCallingAgent)({
-      llm: this.llm,
-      tools: this._tools,
-      prompt
-    });
-    return new import_agents.AgentExecutor({
-      agent,
+    const toolNames = this._tools.map((tool) => tool.name);
+    logger.info(`\u{1F9E0} Agent ready with tools: ${toolNames.join(", ")}`);
+    const middleware = [(0, import_langchain2.modelCallLimitMiddleware)({ runLimit: this.maxSteps })];
+    const agent = (0, import_langchain2.createAgent)({
+      model: this.llm,
       tools: this._tools,
-      maxIterations: this.maxSteps,
-      verbose: this.verbose,
-      returnIntermediateSteps: true,
-      callbacks: this.callbacks
+      systemPrompt: systemContent,
+      middleware
     });
+    logger.debug(`Created agent with max_steps=${this.maxSteps} (via ModelCallLimitMiddleware) and ${this.callbacks.length} callbacks`);
+    return agent;
   }
   getConversationHistory() {
     return [...this.conversationHistory];
@@ -3061,9 +3084,9 @@ var MCPAgent = class {
     return this.systemMessage;
   }
   setSystemMessage(message) {
-    this.systemMessage = new import_messages2.SystemMessage(message);
+    this.systemMessage = new import_langchain2.SystemMessage(message);
     if (this.memoryEnabled) {
-      this.conversationHistory = this.conversationHistory.filter((m) => !(m instanceof import_messages2.SystemMessage));
+      this.conversationHistory = this.conversationHistory.filter((m) => !(m instanceof import_langchain2.SystemMessage));
       this.conversationHistory.unshift(this.systemMessage);
     }
     if (this._initialized && this._tools.length) {
@@ -3213,6 +3236,42 @@ var MCPAgent = class {
     }
     return serverInfo;
   }
+  _normalizeOutput(value) {
+    try {
+      if (typeof value === "string") {
+        return value;
+      }
+      if (value && typeof value === "object" && "content" in value) {
+        return this._normalizeOutput(value.content);
+      }
+      if (Array.isArray(value)) {
+        const parts = [];
+        for (const item of value) {
+          if (typeof item === "object" && item !== null) {
+            if ("text" in item && typeof item.text === "string") {
+              parts.push(item.text);
+            } else if ("content" in item) {
+              parts.push(this._normalizeOutput(item.content));
+            } else {
+              parts.push(String(item));
+            }
+          } else {
+            const partText = item && typeof item === "object" && "text" in item ? item.text : null;
+            if (typeof partText === "string") {
+              parts.push(partText);
+            } else {
+              const partContent = item && typeof item === "object" && "content" in item ? item.content : item;
+              parts.push(this._normalizeOutput(partContent));
+            }
+          }
+        }
+        return parts.join("");
+      }
+      return String(value);
+    } catch (error) {
+      return String(value);
+    }
+  }
   async _consumeAndReturn(generator) {
     while (true) {
       const { done, value } = await generator.next();
@@ -3234,36 +3293,16 @@ var MCPAgent = class {
     );
     return this._consumeAndReturn(generator);
   }
-  /**
-   * Runs the agent and yields intermediate steps as an async generator.
-   * If outputSchema is provided, returns structured output of type T.
-   */
   async *stream(query, maxSteps, manageConnector = true, externalHistory, outputSchema) {
     if (this.isRemote && this.remoteAgent) {
-      const result2 = await this.remoteAgent.run(query, maxSteps, manageConnector, externalHistory, outputSchema);
-      return result2;
+      const result = await this.remoteAgent.run(query, maxSteps, manageConnector, externalHistory, outputSchema);
+      return result;
     }
-    let result = "";
     let initializedHere = false;
     const startTime = Date.now();
-    const toolsUsedNames = [];
+    let success = false;
+    let finalOutput = null;
     let stepsTaken = 0;
-    const structuredOutputSuccess = false;
-    const structuredOutputSuccessRef = { value: structuredOutputSuccess };
-    let structuredLlm = null;
-    let schemaDescription = "";
-    if (outputSchema) {
-      query = this._enhanceQueryWithSchema(query, outputSchema);
-      logger.debug(`\u{1F504} Structured output requested, schema: ${JSON.stringify((0, import_zod_to_json_schema2.zodToJsonSchema)(outputSchema), null, 2)}`);
-      if (this.llm && "withStructuredOutput" in this.llm && typeof this.llm.withStructuredOutput === "function") {
-        structuredLlm = this.llm.withStructuredOutput(outputSchema);
-      } else if (this.llm) {
-        structuredLlm = this.llm;
-      } else {
-        throw new Error("LLM is required for structured output");
-      }
-      schemaDescription = JSON.stringify((0, import_zod_to_json_schema2.zodToJsonSchema)(outputSchema), null, 2);
-    }
     try {
       if (manageConnector && !this._initialized) {
         await this.initialize();
@@ -3275,158 +3314,169 @@ var MCPAgent = class {
       if (!this._agentExecutor) {
         throw new Error("MCP agent failed to initialize");
       }
-      const steps = maxSteps ?? this.maxSteps;
-      this._agentExecutor.maxIterations = steps;
-      const display_query = query.length > 50 ? `${query.slice(0, 50).replace(/\n/g, " ")}...` : query.replace(/\n/g, " ");
-      logger.info(`\u{1F4AC} Received query: '${display_query}'`);
-      if (this.memoryEnabled) {
-        this.addToHistory(new import_messages2.HumanMessage(query));
+      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))) {
+          logger.info(
+            `\u{1F504} Tools changed before execution, updating agent. New tools: ${[...currentToolNames].join(", ")}`
+          );
+          this._tools = currentTools;
+          this._tools.push(...this.additionalTools);
+          await this.createSystemMessageFromTools(this._tools);
+          this._agentExecutor = this.createAgent();
+        }
       }
       const historyToUse = externalHistory ?? this.conversationHistory;
       const langchainHistory = [];
       for (const msg of historyToUse) {
-        if (msg instanceof import_messages2.HumanMessage || msg instanceof import_messages2.AIMessage) {
+        if (msg instanceof import_messages.HumanMessage || msg instanceof import_messages.AIMessage) {
           langchainHistory.push(msg);
         }
       }
-      const intermediateSteps = [];
-      const inputs = { input: query, chat_history: langchainHistory };
-      let nameToToolMap = Object.fromEntries(this._tools.map((t) => [t.name, t]));
-      logger.info(`\u{1F3C1} Starting agent execution with max_steps=${steps}`);
-      let runManager;
-      if (this.callbacks?.length > 0) {
-        const callbackManager = new import_manager2.CallbackManager(void 0, {
-          handlers: this.callbacks,
-          inheritableHandlers: this.callbacks
-        });
-        runManager = await callbackManager.handleChainStart({
-          name: "MCPAgent (mcp-use)",
-          id: ["MCPAgent (mcp-use)"],
-          lc: 1,
-          type: "not_implemented"
-        }, inputs);
-      }
-      for (let stepNum = 0; stepNum < steps; stepNum++) {
-        stepsTaken = stepNum + 1;
-        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));
-          const changed = currentTools.length !== this._tools.length || [...currentToolNames].some((n) => !existingToolNames.has(n));
-          if (changed) {
-            logger.info(
-              `\u{1F504} Tools changed before step ${stepNum + 1}, updating agent. New tools: ${[...currentToolNames].join(", ")}`
-            );
-            this._tools = currentTools;
-            this._tools.push(...this.additionalTools);
-            await this.createSystemMessageFromTools(this._tools);
-            this._agentExecutor = this.createAgent();
-            this._agentExecutor.maxIterations = steps;
-            nameToToolMap = Object.fromEntries(this._tools.map((t) => [t.name, t]));
+      const displayQuery = query.length > 50 ? `${query.slice(0, 50).replace(/\n/g, " ")}...` : query.replace(/\n/g, " ");
+      logger.info(`\u{1F4AC} Received query: '${displayQuery}'`);
+      logger.info("\u{1F3C1} Starting agent execution");
+      const maxRestarts = 3;
+      let restartCount = 0;
+      const accumulatedMessages = [...langchainHistory, new import_messages.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 }
           }
-        }
-        logger.info(`\u{1F463} Step ${stepNum + 1}/${steps}`);
-        try {
-          logger.debug("Starting agent step execution");
-          const nextStepOutput = await this._agentExecutor._takeNextStep(
-            nameToToolMap,
-            inputs,
-            intermediateSteps,
-            runManager
-          );
-          if ("returnValues" in nextStepOutput) {
-            logger.info(`\u2705 Agent finished at step ${stepNum + 1}`);
-            result = nextStepOutput.returnValues?.output ?? "No output generated";
-            runManager?.handleChainEnd({ output: result });
-            if (outputSchema && structuredLlm) {
-              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)}`));
+        );
+        for await (const chunk of stream) {
+          for (const [nodeName, nodeOutput] of Object.entries(chunk)) {
+            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)) {
+                messages = [messages];
+              }
+              for (const msg of messages) {
+                if (!accumulatedMessages.includes(msg)) {
+                  accumulatedMessages.push(msg);
                 }
-                logger.info("\u2705 Structured output successful");
-                structuredOutputSuccessRef.value = true;
-                return structuredResult;
-              }).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: ${currentResult}
-                
-                If information is missing, please continue working to gather the missing information needed for:
-                ${schemaDescription}
-
-                If the information is complete, please return the result in the required structure.
-                `;
-                inputs.input = failedStructuredOutputPrompt;
-                if (this.memoryEnabled) {
-                  this.addToHistory(new import_messages2.HumanMessage(failedStructuredOutputPrompt));
+              }
+              for (const message of messages) {
+                if ("tool_calls" in message && Array.isArray(message.tool_calls) && message.tool_calls.length > 0) {
+                  for (const toolCall of message.tool_calls) {
+                    const toolName = toolCall.name || "unknown";
+                    const toolInput = toolCall.args || {};
+                    this.toolsUsedNames.push(toolName);
+                    stepsTaken++;
+                    let toolInputStr = JSON.stringify(toolInput);
+                    if (toolInputStr.length > 100) {
+                      toolInputStr = `${toolInputStr.slice(0, 97)}...`;
+                    }
+                    logger.info(`\u{1F527} Tool call: ${toolName} with input: ${toolInputStr}`);
+                    yield {
+                      action: {
+                        tool: toolName,
+                        toolInput,
+                        log: `Calling tool ${toolName}`
+                      },
+                      observation: ""
+                      // Will be filled in by tool result
+                    };
+                  }
                 }
-                logger.info("\u{1F504} Continuing execution to gather missing information...");
-              });
-            }
-          }
-          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";
+                if (message instanceof import_messages.ToolMessage || message && "type" in message && message.type === "tool") {
+                  const observation = message.content;
+                  let observationStr = String(observation);
+                  if (observationStr.length > 100) {
+                    observationStr = `${observationStr.slice(0, 97)}...`;
+                  }
+                  observationStr = observationStr.replace(/\n/g, " ");
+                  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))) {
+                      logger.info(
+                        `\u{1F504} Tools changed during execution. New tools: ${[...currentToolNames].join(", ")}`
+                      );
+                      this._tools = currentTools;
+                      this._tools.push(...this.additionalTools);
+                      await this.createSystemMessageFromTools(this._tools);
+                      this._agentExecutor = this.createAgent();
+                      shouldRestart = true;
+                      restartCount++;
+                      logger.info(
+                        `\u{1F503} Restarting execution with updated tools (restart ${restartCount}/${maxRestarts})`
+                      );
+                      break;
+                    }
+                  }
+                }
+                if (message instanceof import_messages.AIMessage && !("tool_calls" in message && Array.isArray(message.tool_calls) && message.tool_calls.length > 0)) {
+                  finalOutput = this._normalizeOutput(message.content);
+                  logger.info("\u2705 Agent finished with output");
+                }
+              }
+              if (shouldRestart) {
                 break;
               }
             }
           }
-        } catch (e) {
-          if (e instanceof import_output_parsers.OutputParserException) {
-            logger.error(`\u274C Output parsing error during step ${stepNum + 1}: ${e}`);
-            result = `Agent stopped due to a parsing error: ${e}`;
-            runManager?.handleChainError(result);
+          if (shouldRestart) {
             break;
           }
-          logger.error(`\u274C Error during agent execution step ${stepNum + 1}: ${e}`);
-          console.error(e);
-          result = `Agent stopped due to an error: ${e}`;
-          runManager?.handleChainError(result);
+        }
+        if (!shouldRestart) {
+          break;
+        }
+        if (restartCount > maxRestarts) {
+          logger.warn(`\u26A0\uFE0F Max restarts (${maxRestarts}) reached. Continuing with current tools.`);
           break;
         }
       }
-      if (!result) {
-        logger.warn(`\u26A0\uFE0F Agent stopped after reaching max iterations (${steps})`);
-        result = `Agent stopped after reaching the maximum number of steps (${steps}).`;
-        runManager?.handleChainEnd({ output: result });
+      if (this.memoryEnabled) {
+        this.addToHistory(new import_messages.HumanMessage(query));
+        if (finalOutput) {
+          this.addToHistory(new import_messages.AIMessage(finalOutput));
+        }
       }
-      logger.info("\u{1F389} Agent execution complete");
-      structuredOutputSuccessRef.value = true;
-      return result;
+      if (outputSchema && finalOutput) {
+        try {
+          logger.info("\u{1F527} Attempting structured output...");
+          const structuredResult = await this._attemptStructuredOutput(
+            finalOutput,
+            this.llm,
+            outputSchema
+          );
+          if (this.memoryEnabled) {
+            this.addToHistory(new import_messages.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)}`);
+        }
+      }
+      logger.info(`\u{1F389} Agent execution complete in ${((Date.now() - startTime) / 1e3).toFixed(2)} seconds`);
+      success = true;
+      return finalOutput || "No output generated";
     } catch (e) {
       logger.error(`\u274C Error running query: ${e}`);
       if (initializedHere && manageConnector) {
-        logger.info("\u{1F9F9} Cleaning up resources after initialization error in run");
+        logger.info("\u{1F9F9} Cleaning up resources after error");
         await this.close();
       }
       throw e;
@@ -3439,16 +3489,17 @@ var MCPAgent = class {
         serverCount = this.connectors.length;
       }
       const conversationHistoryLength = this.memoryEnabled ? this.conversationHistory.length : 0;
+      const toolsAvailable = this._tools || [];
       await this.telemetry.trackAgentExecution({
         executionMethod: "stream",
         query,
-        success: structuredOutputSuccess,
+        success,
         modelProvider: this.modelProvider,
         modelName: this.modelName,
         serverCount,
         serverIdentifiers: this.connectors.map((connector) => connector.publicIdentifier),
-        totalToolsAvailable: this._tools.length,
-        toolsAvailableNames: this._tools.map((t) => t.name),
+        totalToolsAvailable: toolsAvailable.length,
+        toolsAvailableNames: toolsAvailable.map((t) => t.name),
         maxStepsConfigured: this.maxSteps,
         memoryEnabled: this.memoryEnabled,
         useServerManager: this.useServerManager,
@@ -3456,19 +3507,30 @@ var MCPAgent = class {
         manageConnector,
         externalHistoryUsed: externalHistory !== void 0,
         stepsTaken,
-        toolsUsedCount: toolsUsedNames.length,
-        toolsUsedNames,
-        response: result,
+        toolsUsedCount: this.toolsUsedNames.length,
+        toolsUsedNames: this.toolsUsedNames,
+        response: finalOutput || "",
         executionTimeMs,
-        errorType: structuredOutputSuccess ? null : "execution_error",
+        errorType: success ? null : "execution_error",
         conversationHistoryLength
       });
       if (manageConnector && !this.client && initializedHere) {
-        logger.info("\u{1F9F9} Closing agent after query completion");
+        logger.info("\u{1F9F9} Closing agent after stream completion");
         await this.close();
       }
     }
   }
+  /**
+   * Flush observability traces to the configured observability platform.
+   * Important for serverless environments where traces need to be sent before function termination.
+   */
+  async flush() {
+    if (this.isRemote && this.remoteAgent) {
+      return;
+    }
+    logger.debug("Flushing observability traces...");
+    await this.observabilityManager.flush();
+  }
   async close() {
     if (this.isRemote && this.remoteAgent) {
       await this.remoteAgent.close();
@@ -3519,34 +3581,40 @@ var MCPAgent = class {
         await this.initialize();
         initializedHere = true;
       }
-      const agentExecutor = this.agentExecutor;
+      const agentExecutor = this._agentExecutor;
       if (!agentExecutor) {
         throw new Error("MCP agent failed to initialize");
       }
-      const steps = maxSteps ?? this.maxSteps;
-      agentExecutor.maxIterations = steps;
+      this.maxSteps = maxSteps ?? this.maxSteps;
       const display_query = query.length > 50 ? `${query.slice(0, 50).replace(/\n/g, " ")}...` : query.replace(/\n/g, " ");
       logger.info(`\u{1F4AC} Received query for streamEvents: '${display_query}'`);
       if (this.memoryEnabled) {
         logger.info(`\u{1F504} Adding user message to history: ${query}`);
-        this.addToHistory(new import_messages2.HumanMessage(query));
+        this.addToHistory(new import_messages.HumanMessage(query));
       }
       const historyToUse = externalHistory ?? this.conversationHistory;
       const langchainHistory = [];
       for (const msg of historyToUse) {
-        if (msg instanceof import_messages2.HumanMessage || msg instanceof import_messages2.AIMessage || msg instanceof import_messages2.ToolMessage) {
+        if (msg instanceof import_messages.HumanMessage || msg instanceof import_messages.AIMessage || msg instanceof import_messages.ToolMessage) {
           langchainHistory.push(msg);
         } else {
           logger.info(`\u26A0\uFE0F Skipped message of type: ${msg.constructor.name}`);
         }
       }
-      const inputs = { input: query, chat_history: langchainHistory };
+      const inputs = [...langchainHistory, new import_messages.HumanMessage(query)];
       logger.info("callbacks", this.callbacks);
       const eventStream = agentExecutor.streamEvents(
-        inputs,
+        { messages: inputs },
         {
+          streamMode: "updates",
           version: "v2",
-          callbacks: this.callbacks.length > 0 ? this.callbacks : void 0
+          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 event of eventStream) {
@@ -3575,7 +3643,7 @@ var MCPAgent = class {
           let conversionCompleted = false;
           let conversionResult = null;
           let conversionError = null;
-          const _conversionPromise = this._attemptStructuredOutput(
+          this._attemptStructuredOutput(
             finalResponse,
             this.llm,
             outputSchema
@@ -3611,7 +3679,7 @@ var MCPAgent = class {
               data: { output: conversionResult }
             };
             if (this.memoryEnabled) {
-              this.addToHistory(new import_messages2.AIMessage(`Structured result: ${JSON.stringify(conversionResult)}`));
+              this.addToHistory(new import_messages.AIMessage(`Structured result: ${JSON.stringify(conversionResult)}`));
             }
             logger.info("\u2705 Structured output successful");
           }
@@ -3623,7 +3691,7 @@ var MCPAgent = class {
           };
         }
       } else if (this.memoryEnabled && finalResponse) {
-        this.addToHistory(new import_messages2.AIMessage(finalResponse));
+        this.addToHistory(new import_messages.AIMessage(finalResponse));
       }
       logger.info(`\u{1F389} StreamEvents complete - ${eventCount} events emitted`);
       success = true;
@@ -3672,6 +3740,10 @@ var MCPAgent = class {
   }
   /**
    * Attempt to create structured output from raw result with validation and retry logic.
+   * 
+   * @param rawResult - The raw text result from the agent
+   * @param llm - LLM to use for structured output
+   * @param outputSchema - The Zod schema to validate against
    */
   async _attemptStructuredOutput(rawResult, llm, outputSchema) {
     logger.info(`\u{1F504} Attempting structured output with schema: ${outputSchema}`);
@@ -4171,7 +4243,7 @@ async function* streamEventsToAISDKWithTools(streamEvents) {
 __name(streamEventsToAISDKWithTools, "streamEventsToAISDKWithTools");
 
 // src/browser.ts
-var import_messages3 = require("@langchain/core/messages");
+var import_messages2 = require("@langchain/core/messages");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AIMessage,