fast-agent-mcp 0.2.42__tar.gz → 0.2.44__tar.gz

{fast_agent_mcp-0.2.42 → fast_agent_mcp-0.2.44}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fast-agent-mcp
-Version: 0.2.42
+Version: 0.2.44
 Summary: Define, Prompt and Test MCP enabled Agents and Workflows
 Author-email: Shaun Smith <fastagent@llmindset.co.uk>
 License:                                  Apache License
@@ -218,7 +218,7 @@ Requires-Dist: deprecated>=1.2.18
 Requires-Dist: email-validator>=2.2.0
 Requires-Dist: fastapi>=0.115.6
 Requires-Dist: google-genai
-Requires-Dist: mcp==1.10.1
+Requires-Dist: mcp==1.12.0
 Requires-Dist: openai>=1.93.0
 Requires-Dist: opentelemetry-distro>=0.50b0
 Requires-Dist: opentelemetry-exporter-otlp-proto-http>=1.29.0
@@ -229,6 +229,7 @@ Requires-Dist: opentelemetry-instrumentation-openai>=0.40.14; python_version >=
 Requires-Dist: prompt-toolkit>=3.0.50
 Requires-Dist: pydantic-settings>=2.7.0
 Requires-Dist: pydantic>=2.10.4
+Requires-Dist: pyperclip>=1.9.0
 Requires-Dist: pyyaml>=6.0.2
 Requires-Dist: rich>=13.9.4
 Requires-Dist: tensorzero>=2025.6.3

{fast_agent_mcp-0.2.42 → fast_agent_mcp-0.2.44}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fast-agent-mcp"
-version = "0.2.42"
+version = "0.2.44"
 description = "Define, Prompt and Test MCP enabled Agents and Workflows"
 readme = "README.md"
 license = { file = "LICENSE" }
@@ -15,7 +15,7 @@ classifiers = [
 requires-python = ">=3.12"
 dependencies = [
     "fastapi>=0.115.6",
-    "mcp==1.10.1",
+    "mcp==1.12.0",
     "opentelemetry-distro>=0.50b0",
     "opentelemetry-exporter-otlp-proto-http>=1.29.0",
     "pydantic-settings>=2.7.0",
@@ -38,6 +38,7 @@ dependencies = [
     "deprecated>=1.2.18",
     "a2a-sdk>=0.2.9",
     "email-validator>=2.2.0",
+    "pyperclip>=1.9.0",
 ]
 
 [project.optional-dependencies]

{fast_agent_mcp-0.2.42 → fast_agent_mcp-0.2.44}/src/mcp_agent/agents/base_agent.py

@@ -330,12 +330,12 @@ class BaseAgent(MCPAggregator, AgentProtocol):
     def _matches_pattern(self, name: str, pattern: str, server_name: str) -> bool:
         """
         Check if a name matches a pattern for a specific server.
-        
+
         Args:
             name: The name to match (could be tool name, resource URI, or prompt name)
             pattern: The pattern to match against (e.g., "add", "math*", "resource://math/*")
             server_name: The server name (used for tool name prefixing)
-            
+
         Returns:
             True if the name matches the pattern
         """
@@ -343,7 +343,7 @@ class BaseAgent(MCPAggregator, AgentProtocol):
         if name.startswith(f"{server_name}-"):
             full_pattern = f"{server_name}-{pattern}"
             return fnmatch.fnmatch(name, full_pattern)
-        
+
         # For resources and prompts, match directly against the pattern
         return fnmatch.fnmatch(name, pattern)
 
@@ -365,9 +365,9 @@ class BaseAgent(MCPAggregator, AgentProtocol):
             filtered_tools = []
             for tool in result.tools:
                 # Extract server name from tool name (e.g., "mathematics-add" -> "mathematics")
-                if '-' in tool.name:
-                    server_name = tool.name.split('-', 1)[0]
-                    
+                if "-" in tool.name:
+                    server_name = tool.name.split("-", 1)[0]
+
                     # Check if this server has tool filters
                     if server_name in self.config.tools:
                         # Check if tool matches any pattern for this server
@@ -495,48 +495,70 @@ class BaseAgent(MCPAggregator, AgentProtocol):
 
     async def apply_prompt(
         self,
-        prompt_name: str,
+        prompt: Union[str, GetPromptResult],
         arguments: Dict[str, str] | None = None,
         agent_name: str | None = None,
         server_name: str | None = None,
+        as_template: bool = False,
     ) -> str:
         """
-        Apply an MCP Server Prompt by name and return the assistant's response.
+        Apply an MCP Server Prompt by name or GetPromptResult and return the assistant's response.
         Will search all available servers for the prompt if not namespaced and no server_name provided.
 
         If the last message in the prompt is from a user, this will automatically
         generate an assistant response to ensure we always end with an assistant message.
 
         Args:
-            prompt_name: The name of the prompt to apply
+            prompt: The name of the prompt to apply OR a GetPromptResult object
             arguments: Optional dictionary of string arguments to pass to the prompt template
             agent_name: Optional agent name (ignored at this level, used by multi-agent apps)
             server_name: Optional name of the server to get the prompt from
+            as_template: If True, store as persistent template (always included in context)
 
         Returns:
             The assistant's response or error message
         """
 
-        # Get the prompt - this will search all servers if needed
-        self.logger.debug(f"Loading prompt '{prompt_name}'")
-        prompt_result: GetPromptResult = await self.get_prompt(prompt_name, arguments, server_name)
+        # Handle both string and GetPromptResult inputs
+        if isinstance(prompt, str):
+            prompt_name = prompt
+            # Get the prompt - this will search all servers if needed
+            self.logger.debug(f"Loading prompt '{prompt_name}'")
+            prompt_result: GetPromptResult = await self.get_prompt(
+                prompt_name, arguments, server_name
+            )
+
+            if not prompt_result or not prompt_result.messages:
+                error_msg = f"Prompt '{prompt_name}' could not be found or contains no messages"
+                self.logger.warning(error_msg)
+                return error_msg
 
-        if not prompt_result or not prompt_result.messages:
-            error_msg = f"Prompt '{prompt_name}' could not be found or contains no messages"
-            self.logger.warning(error_msg)
-            return error_msg
+            # Get the display name (namespaced version)
+            namespaced_name = getattr(prompt_result, "namespaced_name", prompt_name)
+        else:
+            # prompt is a GetPromptResult object
+            prompt_result = prompt
+            if not prompt_result or not prompt_result.messages:
+                error_msg = "Provided GetPromptResult contains no messages"
+                self.logger.warning(error_msg)
+                return error_msg
+
+            # Use a reasonable display name
+            namespaced_name = getattr(prompt_result, "namespaced_name", "provided_prompt")
 
-        # Get the display name (namespaced version)
-        namespaced_name = getattr(prompt_result, "namespaced_name", prompt_name)
         self.logger.debug(f"Using prompt '{namespaced_name}'")
 
         # Convert prompt messages to multipart format using the safer method
         multipart_messages = PromptMessageMultipart.from_get_prompt_result(prompt_result)
 
-        # Always call generate to ensure LLM implementations can handle prompt templates
-        # This is critical for stateful LLMs like PlaybackLLM
-        response = await self.generate(multipart_messages, None)
-        return response.first_text()
+        if as_template:
+            # Use apply_prompt_template to store as persistent prompt messages
+            return await self.apply_prompt_template(prompt_result, namespaced_name)
+        else:
+            # Always call generate to ensure LLM implementations can handle prompt templates
+            # This is critical for stateful LLMs like PlaybackLLM
+            response = await self.generate(multipart_messages, None)
+            return response.first_text()
 
     async def get_embedded_resources(
         self, resource_uri: str, server_name: str | None = None
@@ -636,6 +658,22 @@ class BaseAgent(MCPAggregator, AgentProtocol):
         with self.tracer.start_as_current_span(f"Agent: '{self.name}' generate"):
             return await self._llm.generate(multipart_messages, request_params)
 
+    async def apply_prompt_template(self, prompt_result: GetPromptResult, prompt_name: str) -> str:
+        """
+        Apply a prompt template as persistent context that will be included in all future conversations.
+        Delegates to the attached LLM.
+
+        Args:
+            prompt_result: The GetPromptResult containing prompt messages
+            prompt_name: The name of the prompt being applied
+
+        Returns:
+            String representation of the assistant's response if generated
+        """
+        assert self._llm
+        with self.tracer.start_as_current_span(f"Agent: '{self.name}' apply_prompt_template"):
+            return await self._llm.apply_prompt_template(prompt_result, prompt_name)
+
     async def structured(
         self,
         multipart_messages: List[PromptMessageMultipart],

{fast_agent_mcp-0.2.42 → fast_agent_mcp-0.2.44}/src/mcp_agent/config.py

@@ -319,6 +319,8 @@ class LoggerSettings(BaseModel):
     """Truncate display of long tool calls"""
     enable_markup: bool = True
     """Enable markup in console output. Disable for outputs that may conflict with rich console formatting"""
+    use_legacy_display: bool = False
+    """Use the legacy console display instead of the new style display"""
 
 
 def find_fastagent_config_files(start_path: Path) -> Tuple[Optional[Path], Optional[Path]]:

{fast_agent_mcp-0.2.42 → fast_agent_mcp-0.2.44}/src/mcp_agent/core/agent_app.py

@@ -5,7 +5,7 @@ Direct AgentApp implementation for interacting with agents without proxies.
 from typing import Dict, List, Optional, Union
 
 from deprecated import deprecated
-from mcp.types import PromptMessage
+from mcp.types import GetPromptResult, PromptMessage
 from rich import print as rich_print
 
 from mcp_agent.agents.agent import Agent
@@ -108,22 +108,26 @@ class AgentApp:
 
     async def apply_prompt(
         self,
-        prompt_name: str,
+        prompt: Union[str, GetPromptResult],
         arguments: Dict[str, str] | None = None,
         agent_name: str | None = None,
+        as_template: bool = False,
     ) -> str:
         """
         Apply a prompt template to an agent (default agent if not specified).
 
         Args:
-            prompt_name: Name of the prompt template to apply
+            prompt: Name of the prompt template to apply OR a GetPromptResult object
             arguments: Optional arguments for the prompt template
             agent_name: Name of the agent to send to
+            as_template: If True, store as persistent template (always included in context)
 
         Returns:
             The agent's response as a string
         """
-        return await self._agent(agent_name).apply_prompt(prompt_name, arguments)
+        return await self._agent(agent_name).apply_prompt(
+            prompt, arguments, as_template=as_template
+        )
 
     async def list_prompts(self, server_name: str | None = None, agent_name: str | None = None):
         """
@@ -235,7 +239,12 @@ class AgentApp:
         """
         return await self.interactive(agent_name=agent_name, default_prompt=default_prompt)
 
-    async def interactive(self, agent_name: str | None = None, default_prompt: str = "", pretty_print_parallel: bool = False) -> str:
+    async def interactive(
+        self,
+        agent_name: str | None = None,
+        default_prompt: str = "",
+        pretty_print_parallel: bool = False,
+    ) -> str:
         """
         Interactive prompt for sending messages with advanced features.
 
@@ -283,6 +292,7 @@ class AgentApp:
                 agent = self._agents.get(agent_name)
                 if agent and agent.agent_type == AgentType.PARALLEL:
                     from mcp_agent.ui.console_display import ConsoleDisplay
+
                     display = ConsoleDisplay(config=None)
                     display.show_parallel_results(agent)
 

{fast_agent_mcp-0.2.42 → fast_agent_mcp-0.2.44}/src/mcp_agent/core/enhanced_prompt.py

@@ -69,7 +69,9 @@ async def _display_agent_info_helper(agent_name: str, agent_provider: object) ->
         )
 
         resources_dict = await agent.list_resources()
-        resource_count = sum(len(resources) for resources in resources_dict.values()) if resources_dict else 0
+        resource_count = (
+            sum(len(resources) for resources in resources_dict.values()) if resources_dict else 0
+        )
 
         prompts_dict = await agent.list_prompts()
         prompt_count = sum(len(prompts) for prompts in prompts_dict.values()) if prompts_dict else 0
@@ -104,15 +106,35 @@ async def _display_agent_info_helper(agent_name: str, agent_provider: object) ->
         else:
             # For regular agents, only display if they have MCP servers attached
             if server_count > 0:
-                # Pluralization helpers
+                # Build display parts in order: tools, prompts, resources (omit if count is 0)
+                display_parts = []
+
+                if tool_count > 0:
+                    tool_word = "tool" if tool_count == 1 else "tools"
+                    display_parts.append(f"{tool_count:,}[dim] {tool_word}[/dim]")
+
+                if prompt_count > 0:
+                    prompt_word = "prompt" if prompt_count == 1 else "prompts"
+                    display_parts.append(f"{prompt_count:,}[dim] {prompt_word}[/dim]")
+
+                if resource_count > 0:
+                    resource_word = "resource" if resource_count == 1 else "resources"
+                    display_parts.append(f"{resource_count:,}[dim] {resource_word}[/dim]")
+
+                # Always show server count
                 server_word = "Server" if server_count == 1 else "Servers"
-                tool_word = "tool" if tool_count == 1 else "tools"
-                resource_word = "resource" if resource_count == 1 else "resources"
-                prompt_word = "prompt" if prompt_count == 1 else "prompts"
+                server_text = f"{server_count:,}[dim] MCP {server_word}[/dim]"
 
-                rich_print(
-                    f"[dim]Agent [/dim][blue]{agent_name}[/blue][dim]:[/dim] {server_count:,}[dim] MCP {server_word}, [/dim]{tool_count:,}[dim] {tool_word}, [/dim]{resource_count:,}[dim] {resource_word}, [/dim]{prompt_count:,}[dim] {prompt_word} available[/dim]"
-                )
+                if display_parts:
+                    content = (
+                        f"{server_text}[dim], [/dim]"
+                        + "[dim], [/dim]".join(display_parts)
+                        + "[dim] available[/dim]"
+                    )
+                else:
+                    content = f"{server_text}[dim] available[/dim]"
+
+                rich_print(f"[dim]Agent [/dim][blue]{agent_name}[/blue][dim]:[/dim] {content}")
 
         # Mark as shown
         _agent_info_shown.add(agent_name)
@@ -226,7 +248,9 @@ async def _display_child_agent_info(child_agent, prefix: str, agent_provider) ->
         )
 
         resources_dict = await child_agent.list_resources()
-        resource_count = sum(len(resources) for resources in resources_dict.values()) if resources_dict else 0
+        resource_count = (
+            sum(len(resources) for resources in resources_dict.values()) if resources_dict else 0
+        )
 
         prompts_dict = await child_agent.list_prompts()
         prompt_count = sum(len(prompts) for prompts in prompts_dict.values()) if prompts_dict else 0
@@ -270,6 +294,7 @@ class AgentCompleter(Completer):
             "prompt": "List and select MCP prompts, or apply specific prompt (/prompt <name>)",
             "agents": "List available agents",
             "usage": "Show current usage statistics",
+            "markdown": "Show last assistant message without markdown formatting",
             "help": "Show available commands",
             "clear": "Clear the screen",
             "STOP": "Stop this prompting session and move to next workflow step",
@@ -394,7 +419,7 @@ def get_text_from_editor(initial_text: str = "") -> str:
     return edited_text.strip()  # Added strip() to remove trailing newlines often added by editors
 
 
-def create_keybindings(on_toggle_multiline=None, app=None):
+def create_keybindings(on_toggle_multiline=None, app=None, agent_provider=None, agent_name=None):
     """Create custom key bindings."""
     kb = KeyBindings()
 
@@ -459,6 +484,41 @@ def create_keybindings(on_toggle_multiline=None, app=None):
             if event.app:
                 event.app.invalidate()
 
+    # Store reference to agent provider and agent name for clipboard functionality
+    kb.agent_provider = agent_provider
+    kb.current_agent_name = agent_name
+
+    @kb.add("c-y")
+    async def _(event) -> None:
+        """Ctrl+Y: Copy last assistant response to clipboard."""
+        if kb.agent_provider and kb.current_agent_name:
+            try:
+                # Get the agent
+                if hasattr(kb.agent_provider, "_agent"):
+                    agent = kb.agent_provider._agent(kb.current_agent_name)
+                else:
+                    agent = kb.agent_provider
+
+                # Get message history
+                if hasattr(agent, "_llm") and agent._llm and agent._llm.message_history:
+                    # Find last assistant message
+                    for msg in reversed(agent._llm.message_history):
+                        if msg.role == "assistant":
+                            content = msg.last_text()
+                            import pyperclip
+
+                            pyperclip.copy(content)
+                            rich_print("\n[green]✓ Copied to clipboard[/green]")
+                            return
+
+                    rich_print("\n[yellow]No assistant messages found[/yellow]")
+                else:
+                    rich_print("\n[yellow]No message history available[/yellow]")
+            except Exception as e:
+                rich_print(f"\n[red]Error copying: {e}[/red]")
+        else:
+            rich_print("[yellow]Clipboard copy not available in this context[/yellow]")
+
     return kb
 
 
@@ -523,6 +583,7 @@ async def get_enhanced_input(
         shortcuts = [
             ("Ctrl+T", toggle_text),
             ("Ctrl+E", "External"),
+            ("Ctrl+Y", "Copy"),
             ("Ctrl+L", "Clear"),
             ("↑/↓", "History"),
         ]
@@ -565,7 +626,12 @@ async def get_enhanced_input(
     )
 
     # Create key bindings with a reference to the app
-    bindings = create_keybindings(on_toggle_multiline=on_multiline_toggle, app=session.app)
+    bindings = create_keybindings(
+        on_toggle_multiline=on_multiline_toggle,
+        app=session.app,
+        agent_provider=agent_provider,
+        agent_name=agent_name,
+    )
     session.app.key_bindings = bindings
 
     # Create formatted prompt text
@@ -615,6 +681,8 @@ async def get_enhanced_input(
                 return "LIST_AGENTS"
             elif cmd == "usage":
                 return "SHOW_USAGE"
+            elif cmd == "markdown":
+                return "MARKDOWN"
             elif cmd == "prompt":
                 # Handle /prompt with no arguments as interactive mode
                 if len(cmd_parts) > 1:
@@ -788,16 +856,18 @@ async def handle_special_commands(command, agent_app=None):
         rich_print("  /help          - Show this help")
         rich_print("  /clear         - Clear screen")
         rich_print("  /agents        - List available agents")
-        rich_print("  /prompts       - List and select MCP prompts")
         rich_print("  /prompt <name> - Apply a specific prompt by name")
         rich_print("  /usage         - Show current usage statistics")
+        rich_print("  /markdown      - Show last assistant message without markdown formatting")
         rich_print("  @agent_name    - Switch to agent")
         rich_print("  STOP           - Return control back to the workflow")
         rich_print("  EXIT           - Exit fast-agent, terminating any running workflows")
         rich_print("\n[bold]Keyboard Shortcuts:[/bold]")
         rich_print("  Enter          - Submit (normal mode) / New line (multiline mode)")
-        rich_print("  Ctrl+Enter      - Always submit (in any mode)")
+        rich_print("  Ctrl+Enter     - Always submit (in any mode)")
         rich_print("  Ctrl+T         - Toggle multiline mode")
+        rich_print("  Ctrl+E         - Edit in external editor")
+        rich_print("  Ctrl+Y         - Copy last assistant response to clipboard")
         rich_print("  Ctrl+L         - Clear input")
         rich_print("  Up/Down        - Navigate history")
         return True
@@ -823,6 +893,10 @@ async def handle_special_commands(command, agent_app=None):
         # Return a dictionary to signal that usage should be shown
         return {"show_usage": True}
 
+    elif command == "MARKDOWN":
+        # Return a dictionary to signal that markdown display should be shown
+        return {"show_markdown": True}
+
     elif command == "SELECT_PROMPT" or (
         isinstance(command, str) and command.startswith("SELECT_PROMPT:")
     ):

{fast_agent_mcp-0.2.42 → fast_agent_mcp-0.2.44}/src/mcp_agent/core/fastagent.py

@@ -314,7 +314,7 @@ class FastAgent:
                         self.agents,
                         model_factory_func,
                     )
-                    
+
                     # Validate API keys after agent creation
                     validate_provider_keys_post_creation(active_agents)
 
@@ -435,6 +435,14 @@ class FastAgent:
                 raise SystemExit(1)
 
             finally:
+                # Ensure progress display is stopped before showing usage summary
+                try:
+                    from mcp_agent.progress_display import progress_display
+
+                    progress_display.stop()
+                except:  # noqa: E722
+                    pass
+
                 # Print usage report before cleanup (show for user exits too)
                 if active_agents and not had_error:
                     self._print_usage_report(active_agents)

{fast_agent_mcp-0.2.42 → fast_agent_mcp-0.2.44}/src/mcp_agent/core/interactive_prompt.py

@@ -30,7 +30,7 @@ from mcp_agent.core.enhanced_prompt import (
     handle_special_commands,
 )
 from mcp_agent.core.usage_display import collect_agents_from_provider, display_usage_report
-from mcp_agent.mcp.mcp_aggregator import SEP  # Import SEP once at the top
+from mcp_agent.mcp.mcp_aggregator import SEP
 from mcp_agent.mcp.prompt_message_multipart import PromptMessageMultipart
 from mcp_agent.progress_display import progress_display
 
@@ -56,6 +56,7 @@ class PromptProvider(Protocol):
         prompt_title: Optional[str] = None,
         arguments: Optional[Dict[str, str]] = None,
         agent_name: Optional[str] = None,
+        as_template: bool = False,
         **kwargs,
     ) -> str:
         """Apply a prompt."""
@@ -188,6 +189,10 @@ class InteractivePrompt:
                         # Handle usage display
                         await self._show_usage(prompt_provider, agent)
                         continue
+                    elif "show_markdown" in command_result:
+                        # Handle markdown display
+                        await self._show_markdown(prompt_provider, agent)
+                        continue
 
                 # Skip further processing if:
                 # 1. The command was handled (command_result is truthy)
@@ -713,3 +718,57 @@ class InteractivePrompt:
 
         except Exception as e:
             rich_print(f"[red]Error showing usage: {e}[/red]")
+
+    async def _show_markdown(self, prompt_provider: PromptProvider, agent_name: str) -> None:
+        """
+        Show the last assistant message without markdown formatting.
+
+        Args:
+            prompt_provider: Provider that has access to agents
+            agent_name: Name of the current agent
+        """
+        try:
+            # Get agent to display from
+            if hasattr(prompt_provider, "_agent"):
+                # This is an AgentApp - get the specific agent
+                agent = prompt_provider._agent(agent_name)
+            else:
+                # This is a single agent
+                agent = prompt_provider
+
+            # Check if agent has message history
+            if not hasattr(agent, "_llm") or not agent._llm:
+                rich_print("[yellow]No message history available[/yellow]")
+                return
+
+            message_history = agent._llm.message_history
+            if not message_history:
+                rich_print("[yellow]No messages in history[/yellow]")
+                return
+
+            # Find the last assistant message
+            last_assistant_msg = None
+            for msg in reversed(message_history):
+                if msg.role == "assistant":
+                    last_assistant_msg = msg
+                    break
+
+            if not last_assistant_msg:
+                rich_print("[yellow]No assistant messages found[/yellow]")
+                return
+
+            # Get the text content and display without markdown
+            content = last_assistant_msg.last_text()
+
+            # Display with a simple header
+            rich_print("\n[bold blue]Last Assistant Response (Plain Text):[/bold blue]")
+            rich_print("─" * 60)
+            # Use console.print with markup=False to display raw text
+            from mcp_agent import console
+
+            console.console.print(content, markup=False)
+            rich_print("─" * 60)
+            rich_print()
+
+        except Exception as e:
+            rich_print(f"[red]Error showing markdown: {e}[/red]")

{fast_agent_mcp-0.2.42 → fast_agent_mcp-0.2.44}/src/mcp_agent/core/usage_display.py

@@ -91,12 +91,19 @@ def display_usage_report(
     max_agent_width = min(15, max(len(data["name"]) for data in usage_data) if usage_data else 8)
     agent_width = max(max_agent_width, 5)  # Minimum of 5 for "Agent" header
 
-    # Display the table
+    # Display the table with new visual style
     console = Console()
+
+    # Top separator
+    console.print()
+    console.print("─" * console.size.width, style="dim")
+    console.print()
+
+    # Header with block character
+    console.print("[dim]▎[/dim] [bold dim]Usage Summary[/bold dim]")
     console.print()
-    console.print("[dim]Usage Summary (Cumulative)[/dim]")
 
-    # Print header with proper spacing
+    # Table header with proper spacing
     console.print(
         f"[dim]{'Agent':<{agent_width}} {'Input':>9} {'Output':>9} {'Total':>9} {'Turns':>6} {'Tools':>6} {'Context%':>9}  {'Model':<25}[/dim]"
     )

{fast_agent_mcp-0.2.42 → fast_agent_mcp-0.2.44}/src/mcp_agent/llm/augmented_llm.py

@@ -46,7 +46,6 @@ from mcp_agent.mcp.interfaces import (
 from mcp_agent.mcp.mcp_aggregator import MCPAggregator
 from mcp_agent.mcp.prompt_message_multipart import PromptMessageMultipart
 from mcp_agent.mcp.prompt_render import render_multipart_message
-from mcp_agent.ui.console_display import ConsoleDisplay
 
 # Define type variables locally
 MessageParamT = TypeVar("MessageParamT")
@@ -157,6 +156,10 @@ class AugmentedLLM(ContextDependent, AugmentedLLMProtocol, Generic[MessageParamT
         self._message_history: List[PromptMessageMultipart] = []
 
         # Initialize the display component
+        if self.context.config and self.context.config.logger.use_legacy_display:
+            from mcp_agent.ui.console_display_legacy import ConsoleDisplay
+        else:
+            from mcp_agent.ui.console_display import ConsoleDisplay
         self.display = ConsoleDisplay(config=self.context.config)
 
         # Tool call counter for current turn
@@ -448,10 +451,6 @@ class AugmentedLLM(ContextDependent, AugmentedLLMProtocol, Generic[MessageParamT
         """Display a tool result in a formatted panel."""
         self.display.show_tool_result(result, name=self.name)
 
-    def show_oai_tool_result(self, result: str) -> None:
-        """Display a tool result in a formatted panel."""
-        self.display.show_oai_tool_result(result, name=self.name)
-
     def show_tool_call(self, available_tools, tool_name, tool_args) -> None:
         """Display a tool call in a formatted panel."""
         self._current_turn_tool_calls += 1

{fast_agent_mcp-0.2.42 → fast_agent_mcp-0.2.44}/src/mcp_agent/llm/augmented_llm_passthrough.py

@@ -162,8 +162,17 @@ class PassthroughLLM(AugmentedLLM):
         self,
         multipart_messages: List["PromptMessageMultipart"],
         request_params: RequestParams | None = None,
+        is_template: bool = False,
     ) -> PromptMessageMultipart:
+        print(
+            f"DEBUG: PassthroughLLM _apply_prompt_provider_specific called with {len(multipart_messages)} messages, is_template={is_template}"
+        )
+
+        # Add messages to history with proper is_prompt flag
+        self.history.extend(multipart_messages, is_prompt=is_template)
+
         last_message = multipart_messages[-1]
+        print(f"DEBUG: Last message role: {last_message.role}, text: '{last_message.first_text()}'")
 
         if self.is_tool_call(last_message):
             result = Prompt.assistant(await self.generate_str(last_message.first_text()))
@@ -200,8 +209,14 @@ class PassthroughLLM(AugmentedLLM):
         else:
             # TODO -- improve when we support Audio/Multimodal gen models e.g. gemini . This should really just return the input as "assistant"...
             concatenated: str = "\n".join(message.all_text() for message in multipart_messages)
+            print(
+                f"DEBUG: PassthroughLLM generating response: '{concatenated}' (is_template={is_template})"
+            )
             await self.show_assistant_message(concatenated)
             result = Prompt.assistant(concatenated)
+            print(f"DEBUG: PassthroughLLM created result: {result}")
+            print(f"DEBUG: Result first_text(): {result.first_text()}")
+            print(f"DEBUG: Result content: {result.content}")
 
         # Track usage for this passthrough "turn"
         try: