fast-agent-mcp 0.2.14__py3-none-any.whl → 0.2.17__py3-none-any.whl

mcp_agent/core/enhanced_prompt.py

@@ -14,6 +14,7 @@ from prompt_toolkit.key_binding import KeyBindings
 from prompt_toolkit.styles import Style
 from rich import print as rich_print
 
+from mcp_agent.core.agent_types import AgentType
 from mcp_agent.core.exceptions import PromptExitError
 
 # Get the application version
@@ -86,7 +87,7 @@ class AgentCompleter(Completer):
             for agent in self.agents:
                 if agent.lower().startswith(agent_name.lower()):
                     # Get agent type or default to "Agent"
-                    agent_type = self.agent_types.get(agent, "Agent")
+                    agent_type = self.agent_types.get(agent, AgentType.BASIC).value
                     yield Completion(
                         agent,
                         start_position=-len(agent_name),
@@ -149,7 +150,7 @@ async def get_enhanced_input(
     show_stop_hint: bool = False,
     multiline: bool = False,
     available_agent_names: List[str] = None,
-    agent_types: dict = None,
+    agent_types: dict[str, AgentType] = None,
     is_human_input: bool = False,
     toolbar_color: str = "ansiblue",
 ) -> str:
@@ -430,18 +431,18 @@ async def get_argument_input(
 async def handle_special_commands(command, agent_app=None):
     """
     Handle special input commands.
-    
+
     Args:
         command: The command to handle, can be string or dictionary
         agent_app: Optional agent app reference
-        
+
     Returns:
         True if command was handled, False if not, or a dict with action info
     """
     # Quick guard for empty or None commands
     if not command:
         return False
-        
+
     # If command is already a dictionary, it has been pre-processed
     # Just return it directly (like when /prompts converts to select_prompt dict)
     if isinstance(command, dict):

mcp_agent/core/fastagent.py

@@ -381,7 +381,7 @@ class FastAgent:
             handle_error(
                 e,
                 "Model Configuration Error",
-                "Common models: gpt-4o, o3-mini, sonnet, haiku. for o3, set reasoning effort with o3-mini.high",
+                "Common models: gpt-4.1, o3-mini, sonnet, haiku. for o3, set reasoning effort with o3-mini.high",
             )
         elif isinstance(e, CircularDependencyError):
             handle_error(

mcp_agent/core/interactive_prompt.py

@@ -20,6 +20,7 @@ from rich import print as rich_print
 from rich.console import Console
 from rich.table import Table
 
+from mcp_agent.core.agent_types import AgentType
 from mcp_agent.core.enhanced_prompt import (
     get_argument_input,
     get_enhanced_input,
@@ -36,14 +37,14 @@ class InteractivePrompt:
     This is extracted from the original AgentApp implementation to support DirectAgentApp.
     """
 
-    def __init__(self, agent_types: Optional[Dict[str, str]] = None) -> None:
+    def __init__(self, agent_types: Optional[Dict[str, AgentType]] = None) -> None:
         """
         Initialize the interactive prompt.
 
         Args:
             agent_types: Dictionary mapping agent names to their types for display
         """
-        self.agent_types = agent_types or {}
+        self.agent_types: Dict[str, AgentType] = agent_types or {}
 
     async def prompt_loop(
         self,
@@ -97,7 +98,7 @@ class InteractivePrompt:
 
                 # Handle special commands - pass "True" to enable agent switching
                 command_result = await handle_special_commands(user_input, True)
-                
+
                 # Check if we should switch agents
                 if isinstance(command_result, dict):
                     if "switch_agent" in command_result:
@@ -113,11 +114,13 @@ class InteractivePrompt:
                         # Use the list_prompts_func directly
                         await self._list_prompts(list_prompts_func, agent)
                         continue
-                    elif "select_prompt" in command_result and (list_prompts_func and apply_prompt_func):
+                    elif "select_prompt" in command_result and (
+                        list_prompts_func and apply_prompt_func
+                    ):
                         # Handle prompt selection, using both list_prompts and apply_prompt
                         prompt_name = command_result.get("prompt_name")
                         prompt_index = command_result.get("prompt_index")
-                        
+
                         # If a specific index was provided (from /prompt <number>)
                         if prompt_index is not None:
                             # First get a list of all prompts to look up the index
@@ -125,20 +128,29 @@ class InteractivePrompt:
                             if not all_prompts:
                                 rich_print("[yellow]No prompts available[/yellow]")
                                 continue
-                                
+
                             # Check if the index is valid
                             if 1 <= prompt_index <= len(all_prompts):
                                 # Get the prompt at the specified index (1-based to 0-based)
                                 selected_prompt = all_prompts[prompt_index - 1]
                                 # Use the already created namespaced_name to ensure consistency
-                                await self._select_prompt(list_prompts_func, apply_prompt_func, agent, selected_prompt["namespaced_name"])
+                                await self._select_prompt(
+                                    list_prompts_func,
+                                    apply_prompt_func,
+                                    agent,
+                                    selected_prompt["namespaced_name"],
+                                )
                             else:
-                                rich_print(f"[red]Invalid prompt number: {prompt_index}. Valid range is 1-{len(all_prompts)}[/red]")
+                                rich_print(
+                                    f"[red]Invalid prompt number: {prompt_index}. Valid range is 1-{len(all_prompts)}[/red]"
+                                )
                                 # Show the prompt list for convenience
                                 await self._list_prompts(list_prompts_func, agent)
                         else:
                             # Use the name-based selection
-                            await self._select_prompt(list_prompts_func, apply_prompt_func, agent, prompt_name)
+                            await self._select_prompt(
+                                list_prompts_func, apply_prompt_func, agent, prompt_name
+                            )
                         continue
 
                 # Skip further processing if command was handled
@@ -158,11 +170,11 @@ class InteractivePrompt:
     async def _get_all_prompts(self, list_prompts_func, agent_name):
         """
         Get a list of all available prompts.
-        
+
         Args:
             list_prompts_func: Function to get available prompts
             agent_name: Name of the agent
-            
+
         Returns:
             List of prompt info dictionaries, sorted by server and name
         """
@@ -171,7 +183,7 @@ class InteractivePrompt:
             # the agent_name parameter should never be used as a server name
             prompt_servers = await list_prompts_func(None)
             all_prompts = []
-            
+
             # Process the returned prompt servers
             if prompt_servers:
                 # First collect all prompts
@@ -179,44 +191,51 @@ class InteractivePrompt:
                     if prompts_info and hasattr(prompts_info, "prompts") and prompts_info.prompts:
                         for prompt in prompts_info.prompts:
                             # Use the SEP constant for proper namespacing
-                            all_prompts.append({
-                                "server": server_name,
-                                "name": prompt.name,
-                                "namespaced_name": f"{server_name}{SEP}{prompt.name}",
-                                "description": getattr(prompt, "description", "No description"),
-                                "arg_count": len(getattr(prompt, "arguments", [])),
-                                "arguments": getattr(prompt, "arguments", [])
-                            })
+                            all_prompts.append(
+                                {
+                                    "server": server_name,
+                                    "name": prompt.name,
+                                    "namespaced_name": f"{server_name}{SEP}{prompt.name}",
+                                    "description": getattr(prompt, "description", "No description"),
+                                    "arg_count": len(getattr(prompt, "arguments", [])),
+                                    "arguments": getattr(prompt, "arguments", []),
+                                }
+                            )
                     elif isinstance(prompts_info, list) and prompts_info:
                         for prompt in prompts_info:
                             if isinstance(prompt, dict) and "name" in prompt:
-                                all_prompts.append({
-                                    "server": server_name,
-                                    "name": prompt["name"],
-                                    "namespaced_name": f"{server_name}{SEP}{prompt['name']}",
-                                    "description": prompt.get("description", "No description"),
-                                    "arg_count": len(prompt.get("arguments", [])),
-                                    "arguments": prompt.get("arguments", [])
-                                })
+                                all_prompts.append(
+                                    {
+                                        "server": server_name,
+                                        "name": prompt["name"],
+                                        "namespaced_name": f"{server_name}{SEP}{prompt['name']}",
+                                        "description": prompt.get("description", "No description"),
+                                        "arg_count": len(prompt.get("arguments", [])),
+                                        "arguments": prompt.get("arguments", []),
+                                    }
+                                )
                             else:
-                                all_prompts.append({
-                                    "server": server_name,
-                                    "name": str(prompt),
-                                    "namespaced_name": f"{server_name}{SEP}{str(prompt)}",
-                                    "description": "No description",
-                                    "arg_count": 0,
-                                    "arguments": []
-                                })
-                
+                                all_prompts.append(
+                                    {
+                                        "server": server_name,
+                                        "name": str(prompt),
+                                        "namespaced_name": f"{server_name}{SEP}{str(prompt)}",
+                                        "description": "No description",
+                                        "arg_count": 0,
+                                        "arguments": [],
+                                    }
+                                )
+
                 # Sort prompts by server and name for consistent ordering
                 all_prompts.sort(key=lambda p: (p["server"], p["name"]))
-            
+
             return all_prompts
-        
+
         except Exception as e:
             import traceback
 
             from rich import print as rich_print
+
             rich_print(f"[red]Error getting prompts: {e}[/red]")
             rich_print(f"[dim]{traceback.format_exc()}[/dim]")
             return []
@@ -238,11 +257,11 @@ class InteractivePrompt:
         try:
             # Directly call the list_prompts function for this agent
             rich_print(f"\n[bold]Fetching prompts for agent [cyan]{agent_name}[/cyan]...[/bold]")
-            
+
             # Get all prompts using the helper function - pass None as server name
             # to get prompts from all available servers
             all_prompts = await self._get_all_prompts(list_prompts_func, None)
-            
+
             if all_prompts:
                 # Create a table for better display
                 table = Table(title="Available MCP Prompts")
@@ -251,7 +270,7 @@ class InteractivePrompt:
                 table.add_column("Prompt Name", style="bright_blue")
                 table.add_column("Description")
                 table.add_column("Args", justify="center")
-                
+
                 # Add prompts to table
                 for i, prompt in enumerate(all_prompts):
                     table.add_row(
@@ -259,11 +278,11 @@ class InteractivePrompt:
                         prompt["server"],
                         prompt["name"],
                         prompt["description"],
-                        str(prompt["arg_count"])
+                        str(prompt["arg_count"]),
                     )
-                
+
                 console.print(table)
-                
+
                 # Add usage instructions
                 rich_print("\n[bold]Usage:[/bold]")
                 rich_print("  • Use [cyan]/prompt <number>[/cyan] to select a prompt by number")
@@ -272,10 +291,13 @@ class InteractivePrompt:
                 rich_print("[yellow]No prompts available[/yellow]")
         except Exception as e:
             import traceback
+
             rich_print(f"[red]Error listing prompts: {e}[/red]")
             rich_print(f"[dim]{traceback.format_exc()}[/dim]")
 
-    async def _select_prompt(self, list_prompts_func, apply_prompt_func, agent_name, requested_name=None) -> None:
+    async def _select_prompt(
+        self, list_prompts_func, apply_prompt_func, agent_name, requested_name=None
+    ) -> None:
         """
         Select and apply a prompt.
 
@@ -293,7 +315,7 @@ class InteractivePrompt:
         try:
             # Get all available prompts directly from the list_prompts function
             rich_print(f"\n[bold]Fetching prompts for agent [cyan]{agent_name}[/cyan]...[/bold]")
-            # IMPORTANT: list_prompts_func gets MCP server prompts, not agent prompts 
+            # IMPORTANT: list_prompts_func gets MCP server prompts, not agent prompts
             # So we pass None to get prompts from all servers, not using agent_name as server name
             prompt_servers = await list_prompts_func(None)
 
@@ -514,9 +536,7 @@ class InteractivePrompt:
 
             # Apply the prompt
             namespaced_name = selected_prompt["namespaced_name"]
-            rich_print(
-                f"\n[bold]Applying prompt [cyan]{namespaced_name}[/cyan]...[/bold]"
-            )
+            rich_print(f"\n[bold]Applying prompt [cyan]{namespaced_name}[/cyan]...[/bold]")
 
             # Call apply_prompt function with the prompt name and arguments
             await apply_prompt_func(namespaced_name, arg_values, agent_name)

mcp_agent/core/request_params.py

@@ -2,7 +2,7 @@
 Request parameters definitions for LLM interactions.
 """
 
-from typing import List
+from typing import Any, List
 
 from mcp import SamplingMessage
 from mcp.types import CreateMessageRequestParams
@@ -44,3 +44,7 @@ class RequestParams(CreateMessageRequestParams):
     Whether to allow multiple tool calls per iteration.
     Also known as multi-step tool use.
     """
+    response_format: Any | None = None
+    """
+    Override response format for structured calls. Prefer sending pydantic model - only use in exceptional circumstances
+    """

mcp_agent/executor/workflow_signal.py

@@ -7,8 +7,6 @@ from pydantic import BaseModel, ConfigDict
 
 SignalValueT = TypeVar("SignalValueT")
 
-# TODO: saqadri - handle signals properly that works with other execution backends like Temporal as well
-
 
 class Signal(BaseModel, Generic[SignalValueT]):
     """Represents a signal that can be sent to a workflow."""

mcp_agent/llm/augmented_llm.py

@@ -18,6 +18,8 @@ from mcp.types import (
     PromptMessage,
     TextContent,
 )
+from openai import NotGiven
+from openai.lib._parsing import type_to_response_format_param as _type_to_response_format
 from pydantic_core import from_json
 from rich.text import Text
 
@@ -58,6 +60,20 @@ HUMAN_INPUT_TOOL_NAME = "__human_input__"
 
 
 class AugmentedLLM(ContextDependent, AugmentedLLMProtocol, Generic[MessageParamT, MessageT]):
+    # Common parameter names used across providers
+    PARAM_MESSAGES = "messages"
+    PARAM_MODEL = "model"
+    PARAM_MAX_TOKENS = "maxTokens"
+    PARAM_SYSTEM_PROMPT = "systemPrompt"
+    PARAM_STOP_SEQUENCES = "stopSequences"
+    PARAM_PARALLEL_TOOL_CALLS = "parallel_tool_calls"
+    PARAM_METADATA = "metadata"
+    PARAM_USE_HISTORY = "use_history"
+    PARAM_MAX_ITERATIONS = "max_iterations"
+
+    # Base set of fields that should always be excluded
+    BASE_EXCLUDE_FIELDS = {PARAM_METADATA}
+
     """
     The basic building block of agentic systems is an LLM enhanced with augmentations
     such as retrieval, tools, and memory provided from a collection of MCP servers.
@@ -141,26 +157,6 @@ class AugmentedLLM(ContextDependent, AugmentedLLMProtocol, Generic[MessageParamT
             use_history=True,
         )
 
-    async def structured(
-        self,
-        prompt: List[PromptMessageMultipart],
-        model: Type[ModelT],
-        request_params: RequestParams | None = None,
-    ) -> Tuple[ModelT | None, PromptMessageMultipart]:
-        """Apply the prompt and return the result as a Pydantic model, or None if coercion fails"""
-        try:
-            result: PromptMessageMultipart = await self.generate(prompt, request_params)
-            final_generation = get_text(result.content[-1]) or ""
-            await self.show_assistant_message(final_generation)
-            json_data = from_json(final_generation, allow_partial=True)
-            validated_model = model.model_validate(json_data)
-
-            return cast("ModelT", validated_model), Prompt.assistant(json_data)
-        except Exception as e:
-            logger = get_logger(__name__)
-            logger.error(f"Failed to parse structured response: {str(e)}")
-            return None, Prompt.assistant(f"Failed to parse structured response: {str(e)}")
-
     async def generate(
         self,
         multipart_messages: List[PromptMessageMultipart],
@@ -169,6 +165,12 @@ class AugmentedLLM(ContextDependent, AugmentedLLMProtocol, Generic[MessageParamT
         """
         Create a completion with the LLM using the provided messages.
         """
+        # note - check changes here are mirrored in structured(). i've thought hard about
+        # a strategy to reduce duplication etc, but aiming for simple but imperfect for the moment
+
+        # We never expect this for structured() calls - this is for interactive use - developers
+        # can do this programatically
+        # TODO -- create a "fast-agent" control role rather than magic strings
         if multipart_messages[-1].first_text().startswith("***SAVE_HISTORY"):
             parts: list[str] = multipart_messages[-1].first_text().split(" ", 1)
             filename: str = (
@@ -180,26 +182,174 @@ class AugmentedLLM(ContextDependent, AugmentedLLMProtocol, Generic[MessageParamT
             )
             return Prompt.assistant(f"History saved to {filename}")
 
-        self._message_history.extend(multipart_messages)
-
-        if multipart_messages[-1].role == "user":
-            self.show_user_message(
-                render_multipart_message(multipart_messages[-1]),
-                model=self.default_request_params.model,
-                chat_turn=self.chat_turn(),
-            )
+        self._precall(multipart_messages)
 
         assistant_response: PromptMessageMultipart = await self._apply_prompt_provider_specific(
             multipart_messages, request_params
         )
 
+        # add generic error and termination reason handling/rollback
         self._message_history.append(assistant_response)
         return assistant_response
 
+    @abstractmethod
+    async def _apply_prompt_provider_specific(
+        self,
+        multipart_messages: List["PromptMessageMultipart"],
+        request_params: RequestParams | None = None,
+        is_template: bool = False,
+    ) -> PromptMessageMultipart:
+        """
+        Provider-specific implementation of apply_prompt_template.
+        This default implementation handles basic text content for any LLM type.
+        Provider-specific subclasses should override this method to handle
+        multimodal content appropriately.
+
+        Args:
+            multipart_messages: List of PromptMessageMultipart objects parsed from the prompt template
+
+        Returns:
+            String representation of the assistant's response if generated,
+            or the last assistant message in the prompt
+        """
+
+    async def structured(
+        self,
+        multipart_messages: List[PromptMessageMultipart],
+        model: Type[ModelT],
+        request_params: RequestParams | None = None,
+    ) -> Tuple[ModelT | None, PromptMessageMultipart]:
+        """Return a structured response from the LLM using the provided messages."""
+        self._precall(multipart_messages)
+        result, assistant_response = await self._apply_prompt_provider_specific_structured(
+            multipart_messages, model, request_params
+        )
+
+        self._message_history.append(assistant_response)
+        return result, assistant_response
+
+    @staticmethod
+    def model_to_response_format(
+        model: Type[Any],
+    ) -> Any:
+        """
+        Convert a pydantic model to the appropriate response format schema.
+        This allows for reuse in multiple provider implementations.
+
+        Args:
+            model: The pydantic model class to convert to a schema
+
+        Returns:
+            Provider-agnostic schema representation or NotGiven if conversion fails
+        """
+        return _type_to_response_format(model)
+
+    @staticmethod
+    def model_to_schema_str(
+        model: Type[Any],
+    ) -> str:
+        """
+        Convert a pydantic model to a schema string representation.
+        This provides a simpler interface for provider implementations
+        that need a string representation.
+
+        Args:
+            model: The pydantic model class to convert to a schema
+
+        Returns:
+            Schema as a string, or empty string if conversion fails
+        """
+        import json
+
+        try:
+            schema = model.model_json_schema()
+            return json.dumps(schema)
+        except Exception:
+            return ""
+
+    async def _apply_prompt_provider_specific_structured(
+        self,
+        multipart_messages: List[PromptMessageMultipart],
+        model: Type[ModelT],
+        request_params: RequestParams | None = None,
+    ) -> Tuple[ModelT | None, PromptMessageMultipart]:
+        """Base class attempts to parse JSON - subclasses can use provider specific functionality"""
+
+        request_params = self.get_request_params(request_params)
+
+        if not request_params.response_format:
+            schema = self.model_to_response_format(model)
+            if schema is not NotGiven:
+                request_params.response_format = schema
+
+        result: PromptMessageMultipart = await self._apply_prompt_provider_specific(
+            multipart_messages, request_params
+        )
+        return self._structured_from_multipart(result, model)
+
+    def _structured_from_multipart(
+        self, message: PromptMessageMultipart, model: Type[ModelT]
+    ) -> Tuple[ModelT | None, PromptMessageMultipart]:
+        """Parse the content of a PromptMessage and return the structured model and message itself"""
+        try:
+            text = get_text(message.content[-1]) or ""
+            json_data = from_json(text, allow_partial=True)
+            validated_model = model.model_validate(json_data)
+            return cast("ModelT", validated_model), message
+        except ValueError as e:
+            logger = get_logger(__name__)
+            logger.warning(f"Failed to parse structured response: {str(e)}")
+            return None, message
+
+    def _precall(self, multipart_messages: List[PromptMessageMultipart]) -> None:
+        """Pre-call hook to modify the message before sending it to the provider."""
+        self._message_history.extend(multipart_messages)
+        if multipart_messages[-1].role == "user":
+            self.show_user_message(
+                render_multipart_message(multipart_messages[-1]),
+                model=self.default_request_params.model,
+                chat_turn=self.chat_turn(),
+            )
+
     def chat_turn(self) -> int:
         """Return the current chat turn number"""
         return 1 + sum(1 for message in self._message_history if message.role == "assistant")
 
+    def prepare_provider_arguments(
+        self,
+        base_args: dict,
+        request_params: RequestParams,
+        exclude_fields: set | None = None,
+    ) -> dict:
+        """
+        Prepare arguments for provider API calls by merging request parameters.
+
+        Args:
+            base_args: Base arguments dictionary with provider-specific required parameters
+            params: The RequestParams object containing all parameters
+            exclude_fields: Set of field names to exclude from params. If None, uses BASE_EXCLUDE_FIELDS.
+
+        Returns:
+            Complete arguments dictionary with all applicable parameters
+        """
+        # Start with base arguments
+        arguments = base_args.copy()
+
+        # Use provided exclude_fields or fall back to base exclusions
+        exclude_fields = exclude_fields or self.BASE_EXCLUDE_FIELDS.copy()
+
+        # Add all fields from params that aren't explicitly excluded
+        params_dict = request_params.model_dump(exclude=exclude_fields)
+        for key, value in params_dict.items():
+            if value is not None and key not in arguments:
+                arguments[key] = value
+
+        # Finally, add any metadata fields as a last layer of overrides
+        if request_params.metadata:
+            arguments.update(request_params.metadata)
+
+        return arguments
+
     def _merge_request_params(
         self, default_params: RequestParams, provided_params: RequestParams
     ) -> RequestParams:
@@ -214,7 +364,6 @@ class AugmentedLLM(ContextDependent, AugmentedLLMProtocol, Generic[MessageParamT
     def get_request_params(
         self,
         request_params: RequestParams | None = None,
-        default: RequestParams | None = None,
     ) -> RequestParams:
         """
         Get request parameters with merged-in defaults and overrides.
@@ -223,17 +372,12 @@ class AugmentedLLM(ContextDependent, AugmentedLLMProtocol, Generic[MessageParamT
             default: The default request parameters to use as the base.
                 If unspecified, self.default_request_params will be used.
         """
-        # Start with the defaults
-        default_request_params = default or self.default_request_params
-
-        if not default_request_params:
-            default_request_params = self._initialize_default_params({})
 
         # If user provides overrides, merge them with defaults
         if request_params:
-            return self._merge_request_params(default_request_params, request_params)
+            return self._merge_request_params(self.default_request_params, request_params)
 
-        return default_request_params
+        return self.default_request_params.model_copy()
 
     @classmethod
     def convert_message_to_message_param(
@@ -435,7 +579,9 @@ class AugmentedLLM(ContextDependent, AugmentedLLMProtocol, Generic[MessageParamT
         multipart_messages = PromptMessageMultipart.parse_get_prompt_result(prompt_result)
 
         # Delegate to the provider-specific implementation
-        result = await self._apply_prompt_provider_specific(multipart_messages, None)
+        result = await self._apply_prompt_provider_specific(
+            multipart_messages, None, is_template=True
+        )
         return result.first_text()
 
     async def _save_history(self, filename: str) -> None:
@@ -450,26 +596,6 @@ class AugmentedLLM(ContextDependent, AugmentedLLMProtocol, Generic[MessageParamT
         # Save messages using the unified save function that auto-detects format
         save_messages_to_file(self._message_history, filename)
 
-    @abstractmethod
-    async def _apply_prompt_provider_specific(
-        self,
-        multipart_messages: List["PromptMessageMultipart"],
-        request_params: RequestParams | None = None,
-    ) -> PromptMessageMultipart:
-        """
-        Provider-specific implementation of apply_prompt_template.
-        This default implementation handles basic text content for any LLM type.
-        Provider-specific subclasses should override this method to handle
-        multimodal content appropriately.
-
-        Args:
-            multipart_messages: List of PromptMessageMultipart objects parsed from the prompt template
-
-        Returns:
-            String representation of the assistant's response if generated,
-            or the last assistant message in the prompt
-        """
-
     @property
     def message_history(self) -> List[PromptMessageMultipart]:
         """

mcp_agent/llm/augmented_llm_passthrough.py

@@ -143,7 +143,6 @@ class PassthroughLLM(AugmentedLLM):
     ) -> PromptMessageMultipart:
         last_message = multipart_messages[-1]
 
-        # TODO -- improve when we support Audio/Multimodal gen
         if self.is_tool_call(last_message):
             result = Prompt.assistant(await self.generate_str(last_message.first_text()))
             await self.show_assistant_message(result.first_text())
@@ -158,6 +157,7 @@ class PassthroughLLM(AugmentedLLM):
             await self.show_assistant_message(self._fixed_response)
             return Prompt.assistant(self._fixed_response)
         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)
             await self.show_assistant_message(concatenated)
             return Prompt.assistant(concatenated)