mcp-use 1.3.10__py3-none-any.whl → 1.3.12__py3-none-any.whl

mcp_use/adapters/langchain_adapter.py

@@ -8,15 +8,12 @@ import re
 from typing import Any, NoReturn
 
 from jsonschema_pydantic import jsonschema_to_pydantic
-from langchain_core.tools import BaseTool, ToolException
+from langchain_core.tools import BaseTool
 from mcp.types import (
     CallToolResult,
-    EmbeddedResource,
-    ImageContent,
     Prompt,
     ReadResourceRequestParams,
     Resource,
-    TextContent,
 )
 from pydantic import BaseModel, Field, create_model
 
@@ -39,7 +36,7 @@ class LangChainAdapter(BaseAdapter):
         self._connector_tool_map: dict[BaseConnector, list[BaseTool]] = {}
 
     def fix_schema(self, schema: dict) -> dict:
-        """Convert JSON Schema 'type': ['string', 'null'] to 'anyOf' format.
+        """Convert JSON Schema 'type': ['string', 'null'] to 'anyOf' format and fix enum handling.
 
         Args:
             schema: The JSON schema to fix.
@@ -51,54 +48,15 @@ class LangChainAdapter(BaseAdapter):
             if "type" in schema and isinstance(schema["type"], list):
                 schema["anyOf"] = [{"type": t} for t in schema["type"]]
                 del schema["type"]  # Remove 'type' and standardize to 'anyOf'
+
+            # Fix enum handling - ensure enum fields are properly typed as strings
+            if "enum" in schema and "type" not in schema:
+                schema["type"] = "string"
+
             for key, value in schema.items():
                 schema[key] = self.fix_schema(value)  # Apply recursively
         return schema
 
-    def _parse_mcp_tool_result(self, tool_result: CallToolResult) -> str:
-        """Parse the content of a CallToolResult into a string.
-
-        Args:
-            tool_result: The result object from calling an MCP tool.
-
-        Returns:
-            A string representation of the tool result content.
-
-        Raises:
-            ToolException: If the tool execution failed, returned no content,
-                        or contained unexpected content types.
-        """
-        if tool_result.isError:
-            raise ToolException(f"Tool execution failed: {tool_result.content}")
-
-        if not tool_result.content:
-            raise ToolException("Tool execution returned no content")
-
-        decoded_result = ""
-        for item in tool_result.content:
-            match item.type:
-                case "text":
-                    item: TextContent
-                    decoded_result += item.text
-                case "image":
-                    item: ImageContent
-                    decoded_result += item.data  # Assuming data is string-like or base64
-                case "resource":
-                    resource: EmbeddedResource = item.resource
-                    if hasattr(resource, "text"):
-                        decoded_result += resource.text
-                    elif hasattr(resource, "blob"):
-                        # Assuming blob needs decoding or specific handling; adjust as needed
-                        decoded_result += (
-                            resource.blob.decode() if isinstance(resource.blob, bytes) else str(resource.blob)
-                        )
-                    else:
-                        raise ToolException(f"Unexpected resource type: {resource.type}")
-                case _:
-                    raise ToolException(f"Unexpected content type: {item.type}")
-
-        return decoded_result
-
     def _convert_tool(self, mcp_tool: dict[str, Any], connector: BaseConnector) -> BaseTool:
         """Convert an MCP tool to LangChain's tool format.
 
@@ -138,7 +96,7 @@ class LangChainAdapter(BaseAdapter):
                 """
                 raise NotImplementedError("MCP tools only support async operations")
 
-            async def _arun(self, **kwargs: Any) -> Any:
+            async def _arun(self, **kwargs: Any) -> str | dict:
                 """Asynchronously execute the tool with given arguments.
 
                 Args:
@@ -155,8 +113,7 @@ class LangChainAdapter(BaseAdapter):
                 try:
                     tool_result: CallToolResult = await self.tool_connector.call_tool(self.name, kwargs)
                     try:
-                        # Use the helper function to parse the result
-                        return adapter_self._parse_mcp_tool_result(tool_result)
+                        return str(tool_result.content)
                     except Exception as e:
                         # Log the exception for debugging
                         logger.error(f"Error parsing tool result: {e}")

mcp_use/agents/mcpagent.py

@@ -213,6 +213,42 @@ class MCPAgent:
         self._initialized = True
         logger.info("✨ Agent initialization complete")
 
+    def _normalize_output(self, value: object) -> str:
+        """Normalize model outputs into a plain text string."""
+        try:
+            if isinstance(value, str):
+                return value
+
+            # LangChain messages may have .content which is str or list-like
+            content = getattr(value, "content", None)
+            if content is not None:
+                return self._normalize_output(content)
+
+            if isinstance(value, list):
+                parts: list[str] = []
+                for item in value:
+                    if isinstance(item, dict):
+                        if "text" in item and isinstance(item["text"], str):
+                            parts.append(item["text"])
+                        elif "content" in item:
+                            parts.append(self._normalize_output(item["content"]))
+                        else:
+                            # Fallback to str for unknown shapes
+                            parts.append(str(item))
+                    else:
+                        # recurse on .content or str
+                        part_content = getattr(item, "text", None)
+                        if isinstance(part_content, str):
+                            parts.append(part_content)
+                        else:
+                            parts.append(self._normalize_output(getattr(item, "content", item)))
+                return "".join(parts)
+
+            return str(value)
+
+        except Exception:
+            return str(value)
+
     async def _create_system_message_from_tools(self, tools: list[BaseTool]) -> None:
         """Create the system message based on provided tools using the builder."""
         # Use the override if provided, otherwise use the imported default
@@ -232,9 +268,12 @@ class MCPAgent:
         )
 
         # Update conversation history if memory is enabled
+        # Note: The system message should not be included in the conversation history,
+        # as it will be automatically added using the create_tool_calling_agent function with the prompt parameter
         if self.memory_enabled:
-            history_without_system = [msg for msg in self._conversation_history if not isinstance(msg, SystemMessage)]
-            self._conversation_history = [self._system_message] + history_without_system
+            self._conversation_history = [
+                msg for msg in self._conversation_history if not isinstance(msg, SystemMessage)
+            ]
 
     def _create_agent(self) -> AgentExecutor:
         """Create the LangChain agent with the configured system message.
@@ -248,14 +287,25 @@ class MCPAgent:
         if self._system_message:
             system_content = self._system_message.content
 
-        prompt = ChatPromptTemplate.from_messages(
-            [
-                ("system", system_content),
-                MessagesPlaceholder(variable_name="chat_history"),
-                ("human", "{input}"),
-                MessagesPlaceholder(variable_name="agent_scratchpad"),
-            ]
-        )
+        if self.memory_enabled:
+            # Query already in chat_history — don't re-inject it
+            prompt = ChatPromptTemplate.from_messages(
+                [
+                    ("system", system_content),
+                    MessagesPlaceholder(variable_name="chat_history"),
+                    ("human", "{input}"),
+                    MessagesPlaceholder(variable_name="agent_scratchpad"),
+                ]
+            )
+        else:
+            # No memory — inject input directly
+            prompt = ChatPromptTemplate.from_messages(
+                [
+                    ("system", system_content),
+                    ("human", "{input}"),
+                    MessagesPlaceholder(variable_name="agent_scratchpad"),
+                ]
+            )
 
         tool_names = [tool.name for tool in self._tools]
         logger.info(f"🧠 Agent ready with tools: {', '.join(tool_names)}")
@@ -286,10 +336,6 @@ class MCPAgent:
         """Clear the conversation history."""
         self._conversation_history = []
 
-        # Re-add the system message if it exists
-        if self._system_message and self.memory_enabled:
-            self._conversation_history = [self._system_message]
-
     def add_to_history(self, message: BaseMessage) -> None:
         """Add a message to the conversation history.
 
@@ -315,15 +361,6 @@ class MCPAgent:
         """
         self._system_message = SystemMessage(content=message)
 
-        # Update conversation history if memory is enabled
-        if self.memory_enabled:
-            # Remove old system message if it exists
-            history_without_system = [msg for msg in self._conversation_history if not isinstance(msg, SystemMessage)]
-            self._conversation_history = history_without_system
-
-            # Add new system message
-            self._conversation_history.insert(0, self._system_message)
-
         # Recreate the agent with the new system message if initialized
         if self._initialized and self._tools:
             self._agent_executor = self._create_agent()
@@ -467,10 +504,6 @@ class MCPAgent:
             display_query = query[:50].replace("\n", " ") + "..." if len(query) > 50 else query.replace("\n", " ")
             logger.info(f"💬 Received query: '{display_query}'")
 
-            # Add the user query to conversation history if memory is enabled
-            if self.memory_enabled:
-                self.add_to_history(HumanMessage(content=query))
-
             # Use the provided history or the internal history
             history_to_use = external_history if external_history is not None else self._conversation_history
 
@@ -492,6 +525,10 @@ class MCPAgent:
 
             logger.info(f"🏁 Starting agent execution with max_steps={steps}")
 
+            # Track whether agent finished successfully vs reached max iterations
+            agent_finished_successfully = False
+            result = None
+
             # Create a run manager with our callbacks if we have any - ONCE for the entire execution
             run_manager = None
             if self.callbacks:
@@ -578,7 +615,9 @@ class MCPAgent:
                     # Process the output
                     if isinstance(next_step_output, AgentFinish):
                         logger.info(f"✅ Agent finished at step {step_num + 1}")
-                        result = next_step_output.return_values.get("output", "No output generated")
+                        agent_finished_successfully = True
+                        output_value = next_step_output.return_values.get("output", "No output generated")
+                        result = self._normalize_output(output_value)
                         # End the chain if we have a run manager
                         if run_manager:
                             await run_manager.on_chain_end({"output": result})
@@ -659,7 +698,9 @@ class MCPAgent:
                         tool_return = self._agent_executor._get_tool_return(last_step)
                         if tool_return is not None:
                             logger.info(f"🏆 Tool returned directly at step {step_num + 1}")
+                            agent_finished_successfully = True
                             result = tool_return.return_values.get("output", "No output generated")
+                            result = self._normalize_output(result)
                             break
 
                 except OutputParserException as e:
@@ -681,10 +722,16 @@ class MCPAgent:
 
             # --- Loop finished ---
             if not result:
-                logger.warning(f"⚠️ Agent stopped after reaching max iterations ({steps})")
-                result = f"Agent stopped after reaching the maximum number of steps ({steps})."
-                if run_manager:
-                    await run_manager.on_chain_end({"output": result})
+                if agent_finished_successfully:
+                    # Agent finished successfully but returned empty output
+                    result = "Agent completed the task successfully."
+                    logger.info("✅ Agent finished successfully with empty output")
+                else:
+                    # Agent actually reached max iterations
+                    logger.warning(f"⚠️ Agent stopped after reaching max iterations ({steps})")
+                    result = f"Agent stopped after reaching the maximum number of steps ({steps})."
+                    if run_manager:
+                        await run_manager.on_chain_end({"output": result})
 
             # If structured output was requested but not achieved, attempt one final time
             if output_schema and structured_llm and not success:
@@ -707,8 +754,11 @@ class MCPAgent:
                     logger.error(f"❌ Final structured output attempt failed: {e}")
                     raise RuntimeError(f"Failed to generate structured output after {steps} steps: {str(e)}") from e
 
+            if self.memory_enabled:
+                self.add_to_history(HumanMessage(content=query))
+
             if self.memory_enabled and not output_schema:
-                self.add_to_history(AIMessage(content=result))
+                self.add_to_history(AIMessage(content=self._normalize_output(result)))
 
             logger.info(f"🎉 Agent execution complete in {time.time() - start_time} seconds")
             if not success:
@@ -861,7 +911,7 @@ class MCPAgent:
                 steps_taken=steps_taken,
                 tools_used_count=len(self.tools_used_names),
                 tools_used_names=self.tools_used_names,
-                response=str(result),
+                response=str(self._normalize_output(result)),
                 execution_time_ms=int((time.time() - start_time) * 1000),
                 error_type=error,
                 conversation_history_length=len(self._conversation_history),
@@ -964,9 +1014,6 @@ class MCPAgent:
         effective_max_steps = max_steps or self.max_steps
         self._agent_executor.max_iterations = effective_max_steps
 
-        if self.memory_enabled:
-            self.add_to_history(HumanMessage(content=query))
-
         history_to_use = external_history if external_history is not None else self._conversation_history
         inputs = {"input": query, "chat_history": history_to_use}
 
@@ -979,6 +1026,10 @@ class MCPAgent:
                         if not isinstance(message, ToolAgentAction):
                             self.add_to_history(message)
             yield event
+
+        if self.memory_enabled:
+            self.add_to_history(HumanMessage(content=query))
+
         # 5. House-keeping -------------------------------------------------------
         # Restrict agent cleanup in _generate_response_chunks_async to only occur
         #  when the agent was initialized in this generator and is not client-managed

mcp_use/agents/prompts/templates.py

@@ -5,16 +5,7 @@ You have access to the following tools:
 
 {tool_descriptions}
 
-Use the following format:
-
-Question: the input question you must answer
-Thought: you should always think about what to do
-Action: the action to take, should be one of the available tools
-Action Input: the input to the action
-Observation: the result of the action
-... (this Thought/Action/Action Input/Observation can repeat N times)
-Thought: I now know the final answer
-Final Answer: the final answer to the original input question"""
+Use these tools to help answer questions and complete tasks as needed."""
 
 
 SERVER_MANAGER_SYSTEM_PROMPT_TEMPLATE = """You are a helpful assistant designed