fast-agent-mcp 0.2.46__py3-none-any.whl → 0.2.47__py3-none-any.whl

mcp_agent/core/direct_factory.py

@@ -10,6 +10,7 @@ from mcp_agent.agents.workflow.evaluator_optimizer import (
     EvaluatorOptimizerAgent,
     QualityRating,
 )
+from mcp_agent.agents.workflow.iterative_planner import IterativePlanner
 from mcp_agent.agents.workflow.orchestrator_agent import OrchestratorAgent
 from mcp_agent.agents.workflow.parallel_agent import ParallelAgent
 from mcp_agent.agents.workflow.router_agent import RouterAgent
@@ -21,9 +22,10 @@ from mcp_agent.event_progress import ProgressAction
 from mcp_agent.llm.augmented_llm import RequestParams
 from mcp_agent.llm.model_factory import ModelFactory
 from mcp_agent.logging.logger import get_logger
+from mcp_agent.mcp.interfaces import AgentProtocol
 
 # Type aliases for improved readability and IDE support
-AgentDict = Dict[str, Agent]
+AgentDict = Dict[str, AgentProtocol]
 AgentConfigDict = Dict[str, Dict[str, Any]]
 T = TypeVar("T")  # For generic types
 
@@ -153,7 +155,7 @@ async def create_agents_by_type(
                 await agent.attach_llm(
                     llm_factory,
                     request_params=config.default_request_params,
-                    api_key=config.api_key
+                    api_key=config.api_key,
                 )
                 result_agents[name] = agent
 
@@ -172,11 +174,11 @@ async def create_agents_by_type(
                 await agent.attach_llm(
                     llm_factory,
                     request_params=config.default_request_params,
-                    api_key=config.api_key
+                    api_key=config.api_key,
                 )
                 result_agents[name] = agent
 
-            elif agent_type == AgentType.ORCHESTRATOR:
+            elif agent_type == AgentType.ORCHESTRATOR or agent_type == AgentType.ITERATIVE_PLANNER:
                 # Get base params configured with model settings
                 base_params = (
                     config.default_request_params.model_copy()
@@ -193,24 +195,35 @@ async def create_agents_by_type(
                     agent = active_agents[agent_name]
                     child_agents.append(agent)
 
-                # Create the orchestrator
-                orchestrator = OrchestratorAgent(
-                    config=config,
-                    context=app_instance.context,
-                    agents=child_agents,
-                    plan_iterations=agent_data.get("plan_iterations", 5),
-                    plan_type=agent_data.get("plan_type", "full"),
-                )
+                if AgentType.ORCHESTRATOR == agent_type:
+                    # Create the orchestrator
+                    orchestrator = OrchestratorAgent(
+                        config=config,
+                        context=app_instance.context,
+                        agents=child_agents,
+                        plan_iterations=agent_data.get("plan_iterations", 5),
+                        plan_type=agent_data.get("plan_type", "full"),
+                    )
+                else:
+                    orchestrator = IterativePlanner(
+                        config=config,
+                        context=app_instance.context,
+                        agents=child_agents,
+                        plan_iterations=agent_data.get("plan_iterations", 5),
+                        plan_type=agent_data.get("plan_type", "full"),
+                    )
 
                 # Initialize the orchestrator
                 await orchestrator.initialize()
 
                 # Attach LLM to the orchestrator
                 llm_factory = model_factory_func(model=config.model)
+
+                #                print("************", config.default_request_params.instruction)
                 await orchestrator.attach_llm(
                     llm_factory,
                     request_params=config.default_request_params,
-                    api_key=config.api_key
+                    api_key=config.api_key,
                 )
 
                 result_agents[name] = orchestrator
@@ -274,7 +287,7 @@ async def create_agents_by_type(
                 await router.attach_llm(
                     llm_factory,
                     request_params=config.default_request_params,
-                    api_key=config.api_key
+                    api_key=config.api_key,
                 )
                 result_agents[name] = router
 
@@ -461,7 +474,6 @@ async def create_agents_in_dependency_order(
             )
             active_agents.update(evaluator_agents)
 
-        # Create orchestrator agents last since they might depend on other agents
         if AgentType.ORCHESTRATOR.value in [agents_dict[name]["type"] for name in group]:
             orchestrator_agents = await create_agents_by_type(
                 app_instance,
@@ -476,6 +488,21 @@ async def create_agents_in_dependency_order(
             )
             active_agents.update(orchestrator_agents)
 
+        # Create orchestrator2 agents last since they might depend on other agents
+        if AgentType.ITERATIVE_PLANNER.value in [agents_dict[name]["type"] for name in group]:
+            orchestrator2_agents = await create_agents_by_type(
+                app_instance,
+                {
+                    name: agents_dict[name]
+                    for name in group
+                    if agents_dict[name]["type"] == AgentType.ITERATIVE_PLANNER.value
+                },
+                AgentType.ITERATIVE_PLANNER,
+                active_agents,
+                model_factory_func,
+            )
+            active_agents.update(orchestrator2_agents)
+
     return active_agents
 
 

mcp_agent/core/fastagent.py

@@ -31,6 +31,9 @@ from mcp_agent.core.direct_decorators import (
 from mcp_agent.core.direct_decorators import (
     evaluator_optimizer as evaluator_optimizer_decorator,
 )
+from mcp_agent.core.direct_decorators import (
+    iterative_planner as orchestrator2_decorator,
+)
 from mcp_agent.core.direct_decorators import (
     orchestrator as orchestrator_decorator,
 )
@@ -249,6 +252,7 @@ class FastAgent:
     agent = agent_decorator
     custom = custom_decorator
     orchestrator = orchestrator_decorator
+    iterative_planner = orchestrator2_decorator
     router = router_decorator
     chain = chain_decorator
     parallel = parallel_decorator

mcp_agent/core/mermaid_utils.py

@@ -0,0 +1,170 @@
+"""Utilities for detecting and processing Mermaid diagrams in text content."""
+
+import base64
+import re
+import zlib
+from dataclasses import dataclass
+from typing import List, Optional
+
+# Mermaid chart viewer URL prefix
+MERMAID_VIEWER_URL = "https://www.mermaidchart.com/play#"
+# mermaid.live#pako= also works but the playground has better ux
+
+
+@dataclass
+class MermaidDiagram:
+    """Represents a detected Mermaid diagram."""
+
+    content: str
+    title: Optional[str] = None
+    start_pos: int = 0
+    end_pos: int = 0
+
+
+def extract_mermaid_diagrams(text: str) -> List[MermaidDiagram]:
+    """
+    Extract all Mermaid diagram blocks from text content.
+
+    Handles both simple mermaid blocks and blocks with titles:
+    - ```mermaid
+    - ```mermaid title={Some Title}
+
+    Also extracts titles from within the diagram content.
+
+    Args:
+        text: The text content to search for Mermaid diagrams
+
+    Returns:
+        List of MermaidDiagram objects found in the text
+    """
+    diagrams = []
+
+    # Pattern to match mermaid code blocks with optional title
+    # Matches: ```mermaid or ```mermaid title={...}
+    pattern = r"```mermaid(?:\s+title=\{([^}]+)\})?\s*\n(.*?)```"
+
+    for match in re.finditer(pattern, text, re.DOTALL):
+        title = match.group(1)  # May be None if no title
+        content = match.group(2).strip()
+
+        if content:  # Only add if there's actual diagram content
+            # If no title from code fence, look for title in the content
+            if not title:
+                # Look for various title patterns in mermaid diagrams
+                # pie title, graph title, etc.
+                title_patterns = [
+                    r"^\s*title\s+(.+?)(?:\n|$)",  # Generic title
+                    r"^\s*pie\s+title\s+(.+?)(?:\n|$)",  # Pie chart title
+                    r"^\s*gantt\s+title\s+(.+?)(?:\n|$)",  # Gantt chart title
+                ]
+
+                for title_pattern in title_patterns:
+                    title_match = re.search(title_pattern, content, re.MULTILINE)
+                    if title_match:
+                        title = title_match.group(1).strip()
+                        break
+
+            diagrams.append(
+                MermaidDiagram(
+                    content=content, title=title, start_pos=match.start(), end_pos=match.end()
+                )
+            )
+
+    return diagrams
+
+
+def create_mermaid_live_link(diagram_content: str) -> str:
+    """
+    Create a Mermaid Live Editor link from diagram content.
+
+    The link uses pako compression (zlib) and base64 encoding.
+
+    Args:
+        diagram_content: The Mermaid diagram source code
+
+    Returns:
+        Complete URL to Mermaid Live Editor
+    """
+    # Create the JSON structure expected by Mermaid Live
+    # Escape newlines and quotes in the diagram content
+    escaped_content = diagram_content.replace('"', '\\"').replace("\n", "\\n")
+    json_str = f'{{"code":"{escaped_content}","mermaid":{{"theme":"default"}},"updateEditor":false,"autoSync":true,"updateDiagram":false}}'
+
+    # Compress using zlib (pako compatible)
+    compressed = zlib.compress(json_str.encode("utf-8"))
+
+    # Base64 encode
+    encoded = base64.urlsafe_b64encode(compressed).decode("utf-8")
+
+    # Remove padding characters as Mermaid Live doesn't use them
+    encoded = encoded.rstrip("=")
+
+    return f"{MERMAID_VIEWER_URL}pako:{encoded}"
+
+
+def format_mermaid_links(diagrams: List[MermaidDiagram]) -> List[str]:
+    """
+    Format Mermaid diagrams as markdown links.
+
+    Args:
+        diagrams: List of MermaidDiagram objects
+
+    Returns:
+        List of formatted markdown strings
+    """
+    links = []
+
+    for i, diagram in enumerate(diagrams, 1):
+        link = create_mermaid_live_link(diagram.content)
+
+        if diagram.title:
+            # Use the title from the diagram with number
+            markdown = f"Diagram {i} - {diagram.title}: [Open Diagram]({link})"
+        else:
+            # Use generic numbering
+            markdown = f"Diagram {i}: [Open Diagram]({link})"
+
+        links.append(markdown)
+
+    return links
+
+
+def detect_diagram_type(content: str) -> str:
+    """
+    Detect the type of mermaid diagram from content.
+
+    Args:
+        content: The mermaid diagram source code
+
+    Returns:
+        Human-readable diagram type name
+    """
+    content_lower = content.strip().lower()
+
+    # Check for common diagram types
+    if content_lower.startswith(("graph ", "flowchart ")):
+        return "Flowchart"
+    elif content_lower.startswith("sequencediagram"):
+        return "Sequence"
+    elif content_lower.startswith("pie"):
+        return "Pie Chart"
+    elif content_lower.startswith("gantt"):
+        return "Gantt Chart"
+    elif content_lower.startswith("classdiagram"):
+        return "Class Diagram"
+    elif content_lower.startswith("statediagram"):
+        return "State Diagram"
+    elif content_lower.startswith("erdiagram"):
+        return "ER Diagram"
+    elif content_lower.startswith("journey"):
+        return "User Journey"
+    elif content_lower.startswith("gitgraph"):
+        return "Git Graph"
+    elif content_lower.startswith("c4context"):
+        return "C4 Context"
+    elif content_lower.startswith("mindmap"):
+        return "Mind Map"
+    elif content_lower.startswith("timeline"):
+        return "Timeline"
+    else:
+        return "Diagram"

mcp_agent/llm/model_database.py

@@ -130,15 +130,11 @@ class ModelDatabase:
     )
 
     # FIXME: xAI has not documented the max output tokens for Grok 4. Using Grok 3 as a placeholder. Will need to update when available (if ever)
-    GROK_4 = ModelParameters(
-        context_window=256000, max_output_tokens=16385, tokenizes=XAI_VISION
-    )
+    GROK_4 = ModelParameters(context_window=256000, max_output_tokens=16385, tokenizes=XAI_VISION)
 
     # Source for Grok 3 max output: https://www.reddit.com/r/grok/comments/1j7209p/exploring_grok_3_beta_output_capacity_a_simple/
     # xAI does not document Grok 3 max output tokens, using the above source as a reference.
-    GROK_3 = ModelParameters(
-        context_window=131072, max_output_tokens=16385, tokenizes=TEXT_ONLY
-    )
+    GROK_3 = ModelParameters(context_window=131072, max_output_tokens=16385, tokenizes=TEXT_ONLY)
 
     # Model configuration database
     MODELS: Dict[str, ModelParameters] = {
@@ -193,7 +189,6 @@ class ModelDatabase:
         "claude-3-7-sonnet": ANTHROPIC_37_SERIES,
         "claude-3-7-sonnet-20250219": ANTHROPIC_37_SERIES,
         "claude-3-7-sonnet-latest": ANTHROPIC_37_SERIES,
-        "claude-sonnet-4": ANTHROPIC_SONNET_4_VERSIONED,
         "claude-sonnet-4-0": ANTHROPIC_SONNET_4_VERSIONED,
         "claude-sonnet-4-20250514": ANTHROPIC_SONNET_4_VERSIONED,
         "claude-opus-4": ANTHROPIC_OPUS_4_VERSIONED,

mcp_agent/llm/providers/augmented_llm_aliyun.py

@@ -18,7 +18,7 @@ class AliyunAugmentedLLM(OpenAIAugmentedLLM):
             model=chosen_model,
             systemPrompt=self.instruction,
             parallel_tool_calls=True,
-            max_iterations=10,
+            max_iterations=20,
             use_history=True,
         )
 

mcp_agent/llm/providers/augmented_llm_anthropic.py

@@ -46,7 +46,7 @@ from mcp_agent.llm.augmented_llm import (
 )
 from mcp_agent.logging.logger import get_logger
 
-DEFAULT_ANTHROPIC_MODEL = "claude-3-7-sonnet-latest"
+DEFAULT_ANTHROPIC_MODEL = "claude-sonnet-4-0"
 
 
 class AnthropicAugmentedLLM(AugmentedLLM[MessageParam, Message]):

mcp_agent/llm/providers/augmented_llm_deepseek.py

@@ -28,7 +28,7 @@ class DeepSeekAugmentedLLM(OpenAIAugmentedLLM):
             model=chosen_model,
             systemPrompt=self.instruction,
             parallel_tool_calls=True,
-            max_iterations=10,
+            max_iterations=20,
             use_history=True,
         )
 
@@ -85,7 +85,9 @@ class DeepSeekAugmentedLLM(OpenAIAugmentedLLM):
         return self._structured_from_multipart(result, model)
 
     @classmethod
-    def convert_message_to_message_param(cls, message: ChatCompletionMessage, **kwargs) -> ChatCompletionAssistantMessageParam:
+    def convert_message_to_message_param(
+        cls, message: ChatCompletionMessage, **kwargs
+    ) -> ChatCompletionAssistantMessageParam:
         """Convert a response object to an input parameter object to allow LLM calls to be chained."""
         if hasattr(message, "reasoning_content"):
             message = copy(message)

mcp_agent/llm/providers/augmented_llm_google_oai.py

@@ -18,7 +18,7 @@ class GoogleOaiAugmentedLLM(OpenAIAugmentedLLM):
             model=chosen_model,
             systemPrompt=self.instruction,
             parallel_tool_calls=False,
-            max_iterations=10,
+            max_iterations=20,
             use_history=True,
         )
 

mcp_agent/llm/providers/augmented_llm_openrouter.py

@@ -32,7 +32,7 @@ class OpenRouterAugmentedLLM(OpenAIAugmentedLLM):
             model=chosen_model,  # Will be validated by base class
             systemPrompt=self.instruction,
             parallel_tool_calls=True,  # Default based on OpenAI provider
-            max_iterations=10,  # Default based on OpenAI provider
+            max_iterations=20,  # Default based on OpenAI provider
             use_history=True,  # Default based on OpenAI provider
         )
 

mcp_agent/llm/providers/augmented_llm_tensorzero.py

@@ -92,7 +92,7 @@ class TensorZeroAugmentedLLM(AugmentedLLM[Dict[str, Any], Any]):
             systemPrompt=self.instruction,
             maxTokens=4096,
             use_history=True,
-            max_iterations=10,  # Max iterations for tool use loop
+            max_iterations=20,  # Max iterations for tool use loop
             parallel_tool_calls=True,
         )
 

mcp_agent/llm/providers/augmented_llm_xai.py

@@ -22,7 +22,7 @@ class XAIAugmentedLLM(OpenAIAugmentedLLM):
             model=chosen_model,
             systemPrompt=self.instruction,
             parallel_tool_calls=False,
-            max_iterations=10,
+            max_iterations=20,
             use_history=True,
         )
 

mcp_agent/resources/examples/workflows/orchestrator.py

@@ -43,8 +43,11 @@ fast = FastAgent("Orchestrator-Workers")
     model="gpt-4.1",
 )
 # Define the orchestrator to coordinate the other agents
-@fast.orchestrator(
-    name="orchestrate", agents=["finder", "writer", "proofreader"], plan_type="full", model="sonnet"
+@fast.iterative_planner(
+    name="orchestrate",
+    agents=["finder", "writer", "proofreader"],
+    model="sonnet",
+    plan_iterations=5,
 )
 async def main() -> None:
     async with fast.run() as agent:

mcp_agent/ui/console_display.py

@@ -7,6 +7,11 @@ from rich.panel import Panel
 from rich.text import Text
 
 from mcp_agent import console
+from mcp_agent.core.mermaid_utils import (
+    create_mermaid_live_link,
+    detect_diagram_type,
+    extract_mermaid_diagrams,
+)
 from mcp_agent.mcp.common import SEP
 from mcp_agent.mcp.mcp_aggregator import MCPAggregator
 
@@ -158,29 +163,29 @@ class ConsoleDisplay:
                 content = content[:360] + "..."
             console.console.print(content, style="dim", markup=self._markup)
 
-        # Bottom separator with tool list: ─ [tool1] [tool2] ────────
+        # Bottom separator with tool list using pipe separators (matching server style)
         console.console.print()
+
+        # Use existing tool list formatting with pipe separators
         if display_tool_list and len(display_tool_list) > 0:
-            # Truncate tool list if needed (leave space for "─ " prefix and some separator)
+            # Truncate tool list if needed (leave space for "─| " prefix and " |" suffix)
             max_tool_width = console.console.size.width - 10  # Reserve space for separators
             truncated_tool_list = self._truncate_list_if_needed(display_tool_list, max_tool_width)
-            tool_width = truncated_tool_list.cell_len
-
-            # Calculate how much space is left for separator line on the right
-            total_width = console.console.size.width
-            remaining_width = max(0, total_width - tool_width - 2)  # -2 for "─ " prefix
-            right_sep = "─" * remaining_width if remaining_width > 0 else ""
-
-            # Create the separator line: ─ [tools] ────────
-            combined = Text()
-            combined.append("─ ", style="dim")
-            combined.append_text(truncated_tool_list)
-            combined.append(right_sep, style="dim")
 
-            console.console.print(combined, markup=self._markup)
+            # Create the separator line: ─| [tools] |──────
+            line1 = Text()
+            line1.append("─| ", style="dim")
+            line1.append_text(truncated_tool_list)
+            line1.append(" |", style="dim")
+            remaining = console.console.size.width - line1.cell_len
+            if remaining > 0:
+                line1.append("─" * remaining, style="dim")
         else:
-            # Full separator if no tools
-            console.console.print("─" * console.console.size.width, style="dim")
+            # No tools - continuous bar
+            line1 = Text()
+            line1.append("─" * console.console.size.width, style="dim")
+
+        console.console.print(line1, markup=self._markup)
         console.console.print()
 
     async def show_tool_update(self, aggregator: MCPAggregator | None, updated_server: str) -> None:
@@ -224,6 +229,8 @@ class ConsoleDisplay:
     def _format_tool_list(self, available_tools, selected_tool_name):
         """Format the list of available tools, highlighting the selected one."""
         display_tool_list = Text()
+        matching_tools = []
+
         for display_tool in available_tools:
             # Handle both OpenAI and Anthropic tool formats
             if isinstance(display_tool, dict):
@@ -248,9 +255,15 @@ class ConsoleDisplay:
             )
 
             if selected_tool_name.split(SEP)[0] == parts[0]:
-                style = "magenta" if tool_call_name == selected_tool_name else "dim white"
                 shortened_name = parts[1] if len(parts[1]) <= 12 else parts[1][:11] + "…"
-                display_tool_list.append(f"[{shortened_name}] ", style)
+                matching_tools.append((shortened_name, tool_call_name))
+
+        # Format with pipe separators instead of brackets
+        for i, (shortened_name, tool_call_name) in enumerate(matching_tools):
+            if i > 0:
+                display_tool_list.append(" | ", style="dim")
+            style = "magenta" if tool_call_name == selected_tool_name else "dim"
+            display_tool_list.append(shortened_name, style)
 
         return display_tool_list
 
@@ -379,31 +392,83 @@ class ConsoleDisplay:
             # Handle Rich Text objects directly
             console.console.print(message_text, markup=self._markup)
 
-        # Bottom separator with server list: ─ [server1] [server2] ────────
+        # Bottom separator with server list and diagrams
         console.console.print()
+
+        # Check for mermaid diagrams in the message content
+        diagrams = []
+        if isinstance(message_text, str):
+            diagrams = extract_mermaid_diagrams(message_text)
+
+        # Create server list with pipe separators (no "mcp:" prefix)
+        server_content = Text()
         if display_server_list and len(display_server_list) > 0:
-            # Truncate server list if needed (leave space for "─ " prefix and some separator)
-            max_server_width = console.console.size.width - 10  # Reserve space for separators
-            truncated_server_list = self._truncate_list_if_needed(
-                display_server_list, max_server_width
-            )
-            server_width = truncated_server_list.cell_len
+            # Convert the existing server list to pipe-separated format
+            servers = []
+            if aggregator:
+                for server_name in await aggregator.list_servers():
+                    servers.append(server_name)
+
+            # Create pipe-separated server list
+            for i, server_name in enumerate(servers):
+                if i > 0:
+                    server_content.append(" | ", style="dim")
+                # Highlight active server, dim inactive ones
+                mcp_server_name = (
+                    highlight_namespaced_tool.split(SEP)[0]
+                    if SEP in highlight_namespaced_tool
+                    else highlight_namespaced_tool
+                )
+                style = "bright_green" if server_name == mcp_server_name else "dim"
+                server_content.append(server_name, style)
+
+        # Create main separator line
+        line1 = Text()
+        if server_content.cell_len > 0:
+            line1.append("─| ", style="dim")
+            line1.append_text(server_content)
+            line1.append(" |", style="dim")
+            remaining = console.console.size.width - line1.cell_len
+            if remaining > 0:
+                line1.append("─" * remaining, style="dim")
+        else:
+            # No servers - continuous bar (no break)
+            line1.append("─" * console.console.size.width, style="dim")
 
-            # Calculate how much space is left for separator line on the right
-            total_width = console.console.size.width
-            remaining_width = max(0, total_width - server_width - 2)  # -2 for "─ " prefix
-            right_sep = "─" * remaining_width if remaining_width > 0 else ""
+        console.console.print(line1, markup=self._markup)
 
-            # Create the separator line: ─ [servers] ────────
-            combined = Text()
-            combined.append("─ ", style="dim")
-            combined.append_text(truncated_server_list)
-            combined.append(right_sep, style="dim")
+        # Add diagram links in panel if any diagrams found
+        if diagrams:
+            diagram_content = Text()
+            # Add bullet at the beginning
+            diagram_content.append("● ", style="dim")
+
+            for i, diagram in enumerate(diagrams, 1):
+                if i > 1:
+                    diagram_content.append(" • ", style="dim")
+
+                # Generate URL
+                url = create_mermaid_live_link(diagram.content)
+
+                # Format: "1 - Title" or "1 - Flowchart" or "Diagram 1"
+                if diagram.title:
+                    diagram_content.append(
+                        f"{i} - {diagram.title}", style=f"bright_blue link {url}"
+                    )
+                else:
+                    # Try to detect diagram type, fallback to "Diagram N"
+                    diagram_type = detect_diagram_type(diagram.content)
+                    if diagram_type != "Diagram":
+                        diagram_content.append(
+                            f"{i} - {diagram_type}", style=f"bright_blue link {url}"
+                        )
+                    else:
+                        diagram_content.append(f"Diagram {i}", style=f"bright_blue link {url}")
+
+            # Display diagrams on a simple new line (more space efficient)
+            console.console.print()
+            console.console.print(diagram_content, markup=self._markup)
 
-            console.console.print(combined, markup=self._markup)
-        else:
-            # Full separator if no servers
-            console.console.print("─" * console.console.size.width, style="dim")
         console.console.print()
 
     def show_user_message(