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

package/dist/{chunk-4SWVHFJH.js → chunk-GKNOUQFQ.js}

@@ -1,6 +1,6 @@
 import {
   logger
-} from "./chunk-2HFIPY7C.js";
+} from "./chunk-ZUEQQ6YK.js";
 import {
   __name
 } from "./chunk-SHUYVCID.js";
@@ -212,7 +212,7 @@ var AcquireActiveMCPServerTool = class extends MCPServerTool {
 };
 
 // src/managers/tools/add_server_from_config.ts
-import { StructuredTool as StructuredTool2 } from "langchain/tools";
+import { StructuredTool as StructuredTool2 } from "@langchain/core/tools";
 import { z as z3 } from "zod";
 var AddMCPServerFromConfigTool = class extends StructuredTool2 {
   static {
@@ -510,9 +510,9 @@ var ObservabilityManager = class {
       return;
     }
     try {
-      const { langfuseHandler: langfuseHandler2, langfuseInitPromise: langfuseInitPromise2 } = await import("./langfuse-YA2S23SM.js");
+      const { langfuseHandler: langfuseHandler2, langfuseInitPromise: langfuseInitPromise2 } = await import("./langfuse-6AJGHMAV.js");
       if (this.agentId || this.metadata || this.metadataProvider || this.tagsProvider) {
-        const { initializeLangfuse } = await import("./langfuse-YA2S23SM.js");
+        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)}`);
       } else {
@@ -578,6 +578,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.
@@ -1232,23 +1249,16 @@ Raw error: ${result}`
 };
 
 // src/agents/mcp_agent.ts
-import { CallbackManager } from "@langchain/core/callbacks/manager";
 import {
   AIMessage,
   HumanMessage,
-  SystemMessage as SystemMessage2,
   ToolMessage
 } from "@langchain/core/messages";
-import { OutputParserException } from "@langchain/core/output_parsers";
-import {
-  ChatPromptTemplate,
-  MessagesPlaceholder
-} from "@langchain/core/prompts";
-import { AgentExecutor, createToolCallingAgent } from "langchain/agents";
+import { createAgent, modelCallLimitMiddleware, SystemMessage as SystemMessage2 } from "langchain";
 import { zodToJsonSchema as zodToJsonSchema2 } from "zod-to-json-schema";
 
 // src/agents/prompts/system_prompt_builder.ts
-import { SystemMessage } from "@langchain/core/messages";
+import { SystemMessage } from "langchain";
 function generateToolDescriptions(tools, disallowedTools) {
   const disallowedSet = new Set(disallowedTools ?? []);
   const descriptions = [];
@@ -1350,6 +1360,7 @@ var MCPAgent = class {
   memoryEnabled;
   disallowedTools;
   additionalTools;
+  toolsUsedNames = [];
   useServerManager;
   verbose;
   observe;
@@ -1417,6 +1428,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;
@@ -1540,25 +1552,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 = ChatPromptTemplate.fromMessages([
-      ["system", systemContent],
-      new MessagesPlaceholder("chat_history"),
-      ["human", "{input}"],
-      new MessagesPlaceholder("agent_scratchpad")
-    ]);
-    const agent = createToolCallingAgent({
-      llm: this.llm,
-      tools: this._tools,
-      prompt
-    });
-    return new AgentExecutor({
-      agent,
+    const toolNames = this._tools.map((tool) => tool.name);
+    logger.info(`\u{1F9E0} Agent ready with tools: ${toolNames.join(", ")}`);
+    const middleware = [modelCallLimitMiddleware({ runLimit: this.maxSteps })];
+    const agent = 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];
@@ -1726,6 +1730,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();
@@ -1747,36 +1787,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(zodToJsonSchema2(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(zodToJsonSchema2(outputSchema), null, 2);
-    }
     try {
       if (manageConnector && !this._initialized) {
         await this.initialize();
@@ -1788,12 +1808,19 @@ 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 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 = [];
@@ -1802,144 +1829,148 @@ var MCPAgent = class {
           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 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 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 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 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 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 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 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 HumanMessage(query));
+        if (finalOutput) {
+          this.addToHistory(new 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 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;
@@ -1952,16 +1983,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,
@@ -1969,19 +2001,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();
@@ -2032,12 +2075,11 @@ 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) {
@@ -2053,13 +2095,20 @@ var MCPAgent = class {
           logger.info(`\u26A0\uFE0F Skipped message of type: ${msg.constructor.name}`);
         }
       }
-      const inputs = { input: query, chat_history: langchainHistory };
+      const inputs = [...langchainHistory, new HumanMessage(query)];
       logger.info("callbacks", this.callbacks);
       const eventStream = agentExecutor.streamEvents(
-        inputs,
+        { messages: inputs },
         {
+          streamMode: "messages",
           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) {
@@ -2070,8 +2119,20 @@ var MCPAgent = class {
         if (event.event === "on_chat_model_stream" && event.data?.chunk?.content) {
           totalResponseLength += event.data.chunk.content.length;
         }
+        if (event.event === "on_chat_model_stream" && event.data?.chunk) {
+          logger.info("on_chat_model_stream", event.data.chunk);
+          const chunk = event.data.chunk;
+          if (chunk.content) {
+            if (!finalResponse) {
+              finalResponse = "";
+            }
+            const normalizedContent = this._normalizeOutput(chunk.content);
+            finalResponse += normalizedContent;
+            logger.debug(`\u{1F4DD} Accumulated response length: ${finalResponse.length}`);
+          }
+        }
         yield event;
-        if (event.event === "on_chain_end" && event.data?.output) {
+        if (event.event === "on_chain_end" && event.data?.output && !finalResponse) {
           const output = event.data.output;
           if (Array.isArray(output) && output.length > 0 && output[0]?.text) {
             finalResponse = output[0].text;
@@ -2088,7 +2149,7 @@ var MCPAgent = class {
           let conversionCompleted = false;
           let conversionResult = null;
           let conversionError = null;
-          const _conversionPromise = this._attemptStructuredOutput(
+          this._attemptStructuredOutput(
             finalResponse,
             this.llm,
             outputSchema
@@ -2185,6 +2246,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}`);
@@ -2199,7 +2264,9 @@ var MCPAgent = class {
     } else {
       throw new Error("LLM is required for structured output");
     }
-    schemaDescription = JSON.stringify(zodToJsonSchema2(outputSchema), null, 2);
+    const jsonSchema = zodToJsonSchema2(outputSchema);
+    const { $schema, additionalProperties, ...cleanSchema } = jsonSchema;
+    schemaDescription = JSON.stringify(cleanSchema, null, 2);
     logger.info(`\u{1F504} Schema description: ${schemaDescription}`);
     let textContent = "";
     if (typeof rawResult === "string") {
@@ -2207,6 +2274,7 @@ var MCPAgent = class {
     } else if (rawResult && typeof rawResult === "object") {
       textContent = JSON.stringify(rawResult);
     }
+    logger.info("rawResult", rawResult);
     if (!textContent) {
       textContent = JSON.stringify(rawResult);
     }
@@ -2217,28 +2285,34 @@ var MCPAgent = class {
       let formatPrompt = `
       Please format the following information according to the EXACT schema specified below.
       You must use the exact field names and types as shown in the schema.
-      
+
       Required schema format:
       ${schemaDescription}
-      
+
       Content to extract from:
       ${textContent}
-      
-      IMPORTANT: 
+
+      IMPORTANT:
       - Use ONLY the field names specified in the schema
       - Match the data types exactly (string, number, boolean, array, etc.)
       - Include ALL required fields
       - Return valid JSON that matches the schema structure exactly
+      - For missing data: use null for nullable fields, omit optional fields entirely
+      - Do NOT use empty strings ("") or zero (0) as placeholders for missing data
       `;
       if (attempt > 1) {
         formatPrompt += `
-        
+
         PREVIOUS ATTEMPT FAILED with error: ${lastError}
         Please fix the issues mentioned above and ensure the output matches the schema exactly.
         `;
       }
       try {
         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}`);
         const stream = await structuredLlm.stream(formatPrompt);
         let structuredResult = null;
         let chunkCount = 0;
@@ -2314,14 +2388,16 @@ var MCPAgent = class {
    */
   _enhanceQueryWithSchema(query, outputSchema) {
     try {
-      const schemaDescription = JSON.stringify(zodToJsonSchema2(outputSchema), null, 2);
+      const jsonSchema = zodToJsonSchema2(outputSchema);
+      const { $schema, additionalProperties, ...cleanSchema } = jsonSchema;
+      const schemaDescription = JSON.stringify(cleanSchema, null, 2);
       const enhancedQuery = `
       ${query}
-      
+
       IMPORTANT: Your response must include sufficient information to populate the following structured output:
-      
+
       ${schemaDescription}
-      
+
       Make sure you gather ALL the required information during your task execution.
       If any required information is missing, continue working to find it.
       `;