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

{fast_agent_mcp-0.2.48.dist-info → fast_agent_mcp-0.2.50.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fast-agent-mcp
-Version: 0.2.48
+Version: 0.2.50
 Summary: Define, Prompt and Test MCP enabled Agents and Workflows
 Author-email: Shaun Smith <fastagent@llmindset.co.uk>
 License:                                  Apache License
@@ -208,8 +208,8 @@ License-File: LICENSE
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
-Requires-Python: >=3.12
-Requires-Dist: a2a-sdk>=0.2.9
+Requires-Python: >=3.13
+Requires-Dist: a2a-sdk>=0.3.0
 Requires-Dist: aiohttp>=3.11.13
 Requires-Dist: anthropic>=0.59.0
 Requires-Dist: azure-identity>=1.14.0
@@ -232,7 +232,7 @@ Requires-Dist: pydantic>=2.10.4
 Requires-Dist: pyperclip>=1.9.0
 Requires-Dist: pyyaml>=6.0.2
 Requires-Dist: rich>=14.1.0
-Requires-Dist: tensorzero>=2025.6.3
+Requires-Dist: tensorzero>=2025.7.5
 Requires-Dist: typer>=0.15.1
 Provides-Extra: azure
 Requires-Dist: azure-identity>=1.14.0; extra == 'azure'

{fast_agent_mcp-0.2.48.dist-info → fast_agent_mcp-0.2.50.dist-info}/RECORD

@@ -1,10 +1,10 @@
 mcp_agent/__init__.py,sha256=HWWxZeB-VxrUNNXZnu4duzKGwdfCdD2M_O6drN4kfs8,2389
 mcp_agent/app.py,sha256=3mtHP1nRQcRaKhhxgTmCOv00alh70nT7UxNA8bN47QE,5560
-mcp_agent/config.py,sha256=GBmdsNlW8YqL8Dp-6Ke4ufQkFuLiaUSq_b8mciQ6sOQ,19382
+mcp_agent/config.py,sha256=uwfZIdnO4NpYF90uQjOvwhgh4GqYnVfkqCahhN5jZHc,19248
 mcp_agent/console.py,sha256=Gjf2QLFumwG1Lav__c07X_kZxxEUSkzV-1_-YbAwcwo,813
 mcp_agent/context.py,sha256=lzz_Fyf9lz9BBAUt1bRVBlyyHjLkyeuyIziAi4qXYUk,7639
 mcp_agent/context_dependent.py,sha256=QXfhw3RaQCKfscEEBRGuZ3sdMWqkgShz2jJ1ivGGX1I,1455
-mcp_agent/event_progress.py,sha256=d7T1hQ1D289MYh2Z5bMPB4JqjGqTOzveJuOHE03B_Xo,3720
+mcp_agent/event_progress.py,sha256=EdozJ6a13Ur_zMMbPx-1pKwsLEbHF0bwCEcErhxLCew,4513
 mcp_agent/mcp_server_registry.py,sha256=lmz-aES-l7Gbg4itDF0iCmpso_KD8bVazVKSVzjwNE4,12398
 mcp_agent/progress_display.py,sha256=GeJU9VUt6qKsFVymG688hCMVCsAygG9ifiiEb5IcbN4,361
 mcp_agent/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -67,8 +67,8 @@ mcp_agent/llm/augmented_llm_playback.py,sha256=rLzgai496e2RlxqQp_Bp0U-Y1FF1SGsWl
 mcp_agent/llm/augmented_llm_silent.py,sha256=IUnK_1Byy4D9TG0Pj46LFeNezgSTQ8d6MQIHWAImBwE,1846
 mcp_agent/llm/augmented_llm_slow.py,sha256=DDSD8bL2flmQrVHZm-UDs7sR8aHRWkDOcOW-mX_GPok,2067
 mcp_agent/llm/memory.py,sha256=pTOaTDV3EA3X68yKwEtUAu7s0xGIQQ_cKBhfYUnfR0w,8614
-mcp_agent/llm/model_database.py,sha256=7puiFtc1tH25M5JEnKdAxsEk9OeAMJHamXA1c37tdjw,9490
-mcp_agent/llm/model_factory.py,sha256=2Ii81GrFJ9FvyjVb4OUyb0FRT59iAi9Vido5v0kZa7w,11732
+mcp_agent/llm/model_database.py,sha256=7G_rAXRE2RFrly_2PRr5uji7fT0XqaWj_RwhpZVx1LU,10690
+mcp_agent/llm/model_factory.py,sha256=WyuQm0hETOxECA9pjCm-Oo5Oh28186nsSWmjSntw2SE,11784
 mcp_agent/llm/prompt_utils.py,sha256=yWQHykoK13QRF7evHUKxVF0SpVLN-Bsft0Yixzvn0g0,4825
 mcp_agent/llm/provider_key_manager.py,sha256=LSWIgcXlrUS4sfBvQBCya82qC6NcXQPYLtDHwHNOXR4,3394
 mcp_agent/llm/provider_types.py,sha256=LfuVuFjcM_lMED0lkrNfKK8s8Fs1vbxugQsrcBE2CIY,1119
@@ -77,22 +77,22 @@ mcp_agent/llm/sampling_format_converter.py,sha256=xGz4odHpOcP7--eFaJaFtUR8eR9jxZ
 mcp_agent/llm/usage_tracking.py,sha256=rF6v8QQDam8QbvlP4jzHljKqvuNHExeYDLkUMI86czY,16073
 mcp_agent/llm/providers/__init__.py,sha256=heVxtmuqFJOnjjxHz4bWSqTAxXoN1E8twC_gQ_yJpHk,265
 mcp_agent/llm/providers/anthropic_utils.py,sha256=vYDN5G5jKMhD2CQg8veJYab7tvvzYkDMq8M1g_hUAQg,3275
-mcp_agent/llm/providers/augmented_llm_aliyun.py,sha256=TwqSQmRwnce_a904CSqsKWTzYRb-od8FFYlie2zwXcE,1101
+mcp_agent/llm/providers/augmented_llm_aliyun.py,sha256=JlRfhohIQQlo5RgM1B2t4ITLC9dok8LQNKLf0BK8Ai8,1158
 mcp_agent/llm/providers/augmented_llm_anthropic.py,sha256=U8znA9HSCOx4FlhIjl-J29nbYc8Y-T6BXevtXuDafio,30352
-mcp_agent/llm/providers/augmented_llm_azure.py,sha256=sBVWgY88F4OsdRSHl71BAT2p3XPvuZp844z1ubwcV7U,6098
+mcp_agent/llm/providers/augmented_llm_azure.py,sha256=Xoo6dFst6L9SaGKurqptwwTUzr-sYsolZ-AFb_79puc,6098
 mcp_agent/llm/providers/augmented_llm_bedrock.py,sha256=nfby1udL07zPTOLlN_tFxd1h0JRioo2oIW7v4iP4Bnk,82267
-mcp_agent/llm/providers/augmented_llm_deepseek.py,sha256=YokCz22qzbq5DyFCzviB8L7LwO1v3FAEt3UlB2EXWMI,3818
+mcp_agent/llm/providers/augmented_llm_deepseek.py,sha256=vphkYMFyukaejBw8SkCN-MqcG9qsfXJfWKZYYtspqPY,3877
 mcp_agent/llm/providers/augmented_llm_generic.py,sha256=5Uq8ZBhcFuQTt7koP_5ykolREh2iWu8zKhNbh3pM9lQ,1210
 mcp_agent/llm/providers/augmented_llm_google_native.py,sha256=c6zczfs-Iw70j3OYELHJ4S7CRwAddkeXinex_yLMhmU,22194
 mcp_agent/llm/providers/augmented_llm_google_oai.py,sha256=g_g46h-YuxqbRZiO_dVo5zO2OkX1yx7nb6xDaQbOvWs,1137
-mcp_agent/llm/providers/augmented_llm_groq.py,sha256=MEk_1elggzIGlMIrnRP5bQ7kcBvu5jCwK0AoImkpb7c,1050
-mcp_agent/llm/providers/augmented_llm_openai.py,sha256=faleOhWV9ShJ3QW8VhaHOcQsRpYHU1W44eVk6uEcguA,24359
-mcp_agent/llm/providers/augmented_llm_openrouter.py,sha256=xKhEfjQEOnjMjbHT2Dc0ZD0_Cyx7EfFz1wA3Uh9S6Xk,2341
+mcp_agent/llm/providers/augmented_llm_groq.py,sha256=5pqWgOoEJpvL230rJekBNlmBzUegbgwYitArlXgAmY0,4424
+mcp_agent/llm/providers/augmented_llm_openai.py,sha256=veVi4NcIP5S7xiV5fZLCSRFSiQbU48xQye0z-xx7X8I,25183
+mcp_agent/llm/providers/augmented_llm_openrouter.py,sha256=m3wS83fabBOmaZJH9gQ9sFw_2TB4xTb44WCOPB-2NJ4,2001
 mcp_agent/llm/providers/augmented_llm_tensorzero.py,sha256=wxNffqdM1Psvfyya6Pmo__BZjyrek55_8iTRoH4TboI,20577
-mcp_agent/llm/providers/augmented_llm_xai.py,sha256=PpztvX26mTl2GPTCzoI24ugxlm5BPpqByHnKO19ej28,1332
+mcp_agent/llm/providers/augmented_llm_xai.py,sha256=MhlX91IUNynQ_NDknx4EQJLwg-NbR8lcHS1P4JuLOnA,1433
 mcp_agent/llm/providers/google_converter.py,sha256=xCUVw4W7lqBvJMgSKKdzW4Y00zmHBgCR6pOoWLYQQfw,16699
 mcp_agent/llm/providers/multipart_converter_anthropic.py,sha256=QsgIwWJ14SNZsun3fKDQaUx5AYdk8X6UYeBgYlZgZN0,16607
-mcp_agent/llm/providers/multipart_converter_openai.py,sha256=1zHlkMKY-16RL8qnrx7kI53IHmCiqASNvYsAdofSq_I,17000
+mcp_agent/llm/providers/multipart_converter_openai.py,sha256=8vBwX7PB62mV6pe4VvAj9YxzX1Dp1RJMZK1NWOMnioY,17998
 mcp_agent/llm/providers/multipart_converter_tensorzero.py,sha256=Tr3DgogthxqTw04ajblwE8aB3Ft42X7aSXsMlm5FP4k,8619
 mcp_agent/llm/providers/openai_multipart.py,sha256=qKBn7d3jSabnJmVgWweVzqh8q9mBqr09fsPmP92niAQ,6899
 mcp_agent/llm/providers/openai_utils.py,sha256=T4bTCL9f7DsoS_zoKgQKv_FUv_4n98vgbvaUpdWZJr8,1875
@@ -103,7 +103,7 @@ mcp_agent/logging/events.py,sha256=dSJJfuCd59-ZyYTVcf0M4HQd6iXb5k50PSAeoq1CpH0,4
 mcp_agent/logging/json_serializer.py,sha256=qkfxnR9ka6OgvwSpM2CggELbEtzzkApm0s_KYz11RDY,5791
 mcp_agent/logging/listeners.py,sha256=_S4Jp5_KWp0kUfrx4BxDdNCeQK3MNT3Zi9AaolPri7A,6648
 mcp_agent/logging/logger.py,sha256=v2_D5kWLSS9u4ueSU7q6cWF1oSmTVeAAtgnwR0LrbXI,11056
-mcp_agent/logging/rich_progress.py,sha256=uMAKDPO8TlhT7uTeJzOEwQPme8pu8qCADLNbsI1vV8g,5544
+mcp_agent/logging/rich_progress.py,sha256=_AMW_ODPs1RXmQ6aTu9je4hmwcCGi3lUmrVAhytq1C4,7462
 mcp_agent/logging/transport.py,sha256=_RVckOdcs_mXv6Jwz-MPe0vVTQEKsbejHdteyK5hBQA,16960
 mcp_agent/mcp/__init__.py,sha256=yxtzSmWBNqRf_nJckqgzYoozyGKja05FvSRLLus_7eM,1100
 mcp_agent/mcp/common.py,sha256=MpSC0fLO21RcDz4VApah4C8_LisVGz7OXkR17Xw-9mY,431
@@ -113,8 +113,8 @@ mcp_agent/mcp/gen_client.py,sha256=fAVwFVCgSamw4PwoWOV4wrK9TABx1S_zZv8BctRyF2k,3
 mcp_agent/mcp/hf_auth.py,sha256=7szw4rkwRyK3J-sUTcVZHdwoLIZqlYo8XolJnZdjOww,4571
 mcp_agent/mcp/interfaces.py,sha256=pe8WKvu3dnNnPWmrkDlu15xdkhuRDAjLUMn2vIE0Mj8,7963
 mcp_agent/mcp/logger_textio.py,sha256=vljC1BtNTCxBAda9ExqNB-FwVNUZIuJT3h1nWmCjMws,3172
-mcp_agent/mcp/mcp_agent_client_session.py,sha256=nEHrSalG5z47BKGwE9ooOmlSTc4Gb7qdEut071Dwepo,8987
-mcp_agent/mcp/mcp_aggregator.py,sha256=D1xFBVVq_4Tn1Ka16SZTVB3qeU-FO5501ITHGXTuXs0,49730
+mcp_agent/mcp/mcp_agent_client_session.py,sha256=ssRgxMOzyCPyAr25AeRBz3Xr-08OBdmsJf8A-ofc3bY,9115
+mcp_agent/mcp/mcp_aggregator.py,sha256=3L_UDxg7nz_Cp1hHVxxCrhDybxg-Bg2QH8e0F8x1_W4,51377
 mcp_agent/mcp/mcp_connection_manager.py,sha256=dJxjnv2IRzlFIxrbPFl39-pmGcZHgyeMXVlMfqpREhE,17974
 mcp_agent/mcp/mime_utils.py,sha256=difepNR_gpb4MpMLkBRAoyhDk-AjXUHTiqKvT_VwS1o,1805
 mcp_agent/mcp/prompt_message_multipart.py,sha256=XDlFODtOIepespQ23hvh37i3GF2L9Hju4AdNHijwe9k,4350
@@ -123,7 +123,7 @@ mcp_agent/mcp/prompt_serialization.py,sha256=MQY6QxnhQTiq0oBDsyRzFtX8sBiovUjzUFX
 mcp_agent/mcp/resource_utils.py,sha256=K4XY8bihmBMleRTZ2viMPiD2Y2HWxFnlgIJi6dd_PYE,6588
 mcp_agent/mcp/sampling.py,sha256=PpUtLDvu9K3U8445z6m_esHeKstdSr-JBTyn9d8ppJM,6665
 mcp_agent/mcp/helpers/__init__.py,sha256=jJP_yVlewL0hePTX_k_MAnUmOzxpr0Tr_rXYZYeE2WY,456
-mcp_agent/mcp/helpers/content_helpers.py,sha256=_P5xfVpJg4F7lBM-v6-1Bjtvfgr9UfTQoW2FSxyxil4,4112
+mcp_agent/mcp/helpers/content_helpers.py,sha256=zrM0cUu9U-C9dRPszOZ6vxh0fquQhFODeDEXaC2TkBg,5173
 mcp_agent/mcp/helpers/server_config_helpers.py,sha256=MkyZB2ZzfsBNsqyGd0LfUOoXxhAMS28VF-f747cJJpY,978
 mcp_agent/mcp/prompts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 mcp_agent/mcp/prompts/__main__.py,sha256=gr1Tdz9fcK0EXjEuZg_BOnKUmvhYq5AH2lFZicVyNb0,237
@@ -168,8 +168,8 @@ mcp_agent/resources/examples/workflows/short_story.txt,sha256=X3y_1AyhLFN2AKzCKv
 mcp_agent/tools/tool_definition.py,sha256=L3Pxl-uLEXqlVoo-bYuFTFALeI-2pIU44YgFhsTKEtM,398
 mcp_agent/ui/console_display.py,sha256=XXrHr950wSBSedEKUaaGkXjOzuFpQYzUKKiyaZ58Mps,28280
 mcp_agent/ui/console_display_legacy.py,sha256=sm2v61-IPVafbF7uUaOyhO2tW_zgFWOjNS83IEWqGgI,14931
-fast_agent_mcp-0.2.48.dist-info/METADATA,sha256=urEeemSyTBTUjlI5CtGjrqLD8SZWgYx1ph9GeUhp3J8,31048
-fast_agent_mcp-0.2.48.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-fast_agent_mcp-0.2.48.dist-info/entry_points.txt,sha256=QaX5kLdI0VdMPRdPUF1nkG_WdLUTNjp_icW6e3EhNYU,232
-fast_agent_mcp-0.2.48.dist-info/licenses/LICENSE,sha256=Gx1L3axA4PnuK4FxsbX87jQ1opoOkSFfHHSytW6wLUU,10935
-fast_agent_mcp-0.2.48.dist-info/RECORD,,
+fast_agent_mcp-0.2.50.dist-info/METADATA,sha256=jNGAWFccNjB_-7zrb8G6ambu93q8jtpvKxiA4Jp3rkQ,31048
+fast_agent_mcp-0.2.50.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+fast_agent_mcp-0.2.50.dist-info/entry_points.txt,sha256=QaX5kLdI0VdMPRdPUF1nkG_WdLUTNjp_icW6e3EhNYU,232
+fast_agent_mcp-0.2.50.dist-info/licenses/LICENSE,sha256=Gx1L3axA4PnuK4FxsbX87jQ1opoOkSFfHHSytW6wLUU,10935
+fast_agent_mcp-0.2.50.dist-info/RECORD,,

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."""

mcp_agent/event_progress.py

@@ -20,6 +20,7 @@ class ProgressAction(str, Enum):
     PLANNING = "Planning"
     READY = "Ready"
     CALLING_TOOL = "Calling Tool"
+    TOOL_PROGRESS = "Tool Progress"
     UPDATED = "Updated"
     FINISHED = "Finished"
     SHUTDOWN = "Shutdown"
@@ -35,6 +36,8 @@ class ProgressEvent(BaseModel):
     details: Optional[str] = None
     agent_name: Optional[str] = None
     streaming_tokens: Optional[str] = None  # Special field for streaming token count
+    progress: Optional[float] = None  # Current progress value
+    total: Optional[float] = None  # Total value for progress calculation
 
     def __str__(self) -> str:
         """Format the progress event for display."""
@@ -86,6 +89,12 @@ def convert_log_event(event: Event) -> Optional[ProgressEvent]:
             details = f"{server_name} ({tool_name})"
         else:
             details = f"{server_name}"
+        
+        # For TOOL_PROGRESS, use progress message if available, otherwise keep default
+        if progress_action == ProgressAction.TOOL_PROGRESS:
+            progress_message = event_data.get("details", "")
+            if progress_message:  # Only override if message is non-empty
+                details = progress_message
 
     elif "augmented_llm" in namespace:
         model = event_data.get("model", "")
@@ -104,10 +113,19 @@ def convert_log_event(event: Event) -> Optional[ProgressEvent]:
     if progress_action == ProgressAction.STREAMING:
         streaming_tokens = event_data.get("details", "")
     
+    # Extract progress data for TOOL_PROGRESS actions
+    progress = None
+    total = None
+    if progress_action == ProgressAction.TOOL_PROGRESS:
+        progress = event_data.get("progress")
+        total = event_data.get("total")
+    
     return ProgressEvent(
         action=ProgressAction(progress_action),
         target=target or "unknown",
         details=details,
         agent_name=event_data.get("agent_name"),
         streaming_tokens=streaming_tokens,
+        progress=progress,
+        total=total,
     )

mcp_agent/llm/model_database.py

@@ -22,6 +22,12 @@ class ModelParameters(BaseModel):
     tokenizes: List[str]
     """List of supported content types for tokenization"""
 
+    json_mode: None | str = "schema"
+    """Structured output style. 'schema', 'object' or None for unsupported """
+
+    reasoning: None | str = None
+    """Reasoning output style. 'tags' if enclosed in <thinking> tags, 'none' if not used"""
+
 
 class ModelDatabase:
     """Centralized model configuration database"""
@@ -87,6 +93,13 @@ class ModelDatabase:
     QWEN_STANDARD = ModelParameters(
         context_window=32000, max_output_tokens=8192, tokenizes=QWEN_MULTIMODAL
     )
+    QWEN3_REASONER = ModelParameters(
+        context_window=131072,
+        max_output_tokens=16384,
+        tokenizes=TEXT_ONLY,
+        json_mode="object",
+        reasoning="tags",
+    )
 
     FAST_AGENT_STANDARD = ModelParameters(
         context_window=1000000, max_output_tokens=100000, tokenizes=TEXT_ONLY
@@ -125,6 +138,13 @@ class ModelDatabase:
         context_window=65536, max_output_tokens=32768, tokenizes=TEXT_ONLY
     )
 
+    DEEPSEEK_DISTILL = ModelParameters(
+        context_window=131072,
+        max_output_tokens=131072,
+        tokenizes=TEXT_ONLY,
+        json_mode="object",
+        reasoning="tags",
+    )
     GEMINI_2_5_PRO = ModelParameters(
         context_window=2097152, max_output_tokens=8192, tokenizes=GOOGLE_MULTIMODAL
     )
@@ -214,6 +234,8 @@ class ModelDatabase:
         "grok-3-fast": GROK_3,
         "grok-3-mini-fast": GROK_3,
         "moonshotai/kimi-k2-instruct": KIMI_MOONSHOT,
+        "qwen/qwen3-32b": QWEN3_REASONER,
+        "deepseek-r1-distill-llama-70b": DEEPSEEK_DISTILL,
     }
 
     @classmethod
@@ -239,6 +261,18 @@ class ModelDatabase:
         params = cls.get_model_params(model)
         return params.tokenizes if params else None
 
+    @classmethod
+    def get_json_mode(cls, model: str) -> str | None:
+        """Get supported json mode (structured output) for a model"""
+        params = cls.get_model_params(model)
+        return params.json_mode if params else None
+
+    @classmethod
+    def get_reasoning(cls, model: str) -> str | None:
+        """Get supported reasoning output style for a model"""
+        params = cls.get_model_params(model)
+        return params.reasoning if params else None
+
     @classmethod
     def get_default_max_tokens(cls, model: str) -> int:
         """Get default max_tokens for RequestParams based on model"""

mcp_agent/llm/model_factory.py

@@ -143,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

mcp_agent/llm/providers/augmented_llm_aliyun.py

@@ -12,15 +12,14 @@ class AliyunAugmentedLLM(OpenAIAugmentedLLM):
 
     def _initialize_default_params(self, kwargs: dict) -> RequestParams:
         """Initialize Aliyun-specific default parameters"""
+        # Get base defaults from parent (includes ModelDatabase lookup)
+        base_params = super()._initialize_default_params(kwargs)
+        
+        # Override with Aliyun-specific settings
         chosen_model = kwargs.get("model", DEFAULT_QWEN_MODEL)
-
-        return RequestParams(
-            model=chosen_model,
-            systemPrompt=self.instruction,
-            parallel_tool_calls=True,
-            max_iterations=20,
-            use_history=True,
-        )
+        base_params.model = chosen_model
+        
+        return base_params
 
     def _base_url(self) -> str:
         base_url = None

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

mcp_agent/llm/providers/augmented_llm_deepseek.py

@@ -22,15 +22,14 @@ class DeepSeekAugmentedLLM(OpenAIAugmentedLLM):
 
     def _initialize_default_params(self, kwargs: dict) -> RequestParams:
         """Initialize Deepseek-specific default parameters"""
+        # Get base defaults from parent (includes ModelDatabase lookup)
+        base_params = super()._initialize_default_params(kwargs)
+        
+        # Override with Deepseek-specific settings
         chosen_model = kwargs.get("model", DEFAULT_DEEPSEEK_MODEL)
-
-        return RequestParams(
-            model=chosen_model,
-            systemPrompt=self.instruction,
-            parallel_tool_calls=True,
-            max_iterations=20,
-            use_history=True,
-        )
+        base_params.model = chosen_model
+        
+        return base_params
 
     def _base_url(self) -> str:
         base_url = None

mcp_agent/llm/providers/augmented_llm_groq.py

@@ -1,9 +1,22 @@
+from typing import List, Tuple, Type, cast
+
+from pydantic_core import from_json
+
 from mcp_agent.core.request_params import RequestParams
+from mcp_agent.llm.model_database import ModelDatabase
 from mcp_agent.llm.provider_types import Provider
 from mcp_agent.llm.providers.augmented_llm_openai import OpenAIAugmentedLLM
+from mcp_agent.logging.logger import get_logger
+from mcp_agent.mcp.helpers.content_helpers import get_text, split_thinking_content
+from mcp_agent.mcp.interfaces import ModelT
+from mcp_agent.mcp.prompt_message_multipart import PromptMessageMultipart
 
 GROQ_BASE_URL = "https://api.groq.com/openai/v1"
-DEFAULT_GROQ_MODEL = ""
+DEFAULT_GROQ_MODEL = "moonshotai/kimi-k2-instruct"
+
+### There is some big refactorings to be had quite easily here now:
+### - combining the structured output type handling
+### - deduplicating between this and the deepseek llm
 
 
 class GroqAugmentedLLM(OpenAIAugmentedLLM):
@@ -12,15 +25,75 @@ class GroqAugmentedLLM(OpenAIAugmentedLLM):
 
     def _initialize_default_params(self, kwargs: dict) -> RequestParams:
         """Initialize Groq default parameters"""
+        # Get base defaults from parent (includes ModelDatabase lookup)
+        base_params = super()._initialize_default_params(kwargs)
+
+        # Override with Groq-specific settings
         chosen_model = kwargs.get("model", DEFAULT_GROQ_MODEL)
+        base_params.model = chosen_model
+        base_params.parallel_tool_calls = False
+
+        return base_params
+
+    async def _apply_prompt_provider_specific_structured(
+        self,
+        multipart_messages: List[PromptMessageMultipart],
+        model: Type[ModelT],
+        request_params: RequestParams | None = None,
+    ) -> Tuple[ModelT | None, PromptMessageMultipart]:  # noqa: F821
+        request_params = self.get_request_params(request_params)
+
+        assert self.default_request_params
+        llm_model = self.default_request_params.model or DEFAULT_GROQ_MODEL
+        json_mode: str | None = ModelDatabase.get_json_mode(llm_model)
+        if "json_object" == json_mode:
+            request_params.response_format = {"type": "json_object"}
+
+        # Get the full schema and extract just the properties
+        full_schema = model.model_json_schema()
+        properties = full_schema.get("properties", {})
+        required_fields = full_schema.get("required", [])
+
+        # Create a cleaner format description
+        format_description = "{\n"
+        for field_name, field_info in properties.items():
+            field_type = field_info.get("type", "string")
+            description = field_info.get("description", "")
+            format_description += f'  "{field_name}": "{field_type}"'
+            if description:
+                format_description += f"  // {description}"
+            if field_name in required_fields:
+                format_description += "  // REQUIRED"
+            format_description += "\n"
+        format_description += "}"
+
+        multipart_messages[-1].add_text(
+            f"""YOU MUST RESPOND WITH A JSON OBJECT IN EXACTLY THIS FORMAT:
+            {format_description}
+
+            IMPORTANT RULES:
+            - Respond ONLY with the JSON object, no other text
+            - Do NOT include "properties" or "schema" wrappers
+            - Do NOT use code fences or markdown
+            - The response must be valid JSON that matches the format above
+            - All required fields must be included"""
+        )
 
-        return RequestParams(
-            model=chosen_model,
-            systemPrompt=self.instruction,
-            parallel_tool_calls=False,
-            max_iterations=20,
-            use_history=True,
+        result: PromptMessageMultipart = await self._apply_prompt_provider_specific(
+            multipart_messages, request_params
         )
+        reasoning_mode: str | None = ModelDatabase.get_reasoning(llm_model)
+        try:
+            text = get_text(result.content[-1]) or ""
+            if "tags" == reasoning_mode:
+                _, text = split_thinking_content(text)
+            json_data = from_json(text, allow_partial=True)
+            validated_model = model.model_validate(json_data)
+            return cast("ModelT", validated_model), result
+        except ValueError as e:
+            logger = get_logger(__name__)
+            logger.warning(f"Failed to parse structured response: {str(e)}")
+            return None, result
 
     def _base_url(self) -> str:
         base_url = None

mcp_agent/llm/providers/augmented_llm_openai.py

@@ -307,6 +307,7 @@ class OpenAIAugmentedLLM(AugmentedLLM[ChatCompletionMessageParam, ChatCompletion
         request_params = self.get_request_params(request_params=request_params)
 
         responses: List[ContentBlock] = []
+        model_name = self.default_request_params.model or DEFAULT_OPENAI_MODEL
 
         # TODO -- move this in to agent context management / agent group handling
         messages: List[ChatCompletionMessageParam] = []
@@ -347,7 +348,6 @@ class OpenAIAugmentedLLM(AugmentedLLM[ChatCompletionMessageParam, ChatCompletion
             stream = await self._openai_client().chat.completions.create(**arguments)
             # Process the stream
             response = await self._process_stream(stream, self.default_request_params.model)
-
             # Track usage if response is valid and has usage data
             if (
                 hasattr(response, "usage")
@@ -391,6 +391,9 @@ class OpenAIAugmentedLLM(AugmentedLLM[ChatCompletionMessageParam, ChatCompletion
             # 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}
+            if model_name == "deepseek-r1-distill-llama-70b":
+                message_dict.pop("reasoning", None)
+
             messages.append(message_dict)
 
             message_text = message.content
@@ -412,6 +415,7 @@ class OpenAIAugmentedLLM(AugmentedLLM[ChatCompletionMessageParam, ChatCompletion
                     )
 
                 tool_results = []
+
                 for tool_call in message.tool_calls:
                     self.show_tool_call(
                         available_tools,
@@ -428,12 +432,24 @@ 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'}"

mcp_agent/llm/providers/augmented_llm_openrouter.py

@@ -17,24 +17,19 @@ class OpenRouterAugmentedLLM(OpenAIAugmentedLLM):
 
     def _initialize_default_params(self, kwargs: dict) -> RequestParams:
         """Initialize OpenRouter-specific default parameters."""
+        # Get base defaults from parent (includes ModelDatabase lookup)
+        base_params = super()._initialize_default_params(kwargs)
+        
+        # Override with OpenRouter-specific settings
         # OpenRouter model names include the provider, e.g., "google/gemini-flash-1.5"
         # The model should be passed in the 'model' kwarg during factory creation.
         chosen_model = kwargs.get("model", DEFAULT_OPENROUTER_MODEL)
-        if not chosen_model:
-            # Unlike Deepseek, OpenRouter *requires* a model path in the identifier.
-            # The factory should extract this before calling the constructor.
-            # We rely on the model being passed correctly via kwargs.
-            # If it's still None here, it indicates an issue upstream (factory or user input).
-            # However, the base class _get_model handles the error if model is None.
-            pass
-
-        return RequestParams(
-            model=chosen_model,  # Will be validated by base class
-            systemPrompt=self.instruction,
-            parallel_tool_calls=True,  # Default based on OpenAI provider
-            max_iterations=20,  # Default based on OpenAI provider
-            use_history=True,  # Default based on OpenAI provider
-        )
+        if chosen_model:
+            base_params.model = chosen_model
+        # If it's still None here, it indicates an issue upstream (factory or user input).
+        # However, the base class _get_model handles the error if model is None.
+        
+        return base_params
 
     def _base_url(self) -> str:
         """Retrieve the OpenRouter base URL from config or use the default."""

mcp_agent/llm/providers/augmented_llm_xai.py

@@ -16,15 +16,15 @@ class XAIAugmentedLLM(OpenAIAugmentedLLM):
 
     def _initialize_default_params(self, kwargs: dict) -> RequestParams:
         """Initialize xAI parameters"""
+        # Get base defaults from parent (includes ModelDatabase lookup)
+        base_params = super()._initialize_default_params(kwargs)
+        
+        # Override with xAI-specific settings
         chosen_model = kwargs.get("model", DEFAULT_XAI_MODEL)
-
-        return RequestParams(
-            model=chosen_model,
-            systemPrompt=self.instruction,
-            parallel_tool_calls=False,
-            max_iterations=20,
-            use_history=True,
-        )
+        base_params.model = chosen_model
+        base_params.parallel_tool_calls = False
+        
+        return base_params
 
     def _base_url(self) -> str:
         base_url = os.getenv("XAI_BASE_URL", XAI_BASE_URL)

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

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,11 +77,12 @@ 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",
             ProgressAction.CALLING_TOOL: "bold magenta",
+            ProgressAction.TOOL_PROGRESS: "bold magenta",
             ProgressAction.FINISHED: "black on green",
             ProgressAction.SHUTDOWN: "black on red",
             ProgressAction.AGGREGATOR_INITIALIZED: "bold green",
@@ -107,18 +108,49 @@ 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}"
+        elif event.action == ProgressAction.TOOL_PROGRESS:
+            # Format similar to streaming - show progress numbers
+            if event.progress is not None:
+                if event.total is not None:
+                    progress_display = f"{int(event.progress)}/{int(event.total)}"
+                else:
+                    progress_display = str(int(event.progress))
+            else:
+                progress_display = "Processing"
+            formatted_text = f"▎[dim]▶[/dim] {progress_display}".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}"
-
-        self._progress.update(
-            task_id,
-            description=description,
-            target=event.target or task_name,  # Use task_name as fallback for target
-            details=event.details or "",
-            task_name=task_name,
-        )
+            description = f"[{self._get_action_style(event.action)}]▎ {event.action.value:<15}"
+
+        # Update basic task information
+        update_kwargs = {
+            "description": description,
+            "target": event.target or task_name,  # Use task_name as fallback for target
+            "details": event.details or "",
+            "task_name": task_name,
+        }
+        
+        # For TOOL_PROGRESS events, update progress if available
+        if event.action == ProgressAction.TOOL_PROGRESS and event.progress is not None:
+            if event.total is not None:
+                update_kwargs["completed"] = event.progress
+                update_kwargs["total"] = event.total
+            else:
+                # If no total, just show as indeterminate progress
+                self._progress.reset(task_id)
+        
+        self._progress.update(task_id, **update_kwargs)
 
         if (
             event.action == ProgressAction.INITIALIZED

mcp_agent/mcp/helpers/content_helpers.py

@@ -156,3 +156,32 @@ def get_resource_text(result: ReadResourceResult, index: int = 0) -> Optional[st
         return content.text
 
     return None
+
+
+def split_thinking_content(message: str) -> tuple[Optional[str], str]:
+    """
+    Split a message into thinking and content parts.
+
+    Extracts content between <thinking> tags and returns it along with the remaining content.
+
+    Args:
+        message: A string that may contain a <thinking>...</thinking> block followed by content
+
+    Returns:
+        A tuple of (thinking_content, main_content) where:
+        - thinking_content: The content inside <thinking> tags, or None if not found/parsing fails
+        - main_content: The content after the thinking block, or the entire message if no thinking block
+    """
+    import re
+
+    # Pattern to match <thinking>...</thinking> at the start of the message
+    pattern = r"^<think>(.*?)</think>\s*(.*)$"
+    match = re.match(pattern, message, re.DOTALL)
+
+    if match:
+        thinking_content = match.group(1).strip()
+        main_content = match.group(2).strip()
+        return (thinking_content, main_content)
+    else:
+        # No thinking block found or parsing failed
+        return (None, message)

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
 

mcp_agent/mcp/mcp_aggregator.py

@@ -12,6 +12,7 @@ from typing import (
 
 from mcp import GetPromptResult, ReadResourceResult
 from mcp.client.session import ClientSession
+from mcp.shared.session import ProgressFnT
 from mcp.types import (
     CallToolResult,
     ListToolsResult,
@@ -136,6 +137,24 @@ class MCPAggregator(ContextDependent):
         # Lock for refreshing tools from a server
         self._refresh_lock = Lock()
 
+    def _create_progress_callback(self, server_name: str, tool_name: str) -> "ProgressFnT":
+        """Create a progress callback function for tool execution."""
+        async def progress_callback(progress: float, total: float | None, message: str | None) -> None:
+            """Handle progress notifications from MCP tool execution."""
+            logger.info(
+                "Tool progress update",
+                data={
+                    "progress_action": ProgressAction.TOOL_PROGRESS,
+                    "tool_name": tool_name,
+                    "server_name": server_name,
+                    "agent_name": self.agent_name,
+                    "progress": progress,
+                    "total": total,
+                    "details": message or "",  # Put the message in details column
+                },
+            )
+        return progress_callback
+
     async def close(self) -> None:
         """
         Close all persistent connections when the aggregator is deleted.
@@ -468,6 +487,7 @@ class MCPAggregator(ContextDependent):
         method_name: str,
         method_args: Dict[str, Any] = None,
         error_factory: Callable[[str], R] = None,
+        progress_callback: ProgressFnT | None = None,
     ) -> R:
         """
         Generic method to execute operations on a specific server.
@@ -479,6 +499,7 @@ class MCPAggregator(ContextDependent):
             method_name: Name of the method to call on the client session
             method_args: Arguments to pass to the method
             error_factory: Function to create an error return value if the operation fails
+            progress_callback: Optional progress callback for operations that support it
 
         Returns:
             Result from the operation or an error result
@@ -487,7 +508,12 @@ class MCPAggregator(ContextDependent):
         async def try_execute(client: ClientSession):
             try:
                 method = getattr(client, method_name)
-                return await method(**method_args)
+                # For call_tool method, check if we need to add progress_callback
+                if method_name == "call_tool" and progress_callback:
+                    # The call_tool method signature includes progress_callback parameter
+                    return await method(**method_args, progress_callback=progress_callback)
+                else:
+                    return await method(**method_args)
             except Exception as e:
                 error_msg = (
                     f"Failed to {method_name} '{operation_name}' on server '{server_name}': {e}"
@@ -597,6 +623,10 @@ class MCPAggregator(ContextDependent):
         with tracer.start_as_current_span(f"MCP Tool: {server_name}/{local_tool_name}"):
             trace.get_current_span().set_attribute("tool_name", local_tool_name)
             trace.get_current_span().set_attribute("server_name", server_name)
+            
+            # Create progress callback for this tool execution
+            progress_callback = self._create_progress_callback(server_name, local_tool_name)
+            
             return await self._execute_on_server(
                 server_name=server_name,
                 operation_type="tool",
@@ -609,6 +639,7 @@ class MCPAggregator(ContextDependent):
                 error_factory=lambda msg: CallToolResult(
                     isError=True, content=[TextContent(type="text", text=msg)]
                 ),
+                progress_callback=progress_callback,
             )
 
     async def get_prompt(