fast-agent-mcp 0.0.11__py3-none-any.whl → 0.0.12__py3-none-any.whl

{fast_agent_mcp-0.0.11.dist-info → fast_agent_mcp-0.0.12.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fast-agent-mcp
-Version: 0.0.11
+Version: 0.0.12
 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
@@ -217,6 +217,7 @@ Requires-Dist: numpy>=2.2.1
 Requires-Dist: openai>=1.63.2
 Requires-Dist: opentelemetry-distro>=0.50b0
 Requires-Dist: opentelemetry-exporter-otlp-proto-http>=1.29.0
+Requires-Dist: prompt-toolkit>=3.0.50
 Requires-Dist: pydantic-settings>=2.7.0
 Requires-Dist: pydantic>=2.10.4
 Requires-Dist: pyyaml>=6.0.2
@@ -271,6 +272,7 @@ Other bootstrap examples include a Researcher (with Evaluator-Optimizer workflow
 ### llmindset.co.uk fork:
 
 - "FastAgent" style prototyping, with per-agent models
+- Api keys through Environment Variables
 - Warm-up / Post-Workflow Agent Interactions
 - Quick Setup
 - Interactive Prompt Mode

{fast_agent_mcp-0.0.11.dist-info → fast_agent_mcp-0.0.12.dist-info}/RECORD

@@ -11,14 +11,15 @@ mcp_agent/agents/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,
 mcp_agent/agents/agent.py,sha256=utMR_QWKD1_MqWE_fYY-xqUMKtGlekW0laJfduU6Ckw,9831
 mcp_agent/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 mcp_agent/cli/__main__.py,sha256=bhxe66GYqy0q78OQhi7dkuubY1Tn0bQL6hU5Nn47E34,73
-mcp_agent/cli/main.py,sha256=wyOvUg0BihD1NpoiFcIaOruevgaHxs1-Xy_bnwb1Ik4,2449
+mcp_agent/cli/main.py,sha256=h_TqBlpIMGhsJr6pp_oxUl00x3F9d1R-JQVwJ9uAreA,2449
 mcp_agent/cli/terminal.py,sha256=5fqrKlJvIpKEuvpvZ653OueQSYFFktBEbosjr2ucMUc,1026
-mcp_agent/cli/commands/bootstrap.py,sha256=lVWMAt3Uzd6HHvEJ3X28bbKdX6o1_F-Vs6682fdol20,10798
+mcp_agent/cli/commands/bootstrap.py,sha256=Q55I2gL-K3Ja8c6MmbLZMVQQ_MaOTxnEC5se09XTI2s,10742
 mcp_agent/cli/commands/config.py,sha256=32YTS5jmsYAs9QzAhjkG70_daAHqOemf4XbZBBSMz6g,204
 mcp_agent/cli/commands/setup.py,sha256=dI_01B5nye707Rcd15gvZZCYlZGSiKajlnuLf6hJf2A,6197
 mcp_agent/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mcp_agent/core/enhanced_prompt.py,sha256=U4hbAbm5WFUwTiwmBlNR7nadbMD9oHYgKuNNQVrGdvc,11047
 mcp_agent/core/exceptions.py,sha256=xDdhYh83ni3t0NiXQTEL0_Yyx0qQxBPQL1gSwRToeaw,1469
-mcp_agent/core/fastagent.py,sha256=obVbZ8AwqxpeHg-LQvlwukswDxvk3sMPzkvPYk1QJSk,47127
+mcp_agent/core/fastagent.py,sha256=Wn5uHR6DIzMXu4S93Ll8oFD7VJUcSBH4wMm4c0aofpw,48858
 mcp_agent/core/server_validation.py,sha256=_59cn16nNT4HGPwg19HgxMtHK4MsdWYDUw_CuL-5xek,1696
 mcp_agent/eval/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 mcp_agent/executor/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -50,12 +51,18 @@ mcp_agent/mcp/stdio.py,sha256=tW075R5rQ-UlflXWFKIFDgCbWbuhKqxhiYolWvyEkFs,3985
 mcp_agent/resources/examples/data-analysis/analysis.py,sha256=Sp-umPPfwVjG3yNrHdQA6blGtG6jc5of1e_0oS4njYc,1379
 mcp_agent/resources/examples/data-analysis/fastagent.config.yaml,sha256=eTKGbjnTHhDTeNRPQvG_fr9OQpEZ5Y9v7X2NyCj0V70,530
 mcp_agent/resources/examples/data-analysis/mount-point/WA_Fn-UseC_-HR-Employee-Attrition.csv,sha256=pcMeOL1_r8m8MziE6xgbBrQbjl5Ijo98yycZn7O-dlk,227977
-mcp_agent/resources/examples/internal/job.py,sha256=uqIqc1i5PfWynobwNaWWcQ6FP_BRifINd4ncmPvzwm0,4093
-mcp_agent/resources/examples/mcp_researcher/researcher-eval.py,sha256=NI1vujVuLeTrcF8dM_ipZZ3Tg-1AL35CaltmuzxWrU4,1807
+mcp_agent/resources/examples/internal/agent.py,sha256=f-jTgYabV3nWCQm0ZP9NtSEWjx3nQbRngzArRufcELg,384
+mcp_agent/resources/examples/internal/job.py,sha256=WEKIAANMEAuKr13__rYf3PqJeTAsNB_kqYqbqVYQlUM,4093
+mcp_agent/resources/examples/mcp_researcher/researcher-eval.py,sha256=kNPjIU-JwE0oIBQKwhv6lZsUF_SPtYVkiEEbY1ZVZxk,1807
 mcp_agent/resources/examples/mcp_researcher/researcher.py,sha256=jPRafm7jbpHKkX_dQiYGG3Sw-e1Dm86q-JZT-WZDhM0,1425
+mcp_agent/resources/examples/researcher/fastagent.config.yaml,sha256=2_VXZneckR6zk6RWzzL-smV_oWmgg4uSkLWqZv8jF0I,1995
+mcp_agent/resources/examples/researcher/researcher-eval.py,sha256=kNPjIU-JwE0oIBQKwhv6lZsUF_SPtYVkiEEbY1ZVZxk,1807
+mcp_agent/resources/examples/researcher/researcher.py,sha256=jPRafm7jbpHKkX_dQiYGG3Sw-e1Dm86q-JZT-WZDhM0,1425
+mcp_agent/resources/examples/workflows/agent.py,sha256=f-jTgYabV3nWCQm0ZP9NtSEWjx3nQbRngzArRufcELg,384
 mcp_agent/resources/examples/workflows/agent_build.py,sha256=vdjS02rZR88RU53WYzXxPscfFNEFFe_niHYE_i49I8Q,2396
 mcp_agent/resources/examples/workflows/chaining.py,sha256=QD_r_PKIoDedWqOTzg7IBnTY8OVoDSMot5WnArJubnc,751
-mcp_agent/resources/examples/workflows/evaluator.py,sha256=ByILFY7PsA8UXtmNa4YtLIGSsnVfZVjKlHGH9G0ie2I,3069
+mcp_agent/resources/examples/workflows/evaluator.py,sha256=kC8uBcCMoeDROip4B_X6jLr-1QXXvcUB0fZ6elun7k4,3147
+mcp_agent/resources/examples/workflows/fastagent.py,sha256=lkO3waYLt_zQtAVqGjirmIsG73jpHA5ad1WSm4BXv2I,532
 mcp_agent/resources/examples/workflows/human_input.py,sha256=c8cBdLEPbaMXddFwsfN3Z7RFs5PZXsdrjANfvq1VTPM,605
 mcp_agent/resources/examples/workflows/orchestrator.py,sha256=kHUDDALqjA8TRjkbsDP2MwspEj1a5DdSUOPAiI17izQ,2545
 mcp_agent/resources/examples/workflows/parallel.py,sha256=cNYcIcsdo0-KK-S7KEPCc11aWELeVlQJdJ2LIC9xgDs,3090
@@ -68,7 +75,7 @@ mcp_agent/workflows/embedding/embedding_base.py,sha256=-c20ggQ8s7XhMxRX-WEhOgHE7
 mcp_agent/workflows/embedding/embedding_cohere.py,sha256=OKTJvKD_uEafd4c2uhR5tBjprea1nyvlJOO-3FDqOnk,1540
 mcp_agent/workflows/embedding/embedding_openai.py,sha256=dntjJ5P-FSMGYuyPZC8MuCU_ehwjXw9wDfzZZuSQN1E,1480
 mcp_agent/workflows/evaluator_optimizer/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mcp_agent/workflows/evaluator_optimizer/evaluator_optimizer.py,sha256=ddAfHu8jFGwdVGbHwm7CZQnmtMeDnIl1gIB_lfkXx_E,13628
+mcp_agent/workflows/evaluator_optimizer/evaluator_optimizer.py,sha256=r0ATtuc8JouBZz6iPc_dQ6g5oUZc7JXfbI9adKd2Wg8,13572
 mcp_agent/workflows/intent_classifier/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 mcp_agent/workflows/intent_classifier/intent_classifier_base.py,sha256=zTbOmq6EY_abOlme4zl28HM4RWNNS6bbHl3tF7SshJ0,4004
 mcp_agent/workflows/intent_classifier/intent_classifier_embedding.py,sha256=_bWZGukc_q9LdA_Q18UoAMSzhN8tt4K_bRHNUhy7Crw,3997
@@ -78,9 +85,9 @@ mcp_agent/workflows/intent_classifier/intent_classifier_llm.py,sha256=WSLUv2Casb
 mcp_agent/workflows/intent_classifier/intent_classifier_llm_anthropic.py,sha256=Hp4454IniWFxV4ml50Ml8ip9rS1La5FBn5pd7vm1FHA,1964
 mcp_agent/workflows/intent_classifier/intent_classifier_llm_openai.py,sha256=zj76WlTYnSCYjBQ_IDi5vFBQGmNwYaoUq1rT730sY98,1940
 mcp_agent/workflows/llm/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mcp_agent/workflows/llm/augmented_llm.py,sha256=BQ7xhYVzloE7_VeuJvvjABYs7sNxJjfS14QdvHUUvjY,23209
-mcp_agent/workflows/llm/augmented_llm_anthropic.py,sha256=_Td5UTNfnaFtqN3XNV5bX1w7ituRjzoWMOyaobz9vO4,21127
-mcp_agent/workflows/llm/augmented_llm_openai.py,sha256=RqsbX0Fc5By1AvQ2N85hxzz0d84mVwuPggslxwqSJVM,24190
+mcp_agent/workflows/llm/augmented_llm.py,sha256=AjYxTn2XdBDHnibmjlCKwaVfQQlQRES9sRBMIU6NaPQ,23258
+mcp_agent/workflows/llm/augmented_llm_anthropic.py,sha256=yrOv1V6rOfm2TTDR58fnf8YU8hBnTIpOZhB2sUgZw6o,21246
+mcp_agent/workflows/llm/augmented_llm_openai.py,sha256=5PwTh0QJSQ29EtK0UuiltgX6snRSBoau75C35S4xQcQ,24477
 mcp_agent/workflows/llm/llm_selector.py,sha256=G7pIybuBDwtmyxUDov_QrNYH2FoI0qFRu2JfoxWUF5Y,11045
 mcp_agent/workflows/llm/model_factory.py,sha256=5JrMXZ5jbE8isiteF2A912gGuCyomGpjtC_BCVSAM9s,6806
 mcp_agent/workflows/orchestrator/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -101,8 +108,8 @@ mcp_agent/workflows/swarm/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJW
 mcp_agent/workflows/swarm/swarm.py,sha256=-lAIeSWDqbGHGRPTvjiP9nIKWvxxy9DAojl9yQzO1Pw,11050
 mcp_agent/workflows/swarm/swarm_anthropic.py,sha256=pW8zFx5baUWGd5Vw3nIDF2oVOOGNorij4qvGJKdYPcs,1624
 mcp_agent/workflows/swarm/swarm_openai.py,sha256=wfteywvAGkT5bLmIxX_StHJq8144whYmCRnJASAjOes,1596
-fast_agent_mcp-0.0.11.dist-info/METADATA,sha256=p3Q0Gcx-dzK-vJA6F2s2iaw6NNm2RoWrB5VakfLIp00,16504
-fast_agent_mcp-0.0.11.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-fast_agent_mcp-0.0.11.dist-info/entry_points.txt,sha256=2IXtSmDK9XjWN__RWuRIJTgWyW17wJnJ_h-pb0pZAxo,174
-fast_agent_mcp-0.0.11.dist-info/licenses/LICENSE,sha256=cN3FxDURL9XuzE5mhK9L2paZo82LTfjwCYVT7e3j0e4,10939
-fast_agent_mcp-0.0.11.dist-info/RECORD,,
+fast_agent_mcp-0.0.12.dist-info/METADATA,sha256=mgH0wJrtVRReqKTn2a-ANc_reC_quUXY-texT2zGdVI,16583
+fast_agent_mcp-0.0.12.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+fast_agent_mcp-0.0.12.dist-info/entry_points.txt,sha256=2IXtSmDK9XjWN__RWuRIJTgWyW17wJnJ_h-pb0pZAxo,174
+fast_agent_mcp-0.0.12.dist-info/licenses/LICENSE,sha256=cN3FxDURL9XuzE5mhK9L2paZo82LTfjwCYVT7e3j0e4,10939
+fast_agent_mcp-0.0.12.dist-info/RECORD,,

mcp_agent/cli/commands/bootstrap.py

@@ -33,11 +33,7 @@ EXAMPLE_TYPES = {
         "description": "Research agent example with additional evaluation/optimization\n"
         "example. Uses Brave Search and Docker MCP Servers.\n"
         "Creates examples in a 'researcher' subdirectory.",
-        "files": [
-            "researcher.py",
-            "researcher-eval.py",
-            "mcp_agent.secrets.yaml.example",
-        ],
+        "files": ["researcher.py", "researcher-eval.py", "fastagent.config.yaml"],
         "create_subdir": True,
     },
     "data-analysis": {

mcp_agent/cli/main.py

@@ -40,11 +40,11 @@ def show_welcome():
 
     console.print("\n[bold]Getting Started:[/bold]")
     console.print("1. Set up a new project:")
-    console.print("   mcp-agent setup")
+    console.print("   fastagent setup")
     console.print("\n2. Try an example:")
-    console.print("   mcp-agent bootstrap create decorator")
+    console.print("   fastagent bootstrap create decorator")
     console.print("\nUse --help with any command for more information")
-    console.print("Example: mcp-agent bootstrap --help")
+    console.print("Example: fastagent bootstrap --help")
 
 
 @app.callback(invoke_without_command=True)
@@ -56,7 +56,7 @@ def main(
         True, "--color/--no-color", help="Enable/disable color output"
     ),
 ):
-    """MCP Agent CLI - Build effective agents using Model Context Protocol (MCP).
+    """FastAgent CLI - Build effective agents using Model Context Protocol (MCP).
 
     Use --help with any command for detailed usage information.
     """

mcp_agent/core/enhanced_prompt.py

@@ -0,0 +1,315 @@
+"""
+Enhanced prompt functionality with advanced prompt_toolkit features.
+"""
+
+from typing import List
+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.lexers import PygmentsLexer
+from prompt_toolkit.filters import Condition
+from pygments.lexers.python import PythonLexer
+from rich import print as rich_print
+
+# Map of agent names to their history
+agent_histories = {}
+
+# Store available agents for auto-completion
+available_agents = set()
+
+# Keep track of multi-line mode state
+in_multiline_mode = False
+
+# Track which agents have already shown welcome messages
+agent_messages_shown = set()
+
+
+class AgentCompleter(Completer):
+    """Provide completion for agent names and common commands."""
+
+    def __init__(self, agents: List[str], commands: List[str] = None, agent_types: dict = None):
+        self.agents = agents
+        self.commands = commands or ["help", "clear", "STOP"]
+        self.agent_types = agent_types or {}
+
+    def get_completions(self, document, complete_event):
+        """Synchronous completions method - this is what prompt_toolkit expects by default"""
+        text = document.text_before_cursor.lower()
+
+        # Complete commands
+        if text.startswith("/"):
+            cmd = text[1:]
+            for command in self.commands:
+                if command.lower().startswith(cmd):
+                    yield Completion(
+                        command,
+                        start_position=-len(cmd),
+                        display=command,
+                        display_meta="Command",
+                    )
+
+        # Complete agent names for agent-related commands
+        elif text.startswith("@"):
+            agent_name = text[1:]
+            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")
+                    yield Completion(
+                        agent,
+                        start_position=-len(agent_name),
+                        display=agent,
+                        display_meta=agent_type,
+                    )
+
+
+def create_keybindings(on_toggle_multiline=None, app=None):
+    """Create custom key bindings."""
+    kb = KeyBindings()
+
+    @kb.add("c-m", filter=Condition(lambda: not in_multiline_mode))
+    def _(event):
+        """Enter: accept input when not in multiline mode."""
+        event.current_buffer.validate_and_handle()
+
+    @kb.add("c-m", filter=Condition(lambda: in_multiline_mode))
+    def _(event):
+        """Enter: insert newline when in multiline mode."""
+        event.current_buffer.insert_text("\n")
+
+    @kb.add("escape", "enter")
+    def _(event):
+        """Alt+Enter: always submit even in multiline mode."""
+        event.current_buffer.validate_and_handle()
+
+    @kb.add("c-t")
+    def _(event):
+        """Ctrl+T: Toggle multiline mode."""
+        global in_multiline_mode
+        in_multiline_mode = not in_multiline_mode
+
+        # Force redraw the app to update toolbar
+        if event.app:
+            event.app.invalidate()
+        elif app:
+            app.invalidate()
+
+        # Call the toggle callback if provided
+        if on_toggle_multiline:
+            on_toggle_multiline(in_multiline_mode)
+
+        # Instead of printing, we'll just update the toolbar
+        # The toolbar will show the current mode
+
+    @kb.add("c-l")
+    def _(event):
+        """Ctrl+L: Clear input."""
+        event.current_buffer.text = ""
+
+    return kb
+
+
+async def get_enhanced_input(
+    agent_name: str,
+    default: str = "",
+    show_default: bool = False,
+    show_stop_hint: bool = False,
+    multiline: bool = False,
+    available_agent_names: List[str] = None,
+    syntax: str = None,
+    agent_types: dict = None,
+) -> str:
+    """
+    Enhanced input with advanced prompt_toolkit features.
+
+    Args:
+        agent_name: Name of the agent (used for prompt and history)
+        default: Default value if user presses enter
+        show_default: Whether to show the default value in the prompt
+        show_stop_hint: Whether to show the STOP hint
+        multiline: Start in multiline mode
+        available_agent_names: List of agent names for auto-completion
+        syntax: Syntax highlighting (e.g., 'python', 'sql')
+        agent_types: Dictionary mapping agent names to their types for display
+
+    Returns:
+        User input string
+    """
+    global in_multiline_mode, available_agents
+
+    # Update global state
+    in_multiline_mode = multiline
+    if available_agent_names:
+        available_agents = set(available_agent_names)
+
+    # Get or create history object for this agent
+    if agent_name not in agent_histories:
+        agent_histories[agent_name] = InMemoryHistory()
+
+    # Define callback for multiline toggle
+    def on_multiline_toggle(enabled):
+        nonlocal session
+        if hasattr(session, "app") and session.app:
+            session.app.invalidate()
+
+    # Define toolbar function that will update dynamically
+    def get_toolbar():
+        if in_multiline_mode:
+            mode_style = "ansired"  # More noticeable for multiline mode
+            mode_text = "MULTILINE"
+            toggle_text = "Normal Editing"
+        else:
+            mode_style = "ansigreen"
+            mode_text = "NORMAL"
+            toggle_text = "Multiline Editing"
+
+        shortcuts = [
+            ("Ctrl+T", toggle_text),
+            ("Alt+Enter", "Submit" if in_multiline_mode else ""),
+            ("Ctrl+L", "Clear"),
+            ("↑/↓", "History"),
+        ]
+        # Only show relevant shortcuts based on mode
+        shortcuts = [(k, v) for k, v in shortcuts if v]
+
+        shortcut_text = " | ".join(f"{key}:{action}" for key, action in shortcuts)
+        return HTML(
+            f" <b>Agent:</b> <ansiblue> {agent_name} </ansiblue> | <b>Mode:</b> <{mode_style}> {mode_text} </{mode_style}> | {shortcut_text}"
+        )
+
+    # Create session with history and completions
+    session = PromptSession(
+        history=agent_histories[agent_name],
+        completer=AgentCompleter(
+            agents=list(available_agents) if available_agents else [],
+            agent_types=agent_types or {},
+        ),
+        complete_while_typing=True,
+        lexer=PygmentsLexer(PythonLexer) if syntax == "python" else None,
+        multiline=Condition(lambda: in_multiline_mode),
+        complete_in_thread=True,
+        mouse_support=True,
+        bottom_toolbar=get_toolbar,  # Pass the function here
+    )
+
+    # Create key bindings with a reference to the app
+    bindings = create_keybindings(
+        on_toggle_multiline=on_multiline_toggle, app=session.app
+    )
+    session.app.key_bindings = bindings
+
+    # Create formatted prompt text
+    prompt_text = f"<ansicyan>{agent_name}</ansicyan> > "
+
+    # Add default value display if requested
+    if show_default and default and default != "STOP":
+        prompt_text = f"{prompt_text} [<ansigreen>{default}</ansigreen>] "
+
+    # Only show hints at startup if requested
+    if show_stop_hint:
+        if default == "STOP":
+            rich_print("[yellow]Press <ENTER> to finish.[/yellow]")
+        else:
+            rich_print("Enter a prompt, or [red]STOP[/red] to finish")
+            if default:
+                rich_print(
+                    f"Press <ENTER> to use the default prompt:\n[cyan]{default}[/cyan]"
+                )
+
+    # Mention available features but only on first usage for this agent
+    if agent_name not in agent_messages_shown:
+        rich_print(
+            "[dim]Tip: Type /help for commands, press F1 for keyboard shortcuts. Ctrl+T toggles multiline mode. @Agent to switch agent[/dim]"
+        )
+        agent_messages_shown.add(agent_name)
+
+    # Process special commands
+    def pre_process_input(text):
+        # Command processing
+        if text and text.startswith("/"):
+            cmd = text[1:].strip().lower()
+            if cmd == "help":
+                return "HELP"
+            elif cmd == "clear":
+                return "CLEAR"
+            elif cmd == "agents":
+                return "LIST_AGENTS"
+
+        # Agent switching
+        if text and text.startswith("@"):
+            return f"SWITCH:{text[1:].strip()}"
+
+        return text
+
+    # Get the input - using async version
+    try:
+        result = await session.prompt_async(HTML(prompt_text), default=default)
+        return pre_process_input(result)
+    except KeyboardInterrupt:
+        # Handle Ctrl+C gracefully
+        return "STOP"
+    except EOFError:
+        # Handle Ctrl+D gracefully
+        return "STOP"
+    except Exception as e:
+        # Log and gracefully handle other exceptions
+        print(f"\nInput error: {type(e).__name__}: {e}")
+        return "STOP"
+
+
+async def handle_special_commands(command, agent_app=None):
+    """Handle special input commands."""
+    # Quick guard for empty or None commands
+    if not command:
+        return False
+
+    # Check for special commands
+    if command == "HELP":
+        rich_print("\n[bold]Available Commands:[/bold]")
+        rich_print("  /help          - Show this help")
+        rich_print("  /clear         - Clear screen")
+        rich_print("  /agents        - List available agents")
+        rich_print("  @agent_name    - Switch to agent")
+        rich_print("  STOP           - End session")
+        rich_print("\n[bold]Keyboard Shortcuts:[/bold]")
+        rich_print(
+            "  Enter          - Submit (normal mode) / New line (multiline mode)"
+        )
+        rich_print("  Alt+Enter      - Always submit (even in multiline mode)")
+        rich_print("  Ctrl+T         - Toggle multiline mode")
+        rich_print("  Ctrl+L         - Clear input")
+        rich_print("  Up/Down        - Navigate history")
+        rich_print("  F1             - Show help")
+        return True
+
+    elif command == "CLEAR":
+        # Clear screen (ANSI escape sequence)
+        print("\033c", end="")
+        return True
+
+    elif command == "LIST_AGENTS":
+        if available_agents:
+            rich_print("\n[bold]Available Agents:[/bold]")
+            for agent in sorted(available_agents):
+                rich_print(f"  @{agent}")
+        else:
+            rich_print("[yellow]No agents available[/yellow]")
+        return True
+
+    elif isinstance(command, str) and command.startswith("SWITCH:"):
+        agent_name = command.split(":", 1)[1]
+        if agent_name in available_agents:
+            if agent_app:
+                rich_print(f"[green]Switching to agent: {agent_name}[/green]")
+                return {"switch_agent": agent_name}
+            else:
+                rich_print(
+                    "[yellow]Agent switching not available in this context[/yellow]"
+                )
+        else:
+            rich_print(f"[red]Unknown agent: {agent_name}[/red]")
+        return True
+
+    return False

mcp_agent/core/fastagent.py

@@ -28,7 +28,6 @@ from mcp_agent.workflows.evaluator_optimizer.evaluator_optimizer import (
 )
 from mcp_agent.workflows.router.router_llm import LLMRouter
 from mcp_agent.config import Settings
-from rich.prompt import Prompt
 from rich import print
 from mcp_agent.progress_display import progress_display
 from mcp_agent.workflows.llm.model_factory import ModelFactory
@@ -161,34 +160,73 @@ class AgentApp:
 
     async def prompt(self, agent_name: Optional[str] = None, default: str = "") -> str:
         """
-        Interactive prompt for sending messages.
+        Interactive prompt for sending messages with advanced features.
 
         Args:
             agent_name: Optional target agent name (uses default if not specified)
-            default_prompt: Default message to use when user presses enter
+            default: Default message to use when user presses enter
         """
+        from .enhanced_prompt import get_enhanced_input, handle_special_commands
 
         agent = agent_name or self._default
 
         if agent not in self._agents:
             raise ValueError(f"No agent named '{agent}'")
+
+        # Pass all available agent names for auto-completion
+        available_agents = list(self._agents.keys())
+        
+        # Create agent_types dictionary mapping agent names to their types
+        agent_types = {}
+        for name, proxy in self._agents.items():
+            # Determine agent type based on the proxy type
+            if isinstance(proxy, LLMAgentProxy):
+                # Convert AgentType.BASIC.value ("agent") to "Agent"
+                agent_types[name] = "Agent"
+            elif isinstance(proxy, RouterProxy):
+                agent_types[name] = "Router"
+            elif isinstance(proxy, WorkflowProxy):
+                # For workflow proxies, check the workflow type
+                workflow = proxy._workflow
+                if isinstance(workflow, Orchestrator):
+                    agent_types[name] = "Orchestrator"
+                elif isinstance(workflow, ParallelLLM):
+                    agent_types[name] = "Parallel"
+                elif isinstance(workflow, EvaluatorOptimizerLLM):
+                    agent_types[name] = "Evaluator"
+                else:
+                    agent_types[name] = "Workflow"
+
         result = ""
         while True:
             with progress_display.paused():
-                if default == "STOP":
-                    print("Press <ENTER> to finish.")
-                elif default != "":
-                    print("Enter a prompt, or [red]STOP[/red] to finish.")
-                    print(
-                        f"Press <ENTER> to use the default prompt:\n[cyan]{default}[/cyan]"
-                    )
-                else:
-                    print("Enter a prompt, or [red]STOP[/red] to finish")
-
-                prompt_text = f"[blue]{agent}[/blue] >"
-                user_input = Prompt.ask(
-                    prompt=prompt_text, default=default, show_default=False
+                # Use the enhanced input method with advanced features
+                user_input = await get_enhanced_input(
+                    agent_name=agent,
+                    default=default,
+                    show_default=(default != ""),
+                    show_stop_hint=True,
+                    multiline=False,  # Default to single-line mode
+                    available_agent_names=available_agents,
+                    syntax=None,  # Can enable syntax highlighting for code input
+                    agent_types=agent_types,  # Pass agent types for display
                 )
+
+                # Handle special commands
+                command_result = await handle_special_commands(user_input, self)
+
+                # Check if we should switch agents
+                if (
+                    isinstance(command_result, dict)
+                    and "switch_agent" in command_result
+                ):
+                    agent = command_result["switch_agent"]
+                    continue
+
+                # Skip further processing if command was handled
+                if command_result:
+                    continue
+
                 if user_input.upper() == "STOP":
                     return
                 if user_input == "":
@@ -400,12 +438,12 @@ class FastAgent(ContextDependent):
             elif agent_type == AgentType.EVALUATOR_OPTIMIZER.value:
                 # Check both evaluator and optimizer exist
                 evaluator = agent_data["evaluator"]
-                optimizer = agent_data["optimizer"]
+                generator = agent_data["generator"]
                 missing = []
                 if evaluator not in available_components:
                     missing.append(f"evaluator: {evaluator}")
-                if optimizer not in available_components:
-                    missing.append(f"optimizer: {optimizer}")
+                if generator not in available_components:
+                    missing.append(f"generator: {generator}")
                 if missing:
                     raise AgentConfigError(
                         f"Evaluator-Optimizer '{name}' references non-existent components: {', '.join(missing)}"
@@ -672,7 +710,7 @@ class FastAgent(ContextDependent):
     def evaluator_optimizer(
         self,
         name: str,
-        optimizer: str,
+        generator: str,
         evaluator: str,
         min_rating: str = "GOOD",
         max_refinements: int = 3,
@@ -684,7 +722,7 @@ class FastAgent(ContextDependent):
 
         Args:
             name: Name of the workflow
-            optimizer: Name of the optimizer agent
+            generator: Name of the generator agent
             evaluator: Name of the evaluator agent
             min_rating: Minimum acceptable quality rating (EXCELLENT, GOOD, FAIR, POOR)
             max_refinements: Maximum number of refinement iterations
@@ -699,7 +737,7 @@ class FastAgent(ContextDependent):
             wrapper_needed=True,
         )(
             name=name,
-            optimizer=optimizer,
+            generator=generator,
             evaluator=evaluator,
             min_rating=min_rating,
             max_refinements=max_refinements,
@@ -853,27 +891,27 @@ class FastAgent(ContextDependent):
 
                 elif agent_type == AgentType.EVALUATOR_OPTIMIZER:
                     # Get the referenced agents - unwrap from proxies
-                    optimizer = self._unwrap_proxy(
-                        active_agents[agent_data["optimizer"]]
+                    generator = self._unwrap_proxy(
+                        active_agents[agent_data["generator"]]
                     )
                     evaluator = self._unwrap_proxy(
                         active_agents[agent_data["evaluator"]]
                     )
 
-                    if not optimizer or not evaluator:
+                    if not generator or not evaluator:
                         raise ValueError(
                             f"Missing agents for workflow {name}: "
-                            f"optimizer={agent_data['optimizer']}, "
+                            f"generator={agent_data['generator']}, "
                             f"evaluator={agent_data['evaluator']}"
                         )
 
                     # TODO: Remove legacy - factory usage is only needed for str evaluators
                     # Later this should only be passed when evaluator is a string
                     optimizer_model = (
-                        optimizer.config.model if isinstance(optimizer, Agent) else None
+                        generator.config.model if isinstance(generator, Agent) else None
                     )
                     instance = EvaluatorOptimizerLLM(
-                        optimizer=optimizer,
+                        generator=generator,
                         evaluator=evaluator,
                         min_rating=QualityRating[agent_data["min_rating"]],
                         max_refinements=agent_data["max_refinements"],

mcp_agent/resources/examples/internal/agent.py

@@ -0,0 +1,17 @@
+import asyncio
+from mcp_agent.core.fastagent import FastAgent
+
+# Create the application
+fast = FastAgent("FastAgent Example")
+
+
+# Define the agent
+@fast.agent(servers=["fetch"])
+async def main():
+    # use the --model command line switch or agent arguments to change model
+    async with fast.run() as agent:
+        await agent()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

mcp_agent/resources/examples/internal/job.py

@@ -52,7 +52,7 @@ fast = FastAgent("PMO Job Description Generator")
 )
 @fast.evaluator_optimizer(
     name="job_description_writer",
-    optimizer="content_generator",
+    generator="content_generator",
     evaluator="consistency_checker",
     min_rating="EXCELLENT",
     max_refinements=2,

mcp_agent/resources/examples/mcp_researcher/researcher-eval.py

@@ -35,7 +35,7 @@ Summarize your evaluation as a structured response with:
 - Specific feedback and areas for improvement.""",
 )
 @agents.evaluator_optimizer(
-    optimizer="Researcher",
+    generator="Researcher",
     evaluator="Evaluator",
     max_refinements=5,
     min_rating="EXCELLENT",

mcp_agent/resources/examples/researcher/fastagent.config.yaml

@@ -0,0 +1,53 @@
+#
+# Please edit this configuration file to match your environment (on Windows).
+# Examples in comments below - check/change the paths.
+#
+#
+
+execution_engine: asyncio
+logger:
+  type: file
+  level: error
+  truncate_tools: true
+
+mcp:
+  servers:
+    brave:
+      # On windows replace the command and args line to use `node` and the absolute path to the server.
+      # Use `npm i -g @modelcontextprotocol/server-brave-search` to install the server globally.
+      # Use `npm -g root` to find the global node_modules path.`
+      # command: "node"
+      # args: ["c:/Program Files/nodejs/node_modules/@modelcontextprotocol/server-brave-search/dist/index.js"]
+      command: "npx"
+      args: ["-y", "@modelcontextprotocol/server-brave-search"]
+      env:
+        # You can also place your BRAVE_API_KEY in the fastagent.secrets.yaml file.
+        BRAVE_API_KEY: <your_brave_api_key>
+    filesystem:
+      # On windows update the command and arguments to use `node` and the absolute path to the server.
+      # Use `npm i -g @modelcontextprotocol/server-filesystem` to install the server globally.
+      # Use `npm -g root` to find the global node_modules path.`
+      # command: "node"
+      # args: ["c:/Program Files/nodejs/node_modules/@modelcontextprotocol/server-filesystem/dist/index.js","./agent_folder"]
+      command: "npx"
+      args: ["-y", "@modelcontextprotocol/server-filesystem", "./agent_folder/"]
+    interpreter:
+      command: "docker"
+      args: [
+          "run",
+          "-i",
+          "--rm",
+          "--pull=always",
+          "-v",
+          "./agent_folder:/mnt/data/",
+          # Docker needs the absolute path on Windows (e.g. "x:/fastagent/agent_folder:/mnt/data/")
+          # "./agent_folder:/mnt/data/",
+          "ghcr.io/evalstate/mcp-py-repl:latest",
+        ]
+      roots:
+        - uri: "file://./agent_folder/"
+          name: "agent_folder"
+          server_uri_alias: "file:///mnt/data/"
+    fetch:
+      command: "uvx"
+      args: ["mcp-server-fetch"]

mcp_agent/resources/examples/researcher/researcher-eval.py

@@ -0,0 +1,53 @@
+import asyncio
+
+from mcp_agent.core.fastagent import FastAgent
+
+agents = FastAgent(name="Researcher")
+
+
+@agents.agent(
+    name="Researcher",
+    instruction="""
+You are a research assistant, with access to internet search (via Brave),
+website fetch, a python interpreter (you can install packages with uv) and a filesystem.
+Use the current working directory to save and create files with both the Interpreter and Filesystem tools.
+The interpreter has numpy, pandas, matplotlib and seaborn already installed.
+
+You must always provide a summary of the specific sources you have used in your research.
+    """,
+    servers=["brave", "interpreter", "filesystem", "fetch"],
+)
+@agents.agent(
+    name="Evaluator",
+    model="sonnet",
+    instruction="""
+Evaluate the response from the researcher based on the criteria:
+ - Sources cited. Has the researcher provided a summary of the specific sources used in the research?
+ - Validity. Has the researcher cross-checked and validated data and assumptions.
+ - Alignment. Has the researher acted and addressed feedback from any previous assessments?
+ 
+For each criterion:
+- Provide a rating (EXCELLENT, GOOD, FAIR, or POOR).
+- Offer specific feedback or suggestions for improvement.
+
+Summarize your evaluation as a structured response with:
+- Overall quality rating.
+- Specific feedback and areas for improvement.""",
+)
+@agents.evaluator_optimizer(
+    generator="Researcher",
+    evaluator="Evaluator",
+    max_refinements=5,
+    min_rating="EXCELLENT",
+    name="Researcher_Evaluator",
+)
+async def main():
+    async with agents.run() as agent:
+        await agent.prompt("Researcher_Evaluator")
+
+        print("Ask follow up quesions to the Researcher?")
+        await agent.prompt("Researcher", default="STOP")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

mcp_agent/resources/examples/researcher/researcher.py

@@ -0,0 +1,38 @@
+import asyncio
+
+from mcp_agent.core.fastagent import FastAgent
+# from rich import print
+
+agents = FastAgent(name="Researcher")
+
+
+@agents.agent(
+    "Researcher",
+    instruction="""
+You are a research assistant, with access to internet search (via Brave),
+website fetch, a python interpreter (you can install packages with uv) and a filesystem.
+Use the current working directory to save and create files with both the Interpreter and Filesystem tools.
+The interpreter has numpy, pandas, matplotlib and seaborn already installed
+    """,
+    servers=["brave", "interpreter", "filesystem", "fetch"],
+)
+async def main():
+    research_prompt = """
+Produce an investment report for the company Eutelsat. The final report should be saved in the filesystem in markdown format, and
+contain at least the following: 
+1 - A brief description of the company
+2 - Current financial position (find data, create and incorporate charts)
+3 - A PESTLE analysis
+4 - An investment thesis for the next 3 years. Include both 'buy side' and 'sell side' arguments, and a final 
+summary and recommendation.
+Todays date is 15 February 2025. Include the main data sources consulted in presenting the report."""  # noqa: F841
+
+    async with agents.run() as agent:
+        await agent.prompt()
+
+        # await agent.prompt(default="STOP")
+        #        await agent.prompt(default=research_prompt)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

mcp_agent/resources/examples/workflows/agent.py

@@ -0,0 +1,17 @@
+import asyncio
+from mcp_agent.core.fastagent import FastAgent
+
+# Create the application
+fast = FastAgent("FastAgent Example")
+
+
+# Define the agent
+@fast.agent(servers=["fetch"])
+async def main():
+    # use the --model command line switch or agent arguments to change model
+    async with fast.run() as agent:
+        await agent()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

mcp_agent/resources/examples/workflows/evaluator.py

@@ -11,7 +11,7 @@ fast = FastAgent("Evaluator-Optimizer")
 
 # Define optimizer agent
 @fast.agent(
-    name="optimizer",
+    name="generator",
     instruction="""You are a career coach specializing in cover letter writing.
     You are tasked with generating a compelling cover letter given the job posting,
     candidate details, and company information. Tailor the response to the company and job requirements.
@@ -38,12 +38,13 @@ fast = FastAgent("Evaluator-Optimizer")
     Summarize your evaluation as a structured response with:
     - Overall quality rating.
     - Specific feedback and areas for improvement.""",
-    model="sonnet",
+    # instructor doesn't seem to work for sonnet37
+    # model="sonnet35",
 )
 # Define the evaluator-optimizer workflow
 @fast.evaluator_optimizer(
     name="cover_letter_writer",
-    optimizer="optimizer",  # Reference to optimizer agent
+    generator="generator",  # Reference to optimizer agent
     evaluator="evaluator",  # Reference to evaluator agent
     min_rating="EXCELLENT",  # Strive for excellence
     max_refinements=3,  # Maximum iterations
@@ -70,6 +71,8 @@ async def main():
             f"Company information: {company_information}",
         )
 
+        await agent()
+
 
 if __name__ == "__main__":
     asyncio.run(main())

mcp_agent/resources/examples/workflows/fastagent.py

@@ -0,0 +1,22 @@
+import asyncio
+from mcp_agent.core.fastagent import FastAgent
+
+# Create the application
+agent_app = FastAgent("FastAgent Example")
+# Uncomment the below to disable human input callback tool
+# agent_app.app._human_input_callback = None
+
+
+# Define the agent
+@agent_app.agent(
+    instruction="You are a helpful AI Agent",
+    servers=[],
+)
+async def main():
+    # use the --model= command line switch to specify model
+    async with agent_app.run() as agent:
+        await agent()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

mcp_agent/workflows/evaluator_optimizer/evaluator_optimizer.py

@@ -66,18 +66,19 @@ class EvaluatorOptimizerLLM(AugmentedLLM[MessageParamT, MessageT]):
 
     def __init__(
         self,
-        optimizer: Agent | AugmentedLLM,
+        generator: Agent | AugmentedLLM,
         evaluator: str | Agent | AugmentedLLM,
         min_rating: QualityRating = QualityRating.GOOD,
         max_refinements: int = 3,
-        llm_factory: Callable[[Agent], AugmentedLLM] | None = None,  # TODO: Remove legacy - factory should only be needed for str evaluator
+        llm_factory: Callable[[Agent], AugmentedLLM]
+        | None = None,  # TODO: Remove legacy - factory should only be needed for str evaluator
         context: Optional["Context"] = None,
     ):
         """
         Initialize the evaluator-optimizer workflow.
 
         Args:
-            optimizer: The agent/LLM/workflow that generates responses. Can be:
+            generator: The agent/LLM/workflow that generates responses. Can be:
                      - An Agent that will be converted to an AugmentedLLM
                      - An AugmentedLLM instance
                      - An Orchestrator/Router/ParallelLLM workflow
@@ -90,38 +91,38 @@ class EvaluatorOptimizerLLM(AugmentedLLM[MessageParamT, MessageT]):
         super().__init__(context=context)
 
         # Set up the optimizer
-        self.name = optimizer.name
+        self.name = generator.name
         self.llm_factory = llm_factory
-        self.optimizer = optimizer
+        self.generator = generator
         self.evaluator = evaluator
 
         # TODO: Remove legacy - optimizer should always be an AugmentedLLM, no conversion needed
-        if isinstance(optimizer, Agent):
+        if isinstance(generator, Agent):
             if not llm_factory:
                 raise ValueError("llm_factory is required when using an Agent")
 
             # Only create new LLM if agent doesn't have one
-            if hasattr(optimizer, "_llm") and optimizer._llm:
-                self.optimizer_llm = optimizer._llm
+            if hasattr(generator, "_llm") and generator._llm:
+                self.generator_llm = generator._llm
             else:
-                self.optimizer_llm = llm_factory(agent=optimizer)
-            
-            self.aggregator = optimizer
+                self.generator_llm = llm_factory(agent=generator)
+
+            self.aggregator = generator
             self.instruction = (
-                optimizer.instruction
-                if isinstance(optimizer.instruction, str)
+                generator.instruction
+                if isinstance(generator.instruction, str)
                 else None
             )
 
-        elif isinstance(optimizer, AugmentedLLM):
-            self.optimizer_llm = optimizer
-            self.aggregator = optimizer.aggregator
-            self.instruction = optimizer.instruction
+        elif isinstance(generator, AugmentedLLM):
+            self.generator_llm = generator
+            self.aggregator = generator.aggregator
+            self.instruction = generator.instruction
 
         else:
-            raise ValueError(f"Unsupported optimizer type: {type(optimizer)}")
+            raise ValueError(f"Unsupported optimizer type: {type(generator)}")
 
-        self.history = self.optimizer_llm.history
+        self.history = self.generator_llm.history
 
         # Set up the evaluator
         if isinstance(evaluator, AugmentedLLM):
@@ -169,17 +170,17 @@ class EvaluatorOptimizerLLM(AugmentedLLM[MessageParamT, MessageT]):
         best_response = None
         best_rating = QualityRating.POOR
         self.refinement_history = []
-        
+
         # Use a single AsyncExitStack for the entire method to maintain connections
         async with contextlib.AsyncExitStack() as stack:
             # Enter all agent contexts once at the beginning
-            if isinstance(self.optimizer, Agent):
-                await stack.enter_async_context(self.optimizer)
+            if isinstance(self.generator, Agent):
+                await stack.enter_async_context(self.generator)
             if isinstance(self.evaluator, Agent):
                 await stack.enter_async_context(self.evaluator)
-                
+
             # Initial generation
-            response = await self.optimizer_llm.generate(
+            response = await self.generator_llm.generate(
                 message=message,
                 request_params=request_params,
             )
@@ -251,7 +252,7 @@ class EvaluatorOptimizerLLM(AugmentedLLM[MessageParamT, MessageT]):
                 )
 
                 # No nested AsyncExitStack here either
-                response = await self.optimizer_llm.generate(
+                response = await self.generator_llm.generate(
                     message=refinement_prompt,
                     request_params=request_params,
                 )
@@ -274,13 +275,13 @@ class EvaluatorOptimizerLLM(AugmentedLLM[MessageParamT, MessageT]):
         # Handle case where response is a single message
         if not isinstance(response, list):
             return str(response)
-            
+
         # Convert all messages to strings, handling different message types
         result_strings = []
         for r in response:
-            if hasattr(r, 'text'):
+            if hasattr(r, "text"):
                 result_strings.append(r.text)
-            elif hasattr(r, 'content'):
+            elif hasattr(r, "content"):
                 # Handle ToolUseBlock and similar
                 if isinstance(r.content, list):
                     # Typically content is a list of blocks
@@ -290,7 +291,7 @@ class EvaluatorOptimizerLLM(AugmentedLLM[MessageParamT, MessageT]):
             else:
                 # Fallback to string representation
                 result_strings.append(str(r))
-                
+
         return "\n".join(result_strings)
 
     async def generate_structured(
@@ -304,7 +305,7 @@ class EvaluatorOptimizerLLM(AugmentedLLM[MessageParamT, MessageT]):
             message=message, request_params=request_params
         )
 
-        return await self.optimizer.generate_structured(
+        return await self.generator.generate_structured(
             message=response_str,
             response_model=response_model,
             request_params=request_params,

mcp_agent/workflows/llm/augmented_llm.py

@@ -495,7 +495,10 @@ class AugmentedLLM(ContextDependent, AugmentedLLMProtocol[MessageParamT, Message
         console.console.print("\n")
 
     async def show_assistant_message(
-        self, message_text: str | Text, highlight_namespaced_tool: str = ""
+        self,
+        message_text: str | Text,
+        highlight_namespaced_tool: str = "",
+        title: str = "ASSISTANT",
     ):
         """Display an assistant message in a formatted panel."""
 
@@ -525,7 +528,7 @@ class AugmentedLLM(ContextDependent, AugmentedLLMProtocol[MessageParamT, Message
 
         panel = Panel(
             message_text,
-            title=f"[ASSISTANT]{f' ({self.name})' if self.name else ''}",
+            title=f"[{title}]{f' ({self.name})' if self.name else ''}",
             title_align="left",
             style="green",
             border_style="bold white",

mcp_agent/workflows/llm/augmented_llm_anthropic.py

@@ -331,7 +331,9 @@ class AnthropicAugmentedLLM(AugmentedLLM[MessageParam, Message]):
             messages=[{"role": "user", "content": response}],
             max_tokens=params.maxTokens,
         )
-
+        await self.show_assistant_message(
+            str(structured_response), title="ASSISTANT/STRUCTURED"
+        )
         return structured_response
 
     @classmethod

mcp_agent/workflows/llm/augmented_llm_openai.py

@@ -97,12 +97,7 @@ class OpenAIAugmentedLLM(
             use_history=True,
         )
 
-    async def generate(self, message, request_params: RequestParams | None = None):
-        """
-        Process a query using an LLM and available tools.
-        The default implementation uses OpenAI's ChatCompletion as the LLM.
-        Override this method to use a different LLM.
-        """
+    def _api_key(self) -> str:
         config = self.context.config
         api_key = None
 
@@ -121,9 +116,22 @@ class OpenAIAugmentedLLM(
                 "Add it to your configuration file under openai.api_key\n"
                 "Or set the OPENAI_API_KEY environment variable",
             )
+        return api_key
+
+    def _base_url(self) -> str:
+        return (
+            self.context.config.openai.base_url if self.context.config.openai else None
+        )
+
+    async def generate(self, message, request_params: RequestParams | None = None):
+        """
+        Process a query using an LLM and available tools.
+        The default implementation uses OpenAI's ChatCompletion as the LLM.
+        Override this method to use a different LLM.
+        """
 
         try:
-            openai_client = OpenAI(api_key=api_key, base_url=config.openai.base_url)
+            openai_client = OpenAI(api_key=self._api_key(), base_url=self._base_url())
             messages: List[ChatCompletionMessageParam] = []
             params = self.get_request_params(request_params)
         except AuthenticationError as e:
@@ -356,8 +364,8 @@ class OpenAIAugmentedLLM(
         # Next we pass the text through instructor to extract structured data
         client = instructor.from_openai(
             OpenAI(
-                api_key=self.context.config.openai.api_key,
-                base_url=self.context.config.openai.base_url,
+                api_key=self._api_key(),
+                base_url=self._base_url(),
             ),
             mode=instructor.Mode.TOOLS_STRICT,
         )
@@ -373,6 +381,9 @@ class OpenAIAugmentedLLM(
                 {"role": "user", "content": response},
             ],
         )
+        await self.show_assistant_message(
+            str(structured_response), title="ASSISTANT/STRUCTURED"
+        )
 
         return structured_response