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

mcp_agent/cli/commands/go.py

@@ -19,7 +19,7 @@ app = typer.Typer(
 
 
 async def _run_agent(
-    name: str = "FastAgent CLI",
+    name: str = "fast-agent cli",
     instruction: str = "You are a helpful AI Agent.",
     config_path: Optional[str] = None,
     server_list: Optional[List[str]] = None,
@@ -28,6 +28,7 @@ async def _run_agent(
     prompt_file: Optional[str] = None,
     url_servers: Optional[Dict[str, Dict[str, str]]] = None,
     stdio_servers: Optional[Dict[str, Dict[str, str]]] = None,
+    agent_name: Optional[str] = "agent",
 ) -> None:
     """Async implementation to run an interactive agent."""
     from pathlib import Path
@@ -35,6 +36,7 @@ async def _run_agent(
     from mcp_agent.mcp.prompts.prompt_load import load_prompt_multipart
 
     # Create the FastAgent instance
+
     fast_kwargs = {
         "name": name,
         "config_path": config_path,
@@ -103,6 +105,8 @@ async def _run_agent(
         # Single model - use original behavior
         # Define the agent with specified parameters
         agent_kwargs = {"instruction": instruction}
+        if agent_name:
+            agent_kwargs["name"] = agent_name
         if server_list:
             agent_kwargs["servers"] = server_list
         if model:
@@ -117,7 +121,7 @@ async def _run_agent(
                     print(response)
                 elif prompt_file:
                     prompt = load_prompt_multipart(Path(prompt_file))
-                    response = await agent.default.generate(prompt)
+                    response = await agent.generate(prompt)
                     # Print the response text and exit
                     print(response.last_text())
                 else:
@@ -138,6 +142,7 @@ def run_async_agent(
     message: Optional[str] = None,
     prompt_file: Optional[str] = None,
     stdio_commands: Optional[List[str]] = None,
+    agent_name: Optional[str] = None,
 ):
     """Run the async agent function with proper loop handling."""
     server_list = servers.split(",") if servers else None
@@ -237,6 +242,7 @@ def run_async_agent(
                 prompt_file=prompt_file,
                 url_servers=url_servers,
                 stdio_servers=stdio_servers,
+                agent_name=agent_name,
             )
         )
     finally:
@@ -258,7 +264,7 @@ def run_async_agent(
 @app.callback(invoke_without_command=True, no_args_is_help=False)
 def go(
     ctx: typer.Context,
-    name: str = typer.Option("FastAgent CLI", "--name", help="Name for the agent"),
+    name: str = typer.Option("fast-agent", "--name", help="Name for the agent"),
     instruction: Optional[str] = typer.Option(
         None, "--instruction", "-i", help="Path to file or URL containing instruction for the agent"
     ),
@@ -338,6 +344,8 @@ def go(
 
     # Resolve instruction from file/URL or use default
     resolved_instruction = "You are a helpful AI Agent."  # Default
+    agent_name = "agent"
+
     if instruction:
         try:
             from pathlib import Path
@@ -352,6 +360,11 @@ def go(
             else:
                 # Treat as file path
                 resolved_instruction = _resolve_instruction(Path(instruction))
+                # Extract filename without extension to use as agent name
+                instruction_path = Path(instruction)
+                if instruction_path.exists() and instruction_path.is_file():
+                    # Get filename without extension
+                    agent_name = instruction_path.stem
         except Exception as e:
             typer.echo(f"Error loading instruction from {instruction}: {e}", err=True)
             raise typer.Exit(1)
@@ -367,4 +380,5 @@ def go(
         message=message,
         prompt_file=prompt_file,
         stdio_commands=stdio_commands,
+        agent_name=agent_name,
     )

mcp_agent/cli/main.py

@@ -8,7 +8,7 @@ from mcp_agent.cli.commands import check_config, go, quickstart, setup
 from mcp_agent.cli.terminal import Application
 
 app = typer.Typer(
-    help="FastAgent CLI - Build effective agents using Model Context Protocol",
+    help="fast-agent - Build effective agents using Model Context Protocol",
     add_completion=False,  # We'll add this later when we have more commands
 )
 
@@ -60,7 +60,7 @@ def main(
     color: bool = typer.Option(True, "--color/--no-color", help="Enable/disable color output"),
     version: bool = typer.Option(False, "--version", help="Show version and exit"),
 ) -> None:
-    """FastAgent CLI - Build effective agents using Model Context Protocol (MCP).
+    """fast-agent - Build effective agents using Model Context Protocol (MCP).
 
     Use --help with any command for detailed usage information.
     """

mcp_agent/config.py

@@ -224,6 +224,17 @@ class AzureSettings(BaseModel):
     model_config = ConfigDict(extra="allow", arbitrary_types_allowed=True)
 
 
+class GroqSettings(BaseModel):
+    """
+    Settings for using xAI Grok models in the fast-agent application.
+    """
+
+    api_key: str | None = None
+    base_url: str | None = "https://api.groq.com/openai/v1"
+
+    model_config = ConfigDict(extra="allow", arbitrary_types_allowed=True)
+
+
 class OpenTelemetrySettings(BaseModel):
     """
     OTEL settings for the fast-agent application.
@@ -441,6 +452,9 @@ class Settings(BaseSettings):
     huggingface: HuggingFaceSettings | None = None
     """Settings for HuggingFace authentication (used for MCP connections)"""
 
+    groq: GroqSettings | None = None
+    """Settings for using the Groq provider in the fast-agent application"""
+
     logger: LoggerSettings | None = LoggerSettings()
     """Logger settings for the fast-agent application"""
 

mcp_agent/core/agent_types.py

@@ -22,6 +22,7 @@ class AgentType(Enum):
     EVALUATOR_OPTIMIZER = "evaluator_optimizer"
     ROUTER = "router"
     CHAIN = "chain"
+    ITERATIVE_PLANNER = "iterative_planner"
 
 
 @dataclass

mcp_agent/core/direct_decorators.py

@@ -25,6 +25,7 @@ from mcp.client.session import ElicitationFnT
 from pydantic import AnyUrl
 
 from mcp_agent.agents.agent import AgentConfig
+from mcp_agent.agents.workflow.iterative_planner import ITERATIVE_PLAN_SYSTEM_PROMPT_TEMPLATE
 from mcp_agent.agents.workflow.router_agent import (
     ROUTING_SYSTEM_INSTRUCTION,
 )
@@ -457,6 +458,59 @@ def orchestrator(
     )
 
 
+def iterative_planner(
+    self,
+    name: str,
+    *,
+    agents: List[str],
+    instruction: str | Path | AnyUrl = ITERATIVE_PLAN_SYSTEM_PROMPT_TEMPLATE,
+    model: Optional[str] = None,
+    request_params: RequestParams | None = None,
+    plan_iterations: int = -1,
+    default: bool = False,
+    api_key: str | None = None,
+) -> Callable[[AgentCallable[P, R]], DecoratedOrchestratorProtocol[P, R]]:
+    """
+    Decorator to create and register an orchestrator agent with type-safe signature.
+
+    Args:
+        name: Name of the orchestrator
+        agents: List of agent names this orchestrator can use
+        instruction: Base instruction for the orchestrator
+        model: Model specification string
+        use_history: Whether to maintain conversation history
+        request_params: Additional request parameters for the LLM
+        human_input: Whether to enable human input capabilities
+        plan_type: Planning approach - "full" or "iterative"
+        plan_iterations: Maximum number of planning iterations (0 for unlimited)
+        default: Whether to mark this as the default agent
+
+    Returns:
+        A decorator that registers the orchestrator with proper type annotations
+    """
+
+    # Create final request params with plan_iterations
+    resolved_instruction = _resolve_instruction(instruction)
+
+    return cast(
+        "Callable[[AgentCallable[P, R]], DecoratedOrchestratorProtocol[P, R]]",
+        _decorator_impl(
+            self,
+            AgentType.ITERATIVE_PLANNER,
+            name=name,
+            instruction=resolved_instruction,
+            servers=[],  # Orchestrators don't connect to servers directly
+            model=model,
+            use_history=False,
+            request_params=request_params,
+            child_agents=agents,
+            plan_iterations=plan_iterations,
+            default=default,
+            api_key=api_key,
+        ),
+    )
+
+
 def router(
     self,
     name: str,

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

@@ -129,16 +129,16 @@ class ModelDatabase:
         context_window=2097152, max_output_tokens=8192, tokenizes=GOOGLE_MULTIMODAL
     )
 
-    # 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
+    KIMI_MOONSHOT = ModelParameters(
+        context_window=131072, max_output_tokens=16384, tokenizes=TEXT_ONLY
     )
 
+    # 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)
+
     # 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 +193,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,
@@ -214,6 +213,7 @@ class ModelDatabase:
         "grok-3-mini": GROK_3,
         "grok-3-fast": GROK_3,
         "grok-3-mini-fast": GROK_3,
+        "moonshotai/kimi-k2-instruct": KIMI_MOONSHOT,
     }
 
     @classmethod

mcp_agent/llm/model_factory.py

@@ -19,6 +19,7 @@ from mcp_agent.llm.providers.augmented_llm_deepseek import DeepSeekAugmentedLLM
 from mcp_agent.llm.providers.augmented_llm_generic import GenericAugmentedLLM
 from mcp_agent.llm.providers.augmented_llm_google_native import GoogleNativeAugmentedLLM
 from mcp_agent.llm.providers.augmented_llm_google_oai import GoogleOaiAugmentedLLM
+from mcp_agent.llm.providers.augmented_llm_groq import GroqAugmentedLLM
 from mcp_agent.llm.providers.augmented_llm_openai import OpenAIAugmentedLLM
 from mcp_agent.llm.providers.augmented_llm_openrouter import OpenRouterAugmentedLLM
 from mcp_agent.llm.providers.augmented_llm_tensorzero import TensorZeroAugmentedLLM
@@ -43,6 +44,7 @@ LLMClass = Union[
     Type[GenericAugmentedLLM],
     Type[AzureOpenAIAugmentedLLM],
     Type[BedrockAugmentedLLM],
+    Type[GroqAugmentedLLM],
 ]
 
 
@@ -122,7 +124,6 @@ class ModelFactory:
         "qwen-plus": Provider.ALIYUN,
         "qwen-max": Provider.ALIYUN,
         "qwen-long": Provider.ALIYUN,
-
     }
 
     MODEL_ALIASES = {
@@ -159,6 +160,7 @@ class ModelFactory:
         Provider.AZURE: AzureOpenAIAugmentedLLM,
         Provider.ALIYUN: AliyunAugmentedLLM,
         Provider.BEDROCK: BedrockAugmentedLLM,
+        Provider.GROQ: GroqAugmentedLLM,
     }
 
     # Mapping of special model names to their specific LLM classes
@@ -213,11 +215,11 @@ class ModelFactory:
         # If provider still None, try to get from DEFAULT_PROVIDERS using the model_name_str
         if provider is None:
             provider = cls.DEFAULT_PROVIDERS.get(model_name_str)
-            
+
             # If still None, try pattern matching for Bedrock models
             if provider is None and BedrockAugmentedLLM.matches_model_pattern(model_name_str):
                 provider = Provider.BEDROCK
-            
+
             if provider is None:
                 raise ModelConfigError(
                     f"Unknown model or provider for: {model_string}. Model name parsed as '{model_name_str}'"

mcp_agent/llm/provider_types.py

@@ -28,3 +28,4 @@ class Provider(Enum):
     HUGGINGFACE = ("huggingface", "HuggingFace")  # For HuggingFace MCP connections
     XAI = ("xai", "XAI")  # For xAI Grok models
     BEDROCK = ("bedrock", "Bedrock")
+    GROQ = ("groq", "Groq")

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,
         )