fast-agent-mcp 0.2.56__py3-none-any.whl → 0.2.58__py3-none-any.whl

mcp_agent/ui/console_display.py

@@ -19,6 +19,61 @@ from mcp_agent.mcp.mcp_aggregator import MCPAggregator
 HUMAN_INPUT_TOOL_NAME = "__human_input__"
 CODE_STYLE = "native"
 
+HTML_ESCAPE_CHARS = {"&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;"}
+
+
+def _prepare_markdown_content(content: str, escape_xml: bool = True) -> str:
+    """Prepare content for markdown rendering by escaping HTML/XML tags
+    while preserving code blocks and inline code.
+
+    This ensures XML/HTML tags are displayed as visible text rather than
+    being interpreted as markup by the markdown renderer.
+
+    Note: This method does not handle overlapping code blocks (e.g., if inline
+    code appears within a fenced code block range). In practice, this is not
+    an issue since markdown syntax doesn't support such overlapping.
+    """
+    if not escape_xml or not isinstance(content, str):
+        return content
+
+    protected_ranges = []
+    import re
+
+    # Protect fenced code blocks (don't escape anything inside these)
+    code_block_pattern = r"```[\s\S]*?```"
+    for match in re.finditer(code_block_pattern, content):
+        protected_ranges.append((match.start(), match.end()))
+
+    # Protect inline code (don't escape anything inside these)
+    inline_code_pattern = r"(?<!`)`(?!``)[^`\n]+`(?!`)"
+    for match in re.finditer(inline_code_pattern, content):
+        protected_ranges.append((match.start(), match.end()))
+
+    protected_ranges.sort(key=lambda x: x[0])
+
+    # Build the escaped content
+    result = []
+    last_end = 0
+
+    for start, end in protected_ranges:
+        # Escape everything outside protected ranges
+        unprotected_text = content[last_end:start]
+        for char, replacement in HTML_ESCAPE_CHARS.items():
+            unprotected_text = unprotected_text.replace(char, replacement)
+        result.append(unprotected_text)
+
+        # Keep protected ranges (code blocks) as-is
+        result.append(content[start:end])
+        last_end = end
+
+    # Escape any remaining content after the last protected range
+    remainder_text = content[last_end:]
+    for char, replacement in HTML_ESCAPE_CHARS.items():
+        remainder_text = remainder_text.replace(char, replacement)
+    result.append(remainder_text)
+
+    return "".join(result)
+
 
 class ConsoleDisplay:
     """
@@ -35,6 +90,49 @@ class ConsoleDisplay:
         """
         self.config = config
         self._markup = config.logger.enable_markup if config else True
+        self._escape_xml = True
+
+    def _render_content_smartly(self, content: str, check_markdown_markers: bool = False) -> None:
+        """
+        Helper method to intelligently render content based on its type.
+
+        - Pure XML: Use syntax highlighting for readability
+        - Markdown (with markers): Use markdown rendering with proper escaping
+        - Plain text: Display as-is (when check_markdown_markers=True and no markers found)
+
+        Args:
+            content: The text content to render
+            check_markdown_markers: If True, only use markdown rendering when markers are present
+        """
+        import re
+
+        from rich.markdown import Markdown
+
+        # Check if content appears to be primarily XML
+        xml_pattern = r"^<[a-zA-Z_][a-zA-Z0-9_-]*[^>]*>"
+        is_xml_content = bool(re.match(xml_pattern, content.strip())) and content.count("<") > 5
+
+        if is_xml_content:
+            # Display XML content with syntax highlighting for better readability
+            from rich.syntax import Syntax
+
+            syntax = Syntax(content, "xml", theme=CODE_STYLE, line_numbers=False)
+            console.console.print(syntax, markup=self._markup)
+        elif check_markdown_markers:
+            # Check for markdown markers before deciding to use markdown rendering
+            if any(marker in content for marker in ["##", "**", "*", "`", "---", "###"]):
+                # Has markdown markers - render as markdown with escaping
+                prepared_content = _prepare_markdown_content(content, self._escape_xml)
+                md = Markdown(prepared_content, code_theme=CODE_STYLE)
+                console.console.print(md, markup=self._markup)
+            else:
+                # Plain text - display as-is
+                console.console.print(content, markup=self._markup)
+        else:
+            # Always treat as markdown with proper escaping
+            prepared_content = _prepare_markdown_content(content, self._escape_xml)
+            md = Markdown(prepared_content, code_theme=CODE_STYLE)
+            console.console.print(md, markup=self._markup)
 
     def show_tool_result(self, result: CallToolResult, name: str | None = None) -> None:
         """Display a tool result in the new visual style."""
@@ -341,7 +439,6 @@ class ConsoleDisplay:
         model: str | None = None,
     ) -> None:
         """Display an assistant message in a formatted panel."""
-        from rich.markdown import Markdown
 
         if not self.config or not self.config.logger.show_chat:
             return
@@ -385,9 +482,8 @@ class ConsoleDisplay:
                 json = JSON(message_text)
                 console.console.print(json, markup=self._markup)
             except (JSONDecodeError, TypeError, ValueError):
-                # Not JSON, treat as markdown
-                md = Markdown(content, code_theme=CODE_STYLE)
-                console.console.print(md, markup=self._markup)
+                # Use the smart rendering helper to handle XML vs Markdown
+                self._render_content_smartly(content)
         else:
             # Handle Rich Text objects directly
             console.console.print(message_text, markup=self._markup)
@@ -475,7 +571,6 @@ class ConsoleDisplay:
         self, message, model: str | None = None, chat_turn: int = 0, name: str | None = None
     ) -> None:
         """Display a user message in the new visual style."""
-        from rich.markdown import Markdown
 
         if not self.config or not self.config.logger.show_chat:
             return
@@ -495,9 +590,8 @@ class ConsoleDisplay:
 
         # Display content as markdown if it looks like markdown, otherwise as text
         if isinstance(message, str):
-            content = message
-            md = Markdown(content, code_theme=CODE_STYLE)
-            console.console.print(md, markup=self._markup)
+            # Use the smart rendering helper to handle XML vs Markdown
+            self._render_content_smartly(message)
         else:
             # Handle Text objects directly
             console.console.print(message, markup=self._markup)
@@ -587,7 +681,7 @@ class ConsoleDisplay:
         Args:
             parallel_agent: The parallel agent containing fan_out_agents with results
         """
-        from rich.markdown import Markdown
+
         from rich.text import Text
 
         if self.config and not self.config.logger.show_chat:
@@ -674,13 +768,9 @@ class ConsoleDisplay:
             console.console.print(left + " " * padding + right, markup=self._markup)
             console.console.print()
 
-            # Display content as markdown if it looks like markdown, otherwise as text
+            # Display content based on its type (check for markdown markers in parallel results)
             content = result["content"]
-            if any(marker in content for marker in ["##", "**", "*", "`", "---", "###"]):
-                md = Markdown(content, code_theme=CODE_STYLE)
-                console.console.print(md, markup=self._markup)
-            else:
-                console.console.print(content, markup=self._markup)
+            self._render_content_smartly(content, check_markdown_markers=True)
 
         # Summary
         console.console.print()