mcp-use 1.3.11__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
 
@@ -60,47 +57,6 @@ class LangChainAdapter(BaseAdapter):
                 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}")
-
-        decoded_result = ""
-        for item in tool_result.content or []:
-            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.
 
@@ -140,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:
@@ -157,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
 
@@ -583,7 +616,8 @@ class MCPAgent:
                     if isinstance(next_step_output, AgentFinish):
                         logger.info(f"✅ Agent finished at step {step_num + 1}")
                         agent_finished_successfully = True
-                        result = next_step_output.return_values.get("output", "No output generated")
+                        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})
@@ -666,6 +700,7 @@ class MCPAgent:
                             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:
@@ -719,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:
@@ -873,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),
@@ -976,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}
 
@@ -991,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/remote.py

@@ -4,6 +4,7 @@ Remote agent implementation for executing agents via API.
 
 import json
 import os
+from collections.abc import AsyncGenerator
 from typing import Any, TypeVar
 from uuid import UUID
 
@@ -17,7 +18,7 @@ T = TypeVar("T", bound=BaseModel)
 
 # API endpoint constants
 API_CHATS_ENDPOINT = "/api/v1/chats/get-or-create"
-API_CHAT_EXECUTE_ENDPOINT = "/api/v1/chats/{chat_id}/execute"
+API_CHAT_STREAM_ENDPOINT = "/api/v1/chats/{chat_id}/stream"
 API_CHAT_DELETE_ENDPOINT = "/api/v1/chats/{chat_id}"
 
 UUID_ERROR_MESSAGE = """A UUID is a 36 character string of the format xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx \n
@@ -129,12 +130,25 @@ class RemoteAgent:
 
         # Parse into the Pydantic model
         try:
+            logger.info(f"🔍 Attempting to validate result_data against {output_schema.__name__}")
+            logger.info(f"🔍 Result data type: {type(result_data)}")
+            logger.info(f"🔍 Result data: {result_data}")
             return output_schema.model_validate(result_data)
         except Exception as e:
-            logger.warning(f"Failed to parse structured output: {e}")
+            logger.warning(f"❌ Failed to parse structured output: {e}")
+            logger.warning(f"🔍 Validation error details: {type(e).__name__}: {str(e)}")
+            logger.warning(f"🔍 Result data that failed validation: {result_data}")
+
             # Fallback: try to parse it as raw content if the model has a content field
             if hasattr(output_schema, "model_fields") and "content" in output_schema.model_fields:
-                return output_schema.model_validate({"content": str(result_data)})
+                logger.info("🔄 Attempting fallback with content field")
+                try:
+                    fallback_result = output_schema.model_validate({"content": str(result_data)})
+                    logger.info("✅ Fallback parsing succeeded")
+                    return fallback_result
+                except Exception as fallback_e:
+                    logger.error(f"❌ Fallback parsing also failed: {fallback_e}")
+                    raise
             raise
 
     async def _upsert_chat_session(self) -> str:
@@ -153,7 +167,7 @@ class RemoteAgent:
         headers = {"Content-Type": "application/json", "x-api-key": self.api_key}
         chat_url = f"{self.base_url}{API_CHATS_ENDPOINT}"
 
-        logger.info(f"📝 Upserting chat session for agent {self.agent_id}")
+        logger.info(f"📝 [{self.chat_id}] Upserting chat session for agent {self.agent_id}")
 
         try:
             chat_response = await self._client.post(chat_url, json=chat_payload, headers=headers)
@@ -162,9 +176,9 @@ class RemoteAgent:
             chat_data = chat_response.json()
             chat_id = chat_data["id"]
             if chat_response.status_code == 201:
-                logger.info(f"✅ New chat session created: {chat_id}")
+                logger.info(f"✅ [{self.chat_id}] New chat session created")
             else:
-                logger.info(f"✅ Resumed chat session: {chat_id}")
+                logger.info(f"✅ [{self.chat_id}] Resumed chat session")
 
             return chat_id
 
@@ -182,144 +196,156 @@ class RemoteAgent:
         except Exception as e:
             raise RuntimeError(f"Failed to create chat session: {str(e)}") from e
 
-    async def run(
+    async def stream(
         self,
         query: str,
         max_steps: int | None = None,
         external_history: list[BaseMessage] | None = None,
         output_schema: type[T] | None = None,
-    ) -> str | T:
-        """Run a query on the remote agent.
-
-        Args:
-            query: The query to execute
-            max_steps: Maximum number of steps (default: 10)
-            external_history: External history (not supported yet for remote execution)
-            output_schema: Optional Pydantic model for structured output
-
-        Returns:
-            The result from the remote agent execution (string or structured output)
-        """
+    ) -> AsyncGenerator[str, None]:
+        """Stream the execution of a query on the remote agent using HTTP streaming."""
         if external_history is not None:
             logger.warning("External history is not yet supported for remote execution")
 
-        try:
-            logger.info(f"🌐 Executing query on remote agent {self.agent_id}")
-
-            # Step 1: Ensure chat session exists on the backend by upserting.
-            # This happens once per agent instance.
-            if not self._session_established:
-                logger.info(f"🔧 Establishing chat session for agent {self.agent_id}")
-                self.chat_id = await self._upsert_chat_session()
-                self._session_established = True
-
-            chat_id = self.chat_id
-
-            # Step 2: Execute the agent within the chat context
-            execution_payload = {"query": query, "max_steps": max_steps or 10}
-
-            # Add structured output schema if provided
-            if output_schema is not None:
-                execution_payload["output_schema"] = self._pydantic_to_json_schema(output_schema)
-                logger.info(f"🔧 Using structured output with schema: {output_schema.__name__}")
-
-            headers = {"Content-Type": "application/json", "x-api-key": self.api_key}
-            execution_url = f"{self.base_url}{API_CHAT_EXECUTE_ENDPOINT.format(chat_id=chat_id)}"
-            logger.info(f"🚀 Executing agent in chat {chat_id}")
-
-            response = await self._client.post(execution_url, json=execution_payload, headers=headers)
-            response.raise_for_status()
-
-            result = response.json()
-            logger.info(f"🔧 Response: {result}")
-            logger.info("✅ Remote execution completed successfully")
-
-            # Check for error responses (even with 200 status)
-            if isinstance(result, dict):
-                # Check for actual error conditions (not just presence of error field)
-                if result.get("status") == "error" or (result.get("error") is not None):
-                    error_msg = result.get("error", str(result))
-                    logger.error(f"❌ Remote agent execution failed: {error_msg}")
-                    raise RuntimeError(f"Remote agent execution failed: {error_msg}")
-
-                # Check if the response indicates agent initialization failure
-                if "failed to initialize" in str(result):
-                    logger.error(f"❌ Agent initialization failed: {result}")
-                    raise RuntimeError(
-                        f"Agent initialization failed on remote server. "
-                        f"This usually indicates:\n"
-                        f"• Invalid agent configuration (LLM model, system prompt)\n"
-                        f"• Missing or invalid MCP server configurations\n"
-                        f"• Network connectivity issues with MCP servers\n"
-                        f"• Missing environment variables or credentials\n"
-                        f"Raw error: {result}"
-                    )
-
-            # Handle structured output
-            if output_schema is not None:
-                return self._parse_structured_response(result, output_schema)
+        if not self._session_established:
+            logger.info(f"🔧 [{self.chat_id}] Establishing chat session for agent {self.agent_id}")
+            self.chat_id = await self._upsert_chat_session()
+            self._session_established = True
 
-            # Regular string output
-            if isinstance(result, dict) and "result" in result:
-                return result["result"]
-            elif isinstance(result, str):
-                return result
-            else:
-                return str(result)
+        chat_id = self.chat_id
+        stream_url = f"{self.base_url}{API_CHAT_STREAM_ENDPOINT.format(chat_id=chat_id)}"
+
+        # Prepare the request payload
+        request_payload = {"messages": [{"role": "user", "content": query}], "max_steps": max_steps or 30}
+        if output_schema is not None:
+            request_payload["output_schema"] = self._pydantic_to_json_schema(output_schema)
+
+        headers = {"Content-Type": "application/json", "x-api-key": self.api_key, "Accept": "text/event-stream"}
+
+        try:
+            logger.info(f"🌐 [{self.chat_id}] Connecting to HTTP stream for agent {self.agent_id}")
+
+            async with self._client.stream("POST", stream_url, headers=headers, json=request_payload) as response:
+                logger.info(f"✅ [{self.chat_id}] HTTP stream connection established")
+
+                if response.status_code != 200:
+                    error_text = await response.aread()
+                    raise RuntimeError(f"Failed to stream from remote agent: {error_text.decode()}")
+
+                # Read the streaming response line by line
+                try:
+                    async for line in response.aiter_lines():
+                        if line:
+                            yield line
+                except UnicodeDecodeError as e:
+                    logger.error(f"❌ [{self.chat_id}] UTF-8 decoding error at position {e.start}: {e.reason}")
+                    logger.error(f"❌ [{self.chat_id}] Error occurred while reading stream for agent {self.agent_id}")
+                    # Try to read raw bytes and decode with error handling
+                    logger.info(f"🔄 [{self.chat_id}] Attempting to read raw bytes with error handling...")
+                logger.info(f"✅ [{self.chat_id}] Agent execution stream completed")
 
         except httpx.HTTPStatusError as e:
             status_code = e.response.status_code
             response_text = e.response.text
 
-            # Provide specific error messages based on status code
-            if status_code == 401:
-                logger.error(f"❌ Authentication failed: {response_text}")
-                raise RuntimeError(
-                    "Authentication failed: Invalid or missing API key. "
-                    "Please check your API key and ensure the MCP_USE_API_KEY environment variable is set correctly."
-                ) from e
-            elif status_code == 403:
-                logger.error(f"❌ Access forbidden: {response_text}")
-                raise RuntimeError(
-                    f"Access denied: You don't have permission to execute agent '{self.agent_id}'. "
-                    "Check if the agent exists and you have the necessary permissions."
-                ) from e
-            elif status_code == 404:
-                logger.error(f"❌ Agent not found: {response_text}")
-                raise RuntimeError(
-                    f"Agent not found: Agent '{self.agent_id}' does not exist or you don't have access to it. "
-                    "Please verify the agent ID and ensure it exists in your account."
-                ) from e
-            elif status_code == 422:
-                logger.error(f"❌ Validation error: {response_text}")
-                raise RuntimeError(
-                    f"Request validation failed: {response_text}. "
-                    "Please check your query parameters and output schema format."
-                ) from e
-            elif status_code == 500:
-                logger.error(f"❌ Server error: {response_text}")
-                raise RuntimeError(
-                    "Internal server error occurred during agent execution. "
-                    "Please try again later or contact support if the issue persists."
-                ) from e
+            if status_code == 404:
+                raise RuntimeError(f"Chat or agent not found: {response_text}") from e
             else:
-                logger.error(f"❌ Remote execution failed with status {status_code}: {response_text}")
-                raise RuntimeError(f"Remote agent execution failed: {status_code} - {response_text}") from e
-        except httpx.TimeoutException as e:
-            logger.error(f"❌ Remote execution timed out: {e}")
-            raise RuntimeError(
-                "Remote agent execution timed out. The server may be overloaded or the query is taking too long to "
-                "process. Try again or use a simpler query."
-            ) from e
-        except httpx.ConnectError as e:
-            logger.error(f"❌ Remote execution connection error: {e}")
-            raise RuntimeError(
-                f"Remote agent connection failed: Cannot connect to {self.base_url}. "
-                f"Check if the server is running and the URL is correct."
-            ) from e
+                raise RuntimeError(f"Failed to stream from remote agent: {status_code} - {response_text}") from e
+        except Exception as e:
+            logger.error(f"❌ [{self.chat_id}] An error occurred during HTTP streaming: {e}")
+            raise RuntimeError(f"Failed to stream from remote agent: {str(e)}") from e
+
+    async def run(
+        self,
+        query: str,
+        max_steps: int | None = None,
+        external_history: list[BaseMessage] | None = None,
+        output_schema: type[T] | None = None,
+    ) -> str | T:
+        """
+        Executes the agent and returns the final result.
+        This method uses HTTP streaming to avoid timeouts for long-running tasks.
+        It consumes the entire stream and returns only the final result.
+        """
+        final_result = None
+        steps_taken = 0
+        finished = False
+
+        try:
+            # Consume the ENTIRE stream to ensure proper execution
+            async for event in self.stream(query, max_steps, external_history, output_schema):
+                logger.debug(f"[{self.chat_id}] Processing stream event: {event}...")
+
+                # Parse AI SDK format events to extract final result
+                # The events follow the AI SDK streaming protocol
+                if event.startswith("0:"):  # Text event
+                    try:
+                        text_data = json.loads(event[2:])  # Remove "0:" prefix
+                        if final_result is None:
+                            final_result = ""
+                        final_result += text_data
+                        result_preview = final_result[:200] if len(final_result) > 200 else final_result
+                        logger.debug(f"Accumulated text result: {result_preview}...")
+                    except json.JSONDecodeError:
+                        logger.warning(f"Failed to parse text event: {event[:100]}")
+                        continue
+
+                elif event.startswith("9:"):  # Tool call event
+                    steps_taken += 1
+                    logger.debug(f"Tool call executed, total steps: {steps_taken}")
+
+                elif event.startswith("d:"):  # Finish event
+                    logger.debug("Received finish event, marking as finished")
+                    finished = True
+                    # Continue consuming to ensure stream cleanup
+
+                elif event.startswith("3:"):  # Error event
+                    try:
+                        error_data = json.loads(event[2:])
+                        error_msg = error_data if isinstance(error_data, str) else json.dumps(error_data)
+                        raise RuntimeError(f"Agent execution failed: {error_msg}")
+                    except json.JSONDecodeError as e:
+                        raise RuntimeError("Agent execution failed with unknown error") from e
+
+            # Log completion of stream consumption
+            logger.info(f"Stream consumption complete. Finished: {finished}, Steps taken: {steps_taken}")
+
+            if final_result is None:
+                logger.warning(f"No final result captured from stream (structured output: {output_schema is not None})")
+                final_result = ""  # Return empty string instead of error message
+
+            # For structured output, try to parse the result
+            if output_schema:
+                logger.info(f"🔍 Attempting structured output parsing for schema: {output_schema.__name__}")
+                logger.info(f"🔍 Raw final result type: {type(final_result)}")
+                logger.info(f"🔍 Raw final result length: {len(str(final_result)) if final_result else 0}")
+                logger.info(f"🔍 Raw final result preview: {str(final_result)[:500] if final_result else 'None'}...")
+
+                if isinstance(final_result, str) and final_result:
+                    try:
+                        # Try to parse as JSON first
+                        parsed_result = json.loads(final_result)
+                        logger.info("✅ Successfully parsed structured result as JSON")
+                        return self._parse_structured_response(parsed_result, output_schema)
+                    except json.JSONDecodeError as e:
+                        logger.warning(f"❌ Could not parse result as JSON: {e}")
+                        logger.warning(f"🔍 Raw string content: {final_result[:1000]}...")
+                        # Try to parse directly
+                        return self._parse_structured_response({"content": final_result}, output_schema)
+                else:
+                    logger.warning(f"❌ Final result is empty or not string: {final_result}")
+                    # Try to parse the result directly
+                    return self._parse_structured_response(final_result, output_schema)
+
+            # Regular string output
+            return final_result if isinstance(final_result, str) else str(final_result)
+
+        except RuntimeError:
+            raise
         except Exception as e:
-            logger.error(f"❌ Remote execution error: {e}")
-            raise RuntimeError(f"Remote agent execution failed: {str(e)}") from e
+            logger.error(f"Error executing agent: {e}")
+            raise RuntimeError(f"Failed to execute agent: {str(e)}") from e
 
     async def close(self) -> None:
         """Close the HTTP client."""