fast-agent-mcp 0.1.7__tar.gz → 0.1.9__tar.gz

{fast_agent_mcp-0.1.7 → fast_agent_mcp-0.1.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fast-agent-mcp
-Version: 0.1.7
+Version: 0.1.9
 Summary: Define, Prompt and Test MCP enabled Agents and Workflows
 Author-email: Shaun Smith <fastagent@llmindset.co.uk>, Sarmad Qadri <sarmad@lastmileai.dev>
 License:                                  Apache License
@@ -209,10 +209,10 @@ Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Requires-Python: >=3.10
-Requires-Dist: anthropic>=0.42.0
+Requires-Dist: aiohttp>=3.11.13
+Requires-Dist: anthropic>=0.49.0
 Requires-Dist: fastapi>=0.115.6
-Requires-Dist: instructor>=1.7.2
-Requires-Dist: mcp==1.2.1
+Requires-Dist: mcp>=1.4.1
 Requires-Dist: numpy>=2.2.1
 Requires-Dist: openai>=1.63.2
 Requires-Dist: opentelemetry-distro>=0.50b0
@@ -224,11 +224,17 @@ Requires-Dist: pyyaml>=6.0.2
 Requires-Dist: rich>=13.9.4
 Requires-Dist: scikit-learn>=1.6.0
 Requires-Dist: typer>=0.15.1
-Provides-Extra: anthropic
-Requires-Dist: anthropic>=0.42.0; extra == 'anthropic'
-Requires-Dist: instructor[anthropic]>=1.7.2; extra == 'anthropic'
 Provides-Extra: cohere
 Requires-Dist: cohere>=5.13.4; extra == 'cohere'
+Provides-Extra: dev
+Requires-Dist: anthropic>=0.42.0; extra == 'dev'
+Requires-Dist: pre-commit>=4.0.1; extra == 'dev'
+Requires-Dist: pydantic>=2.10.4; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.21.1; extra == 'dev'
+Requires-Dist: pytest>=7.4.0; extra == 'dev'
+Requires-Dist: pyyaml>=6.0.2; extra == 'dev'
+Requires-Dist: ruff>=0.8.4; extra == 'dev'
+Requires-Dist: tomli>=2.2.1; extra == 'dev'
 Provides-Extra: openai
 Requires-Dist: openai>=1.58.1; extra == 'openai'
 Provides-Extra: temporal
@@ -253,6 +259,10 @@ The simple declarative syntax lets you concentrate on composing your Prompts and
 
 Evaluate how different models handle Agent and MCP Server calling tasks, then build multi-model workflows using the best provider for each task.
 
+`fast-agent` is now multi-modal, supporting Images and PDFs for both Anthropic and OpenAI endpoints (for supported models), via Prompts and MCP Tool Call results.
+
+> [!TIP] > `fast-agent` is now MCP Native! Coming Soon - Full Documentation Site.
+
 ### Agent Application Development
 
 Prompts and configurations that define your Agent Applications are stored in simple files, with minimal boilerplate, enabling simple management and version control.
@@ -582,6 +592,19 @@ agent["greeter"].send("Good Evening!")          # Dictionary access is supported
 )
 ```
 
+### Multimodal Support
+
+Add Resources to prompts using either the inbuilt `prompt-server` or MCP Types directly. Convenience class are made available to do so simply, for example:
+
+#### MCP Tool Result Conversion
+
+LLM APIs have restrictions on the content types that can be returned as Tool Calls/Function results via their Chat Completions API's:
+
+- OpenAI supports Text
+- Anthropic supports Text and Image
+
+For MCP Tool Results, `ImageResources` and `EmbeddedResources` are converted to User Messages and added to the conversation.
+
 ### Prompts
 
 MCP Prompts are supported with `apply_prompt(name,arguments)`, which always returns an Assistant Message. If the last message from the MCP Server is a 'User' message, it is sent to the LLM for processing. Prompts applied to the Agent's Context are retained - meaning that with `use_history=False`, Agents can act as finely tuned responders.
@@ -599,8 +622,9 @@ Prompts can also be applied interactively through the interactive interface by u
 
 ### llmindset.co.uk fork:
 
+- Addition of MCP Prompts including Prompt Server and agent save/replay ability.
 - Overhaul of Eval/Opt for Conversation Management
-- Remove instructor use for Orchestrator
+- Removed instructor/double-llm calling - native structured outputs for OAI.
 - Improved handling of Parallel/Fan-In and respose option
 - XML based generated prompts
 - "FastAgent" style prototyping, with per-agent models
@@ -619,4 +643,8 @@ Prompts can also be applied interactively through the interactive interface by u
 - Declarative workflows
 - Numerous defect fixes
 
-### Features to add.
+### Features to add (Commmitted)
+
+- Run Agent as MCP Server, with interop
+- Multi-part content types supporing Vision, PDF and multi-part Text.
+- Improved test automation (supported by prompt_server.py and augmented_llm_playback.py)

{fast_agent_mcp-0.1.7 → fast_agent_mcp-0.1.9}/README.md

@@ -16,6 +16,10 @@ The simple declarative syntax lets you concentrate on composing your Prompts and
 
 Evaluate how different models handle Agent and MCP Server calling tasks, then build multi-model workflows using the best provider for each task.
 
+`fast-agent` is now multi-modal, supporting Images and PDFs for both Anthropic and OpenAI endpoints (for supported models), via Prompts and MCP Tool Call results.
+
+> [!TIP] > `fast-agent` is now MCP Native! Coming Soon - Full Documentation Site.
+
 ### Agent Application Development
 
 Prompts and configurations that define your Agent Applications are stored in simple files, with minimal boilerplate, enabling simple management and version control.
@@ -345,6 +349,19 @@ agent["greeter"].send("Good Evening!")          # Dictionary access is supported
 )
 ```
 
+### Multimodal Support
+
+Add Resources to prompts using either the inbuilt `prompt-server` or MCP Types directly. Convenience class are made available to do so simply, for example:
+
+#### MCP Tool Result Conversion
+
+LLM APIs have restrictions on the content types that can be returned as Tool Calls/Function results via their Chat Completions API's:
+
+- OpenAI supports Text
+- Anthropic supports Text and Image
+
+For MCP Tool Results, `ImageResources` and `EmbeddedResources` are converted to User Messages and added to the conversation.
+
 ### Prompts
 
 MCP Prompts are supported with `apply_prompt(name,arguments)`, which always returns an Assistant Message. If the last message from the MCP Server is a 'User' message, it is sent to the LLM for processing. Prompts applied to the Agent's Context are retained - meaning that with `use_history=False`, Agents can act as finely tuned responders.
@@ -362,8 +379,9 @@ Prompts can also be applied interactively through the interactive interface by u
 
 ### llmindset.co.uk fork:
 
+- Addition of MCP Prompts including Prompt Server and agent save/replay ability.
 - Overhaul of Eval/Opt for Conversation Management
-- Remove instructor use for Orchestrator
+- Removed instructor/double-llm calling - native structured outputs for OAI.
 - Improved handling of Parallel/Fan-In and respose option
 - XML based generated prompts
 - "FastAgent" style prototyping, with per-agent models
@@ -382,4 +400,8 @@ Prompts can also be applied interactively through the interactive interface by u
 - Declarative workflows
 - Numerous defect fixes
 
-### Features to add.
+### Features to add (Commmitted)
+
+- Run Agent as MCP Server, with interop
+- Multi-part content types supporing Vision, PDF and multi-part Text.
+- Improved test automation (supported by prompt_server.py and augmented_llm_playback.py)

{fast_agent_mcp-0.1.7 → fast_agent_mcp-0.1.9}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fast-agent-mcp"
-version = "0.1.7"
+version = "0.1.9"
 description = "Define, Prompt and Test MCP enabled Agents and Workflows"
 readme = "README.md"
 license = { file = "LICENSE" }
@@ -16,8 +16,7 @@ classifiers = [
 requires-python = ">=3.10"
 dependencies = [
     "fastapi>=0.115.6",
-    "instructor>=1.7.2",
-    "mcp==1.2.1",
+    "mcp>=1.4.1",
     "opentelemetry-distro>=0.50b0",
     "opentelemetry-exporter-otlp-proto-http>=1.29.0",
     "pydantic-settings>=2.7.0",
@@ -27,25 +26,32 @@ dependencies = [
     "typer>=0.15.1",
     "numpy>=2.2.1",
     "scikit-learn>=1.6.0",
-    "anthropic>=0.42.0",
+    "anthropic>=0.49.0",
     "openai>=1.63.2",
     "prompt-toolkit>=3.0.50",
+    "aiohttp>=3.11.13",
 ]
 
 [project.optional-dependencies]
 temporal = [
     "temporalio>=1.8.0",
 ]
-anthropic = [
-    "anthropic>=0.42.0",
-    "instructor[anthropic]>=1.7.2",
-]
 openai = [
     "openai>=1.58.1",
 ]
 cohere = [
     "cohere>=5.13.4",
 ]
+dev = [
+    "anthropic>=0.42.0",
+    "pre-commit>=4.0.1",
+    "pydantic>=2.10.4",
+    "pyyaml>=6.0.2",
+    "ruff>=0.8.4",
+    "tomli>=2.2.1",
+    "pytest>=7.4.0",
+    "pytest-asyncio>=0.21.1",
+]
 
 [build-system]
 requires = ["hatchling"]
@@ -66,14 +72,27 @@ include = [
     "src/mcp_agent/resources/**/*.csv",
 ]
 
+[tool.pytest.ini_options]
+asyncio_mode = "strict"
+asyncio_default_fixture_loop_scope = "function"
+markers = [
+    "e2e: tests that connect to external resources (llms)",
+    "integration: marks tests as integration tests",
+    "simulated_endpoints: marks tests that use simulated external endpoints"
+]
+# Other pytest options can go here too
+testpaths = ["test", "integration_tests"]
+
 [dependency-groups]
 dev = [
-    "anthropic>=0.42.0",
+    "anthropic>=0.49.0",
     "pre-commit>=4.0.1",
     "pydantic>=2.10.4",
     "pyyaml>=6.0.2",
     "ruff>=0.8.4",
     "tomli>=2.2.1",
+    "pytest>=7.4.0",
+    "pytest-asyncio>=0.21.1",
 ]
 
 [project.scripts]
@@ -81,6 +100,7 @@ fast-agent = "mcp_agent.cli.__main__:app"
 fast_agent = "mcp_agent.cli.__main__:app"
 fastagent = "mcp_agent.cli.__main__:app"
 silsila = "mcp_agent.cli.__main__:app"
+prompt-server = "mcp_agent.mcp.prompts.__main__:main"
 
 [tool.setuptools.package-data]
 mcp_agent = [

{fast_agent_mcp-0.1.7 → fast_agent_mcp-0.1.9}/src/mcp_agent/agents/agent.py

@@ -320,18 +320,20 @@ class Agent(MCPAggregator):
                 ],
             )
 
-    async def apply_prompt(self, prompt_name: str, arguments: dict[str, str] = None) -> str:
+    async def apply_prompt(
+        self, prompt_name: str, arguments: dict[str, str] = None
+    ) -> str:
         """
         Apply an MCP Server Prompt by name and return the assistant's response.
         Will search all available servers for the prompt if not namespaced.
-        
+
         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
             arguments: Optional dictionary of string arguments to pass to the prompt template
-            
+
         Returns:
             The assistant's response or error message
         """
@@ -357,11 +359,3 @@ class Agent(MCPAggregator):
         # The LLM will automatically generate a response if needed
         result = await self._llm.apply_prompt_template(prompt_result, display_name)
         return result
-
-    # For backward compatibility
-    async def load_prompt(self, prompt_name: str, arguments: dict[str, str] = None) -> str:
-        """
-        Legacy method - use apply_prompt instead.
-        This is maintained for backward compatibility.
-        """
-        return await self.apply_prompt(prompt_name, arguments)

{fast_agent_mcp-0.1.7 → fast_agent_mcp-0.1.9}/src/mcp_agent/core/agent_app.py

@@ -2,9 +2,10 @@
 Main application wrapper for interacting with agents.
 """
 
-from typing import Optional, Dict, TYPE_CHECKING
+from typing import Optional, Dict, Union, TYPE_CHECKING
 
 from mcp_agent.app import MCPApp
+from mcp_agent.mcp.prompt_message_multipart import PromptMessageMultipart
 from mcp_agent.progress_display import progress_display
 from mcp_agent.workflows.orchestrator.orchestrator import Orchestrator
 from mcp_agent.workflows.parallel.parallel_llm import ParallelLLM
@@ -37,16 +38,80 @@ class AgentApp:
         # Optional: set default agent for direct calls
         self._default = next(iter(agents)) if agents else None
 
-    async def send(self, agent_name: str, message: Optional[str]) -> str:
-        """Core message sending"""
-        if agent_name not in self._agents:
-            raise ValueError(f"No agent named '{agent_name}'")
+    async def send_prompt(
+        self, prompt: PromptMessageMultipart, agent_name: Optional[str] = None
+    ) -> str:
+        """
+        Send a PromptMessageMultipart to an agent
+
+        Args:
+            prompt: The PromptMessageMultipart to send
+            agent_name: The name of the agent to send to (uses default if None)
+
+        Returns:
+            The agent's response as a string
+        """
+        target = agent_name or self._default
+        if not target:
+            raise ValueError("No default agent available")
+
+        if target not in self._agents:
+            raise ValueError(f"No agent named '{target}'")
+
+        proxy = self._agents[target]
+        return await proxy.send_prompt(prompt)
+
+    async def send(
+        self,
+        message: Union[str, PromptMessageMultipart] = None,
+        agent_name: Optional[str] = None,
+    ) -> str:
+        """
+        Send a message to the default agent or specified agent
+
+        Args:
+            message: Either a string message or a PromptMessageMultipart object
+            agent_name: The name of the agent to send to (uses default if None)
 
-        if not message or "" == message:
-            return await self.prompt(agent_name)
+        Returns:
+            The agent's response as a string
+        """
+        target = agent_name or self._default
+        if not target:
+            raise ValueError("No default agent available")
 
-        proxy = self._agents[agent_name]
-        return await proxy.generate_str(message)
+        if target not in self._agents:
+            raise ValueError(f"No agent named '{target}'")
+
+        proxy = self._agents[target]
+        return await proxy.send(message)
+
+    async def apply_prompt(
+        self,
+        prompt_name: str,
+        arguments: Optional[dict[str, str]] = None,
+        agent_name: Optional[str] = None,
+    ) -> str:
+        """
+        Apply an MCP Server Prompt by name and return the assistant's response
+
+        Args:
+            prompt_name: The name of the prompt to apply
+            arguments: Optional dictionary of string arguments to pass to the prompt template
+            agent_name: The name of the agent to use (uses default if None)
+
+        Returns:
+            The assistant's response as a string
+        """
+        target = agent_name or self._default
+        if not target:
+            raise ValueError("No default agent available")
+
+        if target not in self._agents:
+            raise ValueError(f"No agent named '{target}'")
+
+        proxy = self._agents[target]
+        return await proxy.apply_prompt(prompt_name, arguments)
 
     async def prompt(self, agent_name: Optional[str] = None, default: str = "") -> str:
         """
@@ -177,9 +242,6 @@ class AgentApp:
                         from rich import print as rich_print
                         from rich.table import Table
                         from rich.console import Console
-                        from prompt_toolkit import PromptSession
-                        from prompt_toolkit.formatted_text import HTML
-                        from prompt_toolkit.completion import WordCompleter
 
                         console = Console()
 
@@ -325,8 +387,11 @@ class AgentApp:
                                         )
 
                                     # Ask user to select one
-                                    prompt_session = PromptSession()
-                                    selection = await prompt_session.prompt_async(
+                                    from mcp_agent.core.enhanced_prompt import (
+                                        get_selection_input,
+                                    )
+
+                                    selection = await get_selection_input(
                                         "Enter prompt number to select: ", default="1"
                                     )
 
@@ -381,12 +446,16 @@ class AgentApp:
                                 prompt_names = [
                                     str(i + 1) for i in range(len(all_prompts))
                                 ]
-                                completer = WordCompleter(prompt_names)
 
                                 # Ask user to select a prompt
-                                prompt_session = PromptSession(completer=completer)
-                                selection = await prompt_session.prompt_async(
-                                    "Enter prompt number to select (or press Enter to cancel): "
+                                from mcp_agent.core.enhanced_prompt import (
+                                    get_selection_input,
+                                )
+
+                                selection = await get_selection_input(
+                                    "Enter prompt number to select (or press Enter to cancel): ",
+                                    options=prompt_names,
+                                    allow_cancel=True,
                                 )
 
                                 # Make cancellation easier
@@ -437,37 +506,38 @@ class AgentApp:
 
                                 # Collect required arguments
                                 for arg_name in required_args:
-                                    # Show description if available
+                                    # Get description if available
                                     description = arg_descriptions.get(arg_name, "")
-                                    if description:
-                                        rich_print(
-                                            f"  [dim]{arg_name}: {description}[/dim]"
-                                        )
-                                    
+
                                     # Collect required argument value
-                                    arg_value = await PromptSession().prompt_async(
-                                        HTML(
-                                            f"Enter value for <ansibrightcyan>{arg_name}</ansibrightcyan> (required): "
-                                        )
+                                    from mcp_agent.core.enhanced_prompt import (
+                                        get_argument_input,
+                                    )
+
+                                    arg_value = await get_argument_input(
+                                        arg_name=arg_name,
+                                        description=description,
+                                        required=True,
                                     )
-                                    # Add to arg_values
-                                    arg_values[arg_name] = arg_value
+                                    # Add to arg_values if a value was provided
+                                    if arg_value is not None:
+                                        arg_values[arg_name] = arg_value
 
                                 # Only include non-empty values for optional arguments
                                 if optional_args:
                                     # Collect optional arguments
                                     for arg_name in optional_args:
-                                        # Show description if available
+                                        # Get description if available
                                         description = arg_descriptions.get(arg_name, "")
-                                        if description:
-                                            rich_print(
-                                                f"  [dim]{arg_name}: {description}[/dim]"
-                                            )
-
-                                        arg_value = await PromptSession().prompt_async(
-                                            HTML(
-                                                f"Enter value for <ansibrightcyan>{arg_name}</ansibrightcyan> (optional, press Enter to skip): "
-                                            )
+
+                                        from mcp_agent.core.enhanced_prompt import (
+                                            get_argument_input,
+                                        )
+
+                                        arg_value = await get_argument_input(
+                                            arg_name=arg_name,
+                                            description=description,
+                                            required=False,
                                         )
                                         # Only include non-empty values for optional arguments
                                         if arg_value:
@@ -501,7 +571,7 @@ class AgentApp:
                 if user_input == "":
                     continue
 
-            result = await self.send(agent, user_input)
+            result = await self.send(user_input, agent)
 
             # Check if current agent is a chain that should continue with final agent
             if agent_types.get(agent) == "Chain":
@@ -527,10 +597,21 @@ class AgentApp:
         return self._agents[name]
 
     async def __call__(
-        self, message: Optional[str] = "", agent_name: Optional[str] = None
+        self,
+        message: Optional[Union[str, PromptMessageMultipart]] = None,
+        agent_name: Optional[str] = None,
     ) -> str:
-        """Support: agent('message')"""
+        """
+        Support: agent('message') or agent(Prompt.user('message'))
+
+        Args:
+            message: Either a string message or a PromptMessageMultipart object
+            agent_name: The name of the agent to use (uses default if None)
+
+        Returns:
+            The agent's response as a string
+        """
         target = agent_name or self._default
         if not target:
             raise ValueError("No default agent available")
-        return await self.send(target, message)
+        return await self.send(message, target)

{fast_agent_mcp-0.1.7 → fast_agent_mcp-0.1.9}/src/mcp_agent/core/decorators.py

@@ -256,7 +256,8 @@ def parallel(
         self.agents[passthrough_name] = {
             "config": AgentConfig(
                 name=passthrough_name,
-                instruction=f"Passthrough fan-in for {name}",
+                model="passthrough",
+                instruction=f"This agent combines the results from the fan-out agents verbatim. {name}",
                 servers=[],
                 use_history=use_history,
             ),
@@ -452,4 +453,4 @@ def passthrough(
         name=name,
         use_history=use_history,
     )
-    return decorator
+    return decorator

{fast_agent_mcp-0.1.7 → fast_agent_mcp-0.1.9}/src/mcp_agent/core/enhanced_prompt.py

@@ -2,13 +2,13 @@
 Enhanced prompt functionality with advanced prompt_toolkit features.
 """
 
-from typing import List
+from typing import List, Optional
 from importlib.metadata import version
 from prompt_toolkit import PromptSession
 from prompt_toolkit.formatted_text import HTML
 from prompt_toolkit.history import InMemoryHistory
 from prompt_toolkit.key_binding import KeyBindings
-from prompt_toolkit.completion import Completer, Completion
+from prompt_toolkit.completion import Completer, Completion, WordCompleter
 from prompt_toolkit.lexers import PygmentsLexer
 from prompt_toolkit.filters import Condition
 from prompt_toolkit.styles import Style
@@ -330,6 +330,110 @@ async def get_enhanced_input(
         # Log and gracefully handle other exceptions
         print(f"\nInput error: {type(e).__name__}: {e}")
         return "STOP"
+    finally:
+        # Ensure the prompt session is properly cleaned up
+        # This is especially important on Windows to prevent resource leaks
+        if session.app.is_running:
+            session.app.exit()
+
+
+async def get_selection_input(
+    prompt_text: str,
+    options: List[str] = None,
+    default: str = None,
+    allow_cancel: bool = True,
+    complete_options: bool = True,
+) -> Optional[str]:
+    """
+    Display a selection prompt and return the user's selection.
+
+    Args:
+        prompt_text: Text to display as the prompt
+        options: List of valid options (for auto-completion)
+        default: Default value if user presses enter
+        allow_cancel: Whether to allow cancellation with empty input
+        complete_options: Whether to use the options for auto-completion
+
+    Returns:
+        Selected value, or None if cancelled
+    """
+    try:
+        # Initialize completer if options provided and completion requested
+        completer = WordCompleter(options) if options and complete_options else None
+
+        # Create prompt session
+        prompt_session = PromptSession(completer=completer)
+
+        try:
+            # Get user input
+            selection = await prompt_session.prompt_async(
+                prompt_text, default=default or ""
+            )
+
+            # Handle cancellation
+            if allow_cancel and not selection.strip():
+                return None
+
+            return selection
+        finally:
+            # Ensure prompt session cleanup
+            if prompt_session.app.is_running:
+                prompt_session.app.exit()
+    except (KeyboardInterrupt, EOFError):
+        return None
+    except Exception as e:
+        rich_print(f"\n[red]Error getting selection: {e}[/red]")
+        return None
+
+
+async def get_argument_input(
+    arg_name: str,
+    description: str = None,
+    required: bool = True,
+) -> Optional[str]:
+    """
+    Prompt for an argument value with formatting and help text.
+
+    Args:
+        arg_name: Name of the argument
+        description: Optional description of the argument
+        required: Whether this argument is required
+
+    Returns:
+        Input value, or None if cancelled/skipped
+    """
+    # Format the prompt differently based on whether it's required
+    required_text = "(required)" if required else "(optional, press Enter to skip)"
+
+    # Show description if available
+    if description:
+        rich_print(f"  [dim]{arg_name}: {description}[/dim]")
+
+    prompt_text = HTML(
+        f"Enter value for <ansibrightcyan>{arg_name}</ansibrightcyan> {required_text}: "
+    )
+
+    # Create prompt session
+    prompt_session = PromptSession()
+
+    try:
+        # Get user input
+        arg_value = await prompt_session.prompt_async(prompt_text)
+
+        # For optional arguments, empty input means skip
+        if not required and not arg_value:
+            return None
+
+        return arg_value
+    except (KeyboardInterrupt, EOFError):
+        return None
+    except Exception as e:
+        rich_print(f"\n[red]Error getting input: {e}[/red]")
+        return None
+    finally:
+        # Ensure prompt session cleanup
+        if prompt_session.app.is_running:
+            prompt_session.app.exit()
 
 
 async def handle_special_commands(command, agent_app=None):
@@ -408,24 +512,6 @@ async def handle_special_commands(command, agent_app=None):
             )
             return True
 
-    elif command == "SELECT_PROMPT" or (
-        isinstance(command, str) and command.startswith("SELECT_PROMPT:")
-    ):
-        # Handle prompt selection UI (previously named "list_prompts" action)
-        if agent_app:
-            # If it's a specific prompt, extract the name
-            prompt_name = None
-            if isinstance(command, str) and command.startswith("SELECT_PROMPT:"):
-                prompt_name = command.split(":", 1)[1].strip()
-
-            # Return a dictionary with a select_prompt action to be handled by the caller
-            return {"select_prompt": True, "prompt_name": prompt_name}
-        else:
-            rich_print(
-                "[yellow]Prompt selection is not available outside of an agent context[/yellow]"
-            )
-            return True
-
     elif isinstance(command, str) and command.startswith("SWITCH:"):
         agent_name = command.split(":", 1)[1]
         if agent_name in available_agents: