fast-agent-mcp 0.2.47__tar.gz → 0.2.49__tar.gz

{fast_agent_mcp-0.2.47 → fast_agent_mcp-0.2.49}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fast-agent-mcp
-Version: 0.2.47
+Version: 0.2.49
 Summary: Define, Prompt and Test MCP enabled Agents and Workflows
 Author-email: Shaun Smith <fastagent@llmindset.co.uk>
 License:                                  Apache License

{fast_agent_mcp-0.2.47 → fast_agent_mcp-0.2.49}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fast-agent-mcp"
-version = "0.2.47"
+version = "0.2.49"
 description = "Define, Prompt and Test MCP enabled Agents and Workflows"
 readme = "README.md"
 license = { file = "LICENSE" }

{fast_agent_mcp-0.2.47 → fast_agent_mcp-0.2.49}/src/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,
     )

{fast_agent_mcp-0.2.47 → fast_agent_mcp-0.2.49}/src/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.
     """

{fast_agent_mcp-0.2.47 → fast_agent_mcp-0.2.49}/src/mcp_agent/config.py

@@ -8,6 +8,7 @@ import re
 from pathlib import Path
 from typing import Any, Dict, List, Literal, Optional, Tuple
 
+from mcp import Implementation
 from pydantic import BaseModel, ConfigDict, field_validator
 from pydantic_settings import BaseSettings, SettingsConfigDict
 
@@ -61,11 +62,9 @@ class MCPServerSettings(BaseModel):
     Represents the configuration for an individual server.
     """
 
-    # TODO: saqadri - server name should be something a server can provide itself during initialization
     name: str | None = None
     """The name of the server."""
 
-    # TODO: saqadri - server description should be something a server can provide itself during initialization
     description: str | None = None
     """The description of the server."""
 
@@ -108,6 +107,8 @@ class MCPServerSettings(BaseModel):
     cwd: str | None = None
     """Working directory for the executed server command."""
 
+    implementation: Implementation | None = None
+
 
 class MCPSettings(BaseModel):
     """Configuration for all MCP servers."""
@@ -224,6 +225,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 +453,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"""
 

{fast_agent_mcp-0.2.47 → fast_agent_mcp-0.2.49}/src/mcp_agent/llm/model_database.py

@@ -129,6 +129,10 @@ class ModelDatabase:
         context_window=2097152, max_output_tokens=8192, tokenizes=GOOGLE_MULTIMODAL
     )
 
+    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)
 
@@ -209,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

{fast_agent_mcp-0.2.47 → fast_agent_mcp-0.2.49}/src/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 = {
@@ -142,6 +143,7 @@ class ModelFactory:
         "gemini2": "gemini-2.0-flash",
         "gemini25": "gemini-2.5-flash-preview-05-20",
         "gemini25pro": "gemini-2.5-pro-preview-05-06",
+        "kimi": "groq.moonshotai/kimi-k2-instruct",
     }
 
     # Mapping of providers to their LLM classes
@@ -159,6 +161,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 +216,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}'"

{fast_agent_mcp-0.2.47 → fast_agent_mcp-0.2.49}/src/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")

{fast_agent_mcp-0.2.47 → fast_agent_mcp-0.2.49}/src/mcp_agent/llm/providers/augmented_llm_azure.py

@@ -18,7 +18,7 @@ def _extract_resource_name(url: str) -> str | None:
     return host.replace(suffix, "") if host.endswith(suffix) else None
 
 
-DEFAULT_AZURE_API_VERSION = "2023-05-15"
+DEFAULT_AZURE_API_VERSION = "2024-10-21"
 
 
 class AzureOpenAIAugmentedLLM(OpenAIAugmentedLLM):

fast_agent_mcp-0.2.49/src/mcp_agent/llm/providers/augmented_llm_groq.py

@@ -0,0 +1,30 @@
+from mcp_agent.core.request_params import RequestParams
+from mcp_agent.llm.provider_types import Provider
+from mcp_agent.llm.providers.augmented_llm_openai import OpenAIAugmentedLLM
+
+GROQ_BASE_URL = "https://api.groq.com/openai/v1"
+DEFAULT_GROQ_MODEL = ""
+
+
+class GroqAugmentedLLM(OpenAIAugmentedLLM):
+    def __init__(self, *args, **kwargs) -> None:
+        super().__init__(*args, provider=Provider.GROQ, **kwargs)
+
+    def _initialize_default_params(self, kwargs: dict) -> RequestParams:
+        """Initialize Groq default parameters"""
+        chosen_model = kwargs.get("model", DEFAULT_GROQ_MODEL)
+
+        return RequestParams(
+            model=chosen_model,
+            systemPrompt=self.instruction,
+            parallel_tool_calls=False,
+            max_iterations=20,
+            use_history=True,
+        )
+
+    def _base_url(self) -> str:
+        base_url = None
+        if self.context.config and self.context.config.groq:
+            base_url = self.context.config.groq.base_url
+
+        return base_url if base_url else GROQ_BASE_URL

{fast_agent_mcp-0.2.47 → fast_agent_mcp-0.2.49}/src/mcp_agent/llm/providers/augmented_llm_openai.py

@@ -388,7 +388,10 @@ class OpenAIAugmentedLLM(AugmentedLLM[ChatCompletionMessageParam, ChatCompletion
 
             # ParsedChatCompletionMessage is compatible with ChatCompletionMessage
             # since it inherits from it, so we can use it directly
-            messages.append(message)
+            # Convert to dict and remove None values
+            message_dict = message.model_dump()
+            message_dict = {k: v for k, v in message_dict.items() if v is not None}
+            messages.append(message_dict)
 
             message_text = message.content
             if await self._is_tool_stop_reason(choice.finish_reason) and message.tool_calls:
@@ -409,7 +412,9 @@ class OpenAIAugmentedLLM(AugmentedLLM[ChatCompletionMessageParam, ChatCompletion
                     )
 
                 tool_results = []
+                
                 for tool_call in message.tool_calls:
+                    
                     self.show_tool_call(
                         available_tools,
                         tool_call.function.name,
@@ -425,12 +430,20 @@ class OpenAIAugmentedLLM(AugmentedLLM[ChatCompletionMessageParam, ChatCompletion
                             else from_json(tool_call.function.arguments, allow_partial=True),
                         ),
                     )
-                    result = await self.call_tool(tool_call_request, tool_call.id)
-                    self.show_tool_result(result)
-
-                    tool_results.append((tool_call.id, result))
-                    responses.extend(result.content)
-                messages.extend(OpenAIConverter.convert_function_results_to_openai(tool_results))
+                    
+                    try:
+                        result = await self.call_tool(tool_call_request, tool_call.id)
+                        self.show_tool_result(result)
+                        tool_results.append((tool_call.id, result))
+                        responses.extend(result.content)
+                    except Exception as e:
+                        self.logger.error(f"Tool call {tool_call.id} failed with error: {e}")
+                        # Still add the tool_call_id with an error result to prevent missing responses
+                        error_result = CallToolResult(content=[TextContent(type="text", text=f"Tool call failed: {str(e)}")])
+                        tool_results.append((tool_call.id, error_result))
+                
+                converted_messages = OpenAIConverter.convert_function_results_to_openai(tool_results)
+                messages.extend(converted_messages)
 
                 self.logger.debug(
                     f"Iteration {i}: Tool call results: {str(tool_results) if tool_results else 'None'}"

{fast_agent_mcp-0.2.47 → fast_agent_mcp-0.2.49}/src/mcp_agent/llm/providers/multipart_converter_openai.py

@@ -441,9 +441,6 @@ class OpenAIConverter:
         # Convert to OpenAI format
         user_message = OpenAIConverter.convert_to_openai(non_text_multipart)
 
-        # We need to add tool_call_id manually
-        user_message["tool_call_id"] = tool_call_id
-
         return (tool_message, [user_message])
 
     @staticmethod
@@ -461,22 +458,42 @@ class OpenAIConverter:
         Returns:
             List of OpenAI API messages for tool responses
         """
-        messages = []
+        tool_messages = []
+        user_messages = []
+        has_mixed_content = False
 
         for tool_call_id, result in results:
-            converted = OpenAIConverter.convert_tool_result_to_openai(
-                tool_result=result,
-                tool_call_id=tool_call_id,
-                concatenate_text_blocks=concatenate_text_blocks,
-            )
-
-            # Handle the case where we have mixed content and get back a tuple
-            if isinstance(converted, tuple):
-                tool_message, additional_messages = converted
-                messages.append(tool_message)
-                messages.extend(additional_messages)
-            else:
-                # Single message case (text-only)
-                messages.append(converted)
+            try:
+                converted = OpenAIConverter.convert_tool_result_to_openai(
+                    tool_result=result,
+                    tool_call_id=tool_call_id,
+                    concatenate_text_blocks=concatenate_text_blocks,
+                )
 
+                # Handle the case where we have mixed content and get back a tuple
+                if isinstance(converted, tuple):
+                    tool_message, additional_messages = converted
+                    tool_messages.append(tool_message)
+                    user_messages.extend(additional_messages)
+                    has_mixed_content = True
+                else:
+                    # Single message case (text-only)
+                    tool_messages.append(converted)
+            except Exception as e:
+                _logger.error(f"Failed to convert tool_call_id={tool_call_id}: {e}")
+                # Create a basic tool response to prevent missing tool_call_id error
+                fallback_message = {
+                    "role": "tool",
+                    "tool_call_id": tool_call_id,
+                    "content": f"[Conversion error: {str(e)}]",
+                }
+                tool_messages.append(fallback_message)
+
+        # CONDITIONAL REORDERING: Only reorder if there are user messages (mixed content)
+        if has_mixed_content and user_messages:
+            # Reorder: All tool messages first (OpenAI sequence), then user messages (vision context)
+            messages = tool_messages + user_messages
+        else:
+            # Pure tool responses - keep original order to preserve context (snapshots, etc.)
+            messages = tool_messages
         return messages

{fast_agent_mcp-0.2.47 → fast_agent_mcp-0.2.49}/src/mcp_agent/logging/rich_progress.py

@@ -21,7 +21,7 @@ class RichProgressDisplay:
         self._progress = Progress(
             SpinnerColumn(spinner_name="simpleDotsScrolling"),
             TextColumn(
-                "[progress.description]{task.description}|",
+                "[progress.description]{task.description}▎",
                 #                table_column=Column(max_width=16),
             ),
             TextColumn(text_format="{task.fields[target]:<16}", style="Bold Blue"),
@@ -77,7 +77,7 @@ class RichProgressDisplay:
             ProgressAction.LOADED: "dim green",
             ProgressAction.INITIALIZED: "dim green",
             ProgressAction.CHATTING: "bold blue",
-            ProgressAction.STREAMING: "bold blue",  # Same color as chatting
+            ProgressAction.STREAMING: "bold green",  # Assistant Colour
             ProgressAction.ROUTING: "bold blue",
             ProgressAction.PLANNING: "bold blue",
             ProgressAction.READY: "dim green",
@@ -107,10 +107,19 @@ class RichProgressDisplay:
         # Ensure no None values in the update
         # For streaming, use custom description immediately to avoid flashing
         if event.action == ProgressAction.STREAMING and event.streaming_tokens:
-            formatted_tokens = f"↓ {event.streaming_tokens.strip()}".ljust(15)
+            # Account for [dim][/dim] tags (11 characters) in padding calculation
+            formatted_tokens = f"▎[dim]◀[/dim] {event.streaming_tokens.strip()}".ljust(17 + 11)
             description = f"[{self._get_action_style(event.action)}]{formatted_tokens}"
+        elif event.action == ProgressAction.CHATTING:
+            # Add special formatting for chatting with dimmed arrow
+            formatted_text = f"▎[dim]▶[/dim] {event.action.value.strip()}".ljust(17 + 11)
+            description = f"[{self._get_action_style(event.action)}]{formatted_text}"
+        elif event.action == ProgressAction.CALLING_TOOL:
+            # Add special formatting for calling tool with dimmed arrow
+            formatted_text = f"▎[dim]◀[/dim] {event.action.value}".ljust(17 + 11)
+            description = f"[{self._get_action_style(event.action)}]{formatted_text}"
         else:
-            description = f"[{self._get_action_style(event.action)}]{event.action.value:<15}"
+            description = f"[{self._get_action_style(event.action)}]▎ {event.action.value:<15}"
 
         self._progress.update(
             task_id,

{fast_agent_mcp-0.2.47 → fast_agent_mcp-0.2.49}/src/mcp_agent/mcp/mcp_agent_client_session.py

@@ -66,9 +66,6 @@ class MCPAgentClientSession(ClientSession, ContextDependent):
         # Extract server_name if provided in kwargs
         from importlib.metadata import version
 
-        version = version("fast-agent-mcp") or "dev"
-        fast_agent: Implementation = Implementation(name="fast-agent-mcp", version=version)
-
         self.session_server_name = kwargs.pop("server_name", None)
         # Extract the notification callbacks if provided
         self._tool_list_changed_callback = kwargs.pop("tool_list_changed_callback", None)
@@ -83,6 +80,11 @@ class MCPAgentClientSession(ClientSession, ContextDependent):
         # Extract custom elicitation handler if provided
         custom_elicitation_handler = kwargs.pop("elicitation_handler", None)
 
+        version = version("fast-agent-mcp") or "dev"
+        fast_agent: Implementation = Implementation(name="fast-agent-mcp", version=version)
+        if self.server_config and self.server_config.implementation:
+            fast_agent = self.server_config.implementation
+
         # Only register callbacks if the server_config has the relevant settings
         list_roots_cb = list_roots if (self.server_config and self.server_config.roots) else None