fast-agent-mcp 0.2.35__tar.gz → 0.2.36__tar.gz

{fast_agent_mcp-0.2.35 → fast_agent_mcp-0.2.36}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fast-agent-mcp
-Version: 0.2.35
+Version: 0.2.36
 Summary: Define, Prompt and Test MCP enabled Agents and Workflows
 Author-email: Shaun Smith <fastagent@llmindset.co.uk>
 License:                                  Apache License
@@ -209,15 +209,15 @@ Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Requires-Python: >=3.10
-Requires-Dist: a2a-types>=0.1.0
+Requires-Dist: a2a-sdk>=0.2.9
 Requires-Dist: aiohttp>=3.11.13
-Requires-Dist: anthropic>=0.49.0
+Requires-Dist: anthropic>=0.55.0
 Requires-Dist: azure-identity>=1.14.0
 Requires-Dist: deprecated>=1.2.18
 Requires-Dist: fastapi>=0.115.6
 Requires-Dist: google-genai
-Requires-Dist: mcp==1.9.4
-Requires-Dist: openai>=1.63.2
+Requires-Dist: mcp==1.10.1
+Requires-Dist: openai>=1.93.0
 Requires-Dist: opentelemetry-distro>=0.50b0
 Requires-Dist: opentelemetry-exporter-otlp-proto-http>=1.29.0
 Requires-Dist: opentelemetry-instrumentation-anthropic>=0.40.7; python_version >= '3.10' and python_version < '4.0'
@@ -229,7 +229,7 @@ Requires-Dist: pydantic-settings>=2.7.0
 Requires-Dist: pydantic>=2.10.4
 Requires-Dist: pyyaml>=6.0.2
 Requires-Dist: rich>=13.9.4
-Requires-Dist: tensorzero>=2025.4.7
+Requires-Dist: tensorzero>=2025.6.3
 Requires-Dist: typer>=0.15.1
 Provides-Extra: azure
 Requires-Dist: azure-identity>=1.14.0; extra == 'azure'

{fast_agent_mcp-0.2.35/src/mcp_agent/resources → fast_agent_mcp-0.2.36}/examples/data-analysis/analysis.py

@@ -1,7 +1,6 @@
 import asyncio
 
 from mcp_agent.core.fastagent import FastAgent
-from mcp_agent.llm.augmented_llm import RequestParams
 
 # Create the application
 fast = FastAgent("Data Analysis (Roots)")
@@ -21,8 +20,8 @@ Data files are accessible from the /mnt/data/ directory (this is the current wor
 Visualisations should be saved as .png files in the current working directory.
 """,
     servers=["interpreter"],
-    request_params=RequestParams(maxTokens=8192),
 )
+@fast.agent(name="another_test", instruction="", servers=["filesystem"])
 async def main() -> None:
     # Use the app's context manager
     async with fast.run() as agent:

{fast_agent_mcp-0.2.35 → fast_agent_mcp-0.2.36}/examples/tensorzero/agent.py

@@ -27,9 +27,8 @@ my_t0_system_vars = {
 )
 async def main():
     async with fast.run() as agent_app:  # Get the AgentApp wrapper
-        agent_name = "default"
         print("\nStarting interactive session with template_vars set via decorator...")
-        await agent_app.interactive(agent=agent_name)
+        await agent_app.interactive()
 
 
 if __name__ == "__main__":

{fast_agent_mcp-0.2.35 → fast_agent_mcp-0.2.36}/examples/workflows/parallel.py

@@ -25,7 +25,6 @@ fast = FastAgent(
     instruction="""Verify the factual consistency within the story. Identify any contradictions,
     logical inconsistencies, or inaccuracies in the plot, character actions, or setting. 
     Highlight potential issues with reasoning or coherence.""",
-    model="gpt-4.1",
 )
 @fast.agent(
     name="style_enforcer",
@@ -40,7 +39,6 @@ fast = FastAgent(
     into a structured report. Summarize key issues and categorize them by type. 
     Provide actionable recommendations for improving the story, 
     and give an overall grade based on the feedback.""",
-    model="o3-mini.low",
 )
 @fast.parallel(
     fan_out=["proofreader", "fact_checker", "style_enforcer"],

{fast_agent_mcp-0.2.35 → fast_agent_mcp-0.2.36}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fast-agent-mcp"
-version = "0.2.35"
+version = "0.2.36"
 description = "Define, Prompt and Test MCP enabled Agents and Workflows"
 readme = "README.md"
 license = { file = "LICENSE" }
@@ -15,7 +15,7 @@ classifiers = [
 requires-python = ">=3.10"
 dependencies = [
     "fastapi>=0.115.6",
-    "mcp==1.9.4",
+    "mcp==1.10.1",
     "opentelemetry-distro>=0.50b0",
     "opentelemetry-exporter-otlp-proto-http>=1.29.0",
     "pydantic-settings>=2.7.0",
@@ -23,20 +23,20 @@ dependencies = [
     "pyyaml>=6.0.2",
     "rich>=13.9.4",
     "typer>=0.15.1",
-    "anthropic>=0.49.0",
-    "openai>=1.63.2",
+    "anthropic>=0.55.0",
+    "openai>=1.93.0",
     "azure-identity>=1.14.0",
     "prompt-toolkit>=3.0.50",
     "aiohttp>=3.11.13",
-    "a2a-types>=0.1.0",
     "opentelemetry-instrumentation-openai>=0.0.40.7; python_version >= '3.10' and python_version < '4.0'",
     "opentelemetry-instrumentation-anthropic>=0.40.7; python_version >= '3.10' and python_version < '4.0'",
     "opentelemetry-instrumentation-mcp>=0.40.7; python_version >= '3.10' and python_version < '4.0'",
     "google-genai",
     "opentelemetry-instrumentation-google-genai>=0.2b0",
-    "tensorzero>=2025.4.7",
+    "tensorzero>=2025.6.3",
     "opentelemetry-instrumentation-google-genai>=0.2b0",
     "deprecated>=1.2.18",
+    "a2a-sdk>=0.2.9",
 ]
 
 [project.optional-dependencies]

{fast_agent_mcp-0.2.35 → fast_agent_mcp-0.2.36}/src/mcp_agent/agents/base_agent.py

@@ -20,7 +20,7 @@ from typing import (
     Union,
 )
 
-from a2a_types.types import AgentCapabilities, AgentCard, AgentSkill
+from a2a.types import AgentCapabilities, AgentCard, AgentSkill
 from mcp.types import (
     CallToolResult,
     EmbeddedResource,
@@ -704,7 +704,7 @@ class BaseAgent(MCPAggregator, AgentProtocol):
     def usage_accumulator(self) -> Optional["UsageAccumulator"]:
         """
         Return the usage accumulator for tracking token usage across turns.
-        
+
         Returns:
             UsageAccumulator object if LLM is attached, None otherwise
         """

{fast_agent_mcp-0.2.35 → fast_agent_mcp-0.2.36}/src/mcp_agent/agents/workflow/router_agent.py

@@ -21,7 +21,7 @@ from mcp_agent.mcp.interfaces import AugmentedLLMProtocol, ModelT
 from mcp_agent.mcp.prompt_message_multipart import PromptMessageMultipart
 
 if TYPE_CHECKING:
-    from a2a_types.types import AgentCard
+    from a2a.types import AgentCard
 
     from mcp_agent.context import Context
 

{fast_agent_mcp-0.2.35 → fast_agent_mcp-0.2.36}/src/mcp_agent/core/enhanced_prompt.py

@@ -40,6 +40,59 @@ in_multiline_mode = False
 # Track whether help text has been shown globally
 help_message_shown = False
 
+# Track which agents have shown their info
+_agent_info_shown = set()
+
+
+async def _display_agent_info_helper(agent_name: str, agent_provider: object) -> None:
+    """Helper function to display agent information."""
+    # Only show once per agent
+    if agent_name in _agent_info_shown:
+        return
+
+    try:
+        # Get agent info
+        if hasattr(agent_provider, "_agent"):
+            # This is an AgentApp - get the specific agent
+            agent = agent_provider._agent(agent_name)
+        else:
+            # This is a single agent
+            agent = agent_provider
+
+        # Get counts
+        servers = await agent.list_servers()
+        server_count = len(servers) if servers else 0
+
+        tools_result = await agent.list_tools()
+        tool_count = (
+            len(tools_result.tools) if tools_result and hasattr(tools_result, "tools") else 0
+        )
+
+        prompts_dict = await agent.list_prompts()
+        prompt_count = sum(len(prompts) for prompts in prompts_dict.values()) if prompts_dict else 0
+
+        # Display with proper pluralization and subdued formatting
+        if server_count == 0:
+            rich_print(
+                f"[dim]Agent [/dim][blue]{agent_name}[/blue][dim]: No MCP Servers attached[/dim]"
+            )
+        else:
+            # Pluralization helpers
+            server_word = "Server" if server_count == 1 else "Servers"
+            tool_word = "tool" if tool_count == 1 else "tools"
+            prompt_word = "prompt" if prompt_count == 1 else "prompts"
+
+            rich_print(
+                f"[dim]Agent [/dim][blue]{agent_name}[/blue][dim]:[/dim] {server_count:,}[dim] MCP {server_word}, [/dim]{tool_count:,}[dim] {tool_word}, [/dim]{prompt_count:,}[dim] {prompt_word} available[/dim]"
+            )
+
+        # Mark as shown
+        _agent_info_shown.add(agent_name)
+
+    except Exception:
+        # Silently ignore errors to not disrupt the user experience
+        pass
+
 
 class AgentCompleter(Completer):
     """Provide completion for agent names and common commands."""
@@ -54,11 +107,11 @@ class AgentCompleter(Completer):
         self.agents = agents
         # Map commands to their descriptions for better completion hints
         self.commands = {
-            "help": "Show available commands",
-            "prompts": "List and select MCP prompts",  # Changed description
-            "prompt": "Apply a specific prompt by name (/prompt <name>)",  # New command
+            "tools": "List and call MCP tools",
+            "prompt": "List and select MCP prompts, or apply specific prompt (/prompt <name>)",
             "agents": "List available agents",
             "usage": "Show current usage statistics",
+            "help": "Show available commands",
             "clear": "Clear the screen",
             "STOP": "Stop this prompting session and move to next workflow step",
             "EXIT": "Exit fast-agent, terminating any running workflows",
@@ -66,8 +119,8 @@ class AgentCompleter(Completer):
         }
         if is_human_input:
             self.commands.pop("agents")
-            self.commands.pop("prompts")  # Remove prompts command in human input mode
             self.commands.pop("prompt", None)  # Remove prompt command in human input mode
+            self.commands.pop("tools", None)  # Remove tools command in human input mode
             self.commands.pop("usage", None)  # Remove usage command in human input mode
         self.agent_types = agent_types or {}
 
@@ -260,6 +313,7 @@ async def get_enhanced_input(
     agent_types: dict[str, AgentType] = None,
     is_human_input: bool = False,
     toolbar_color: str = "ansiblue",
+    agent_provider: object = None,
 ) -> str:
     """
     Enhanced input with advanced prompt_toolkit features.
@@ -274,6 +328,7 @@ async def get_enhanced_input(
         agent_types: Dictionary mapping agent names to their types for display
         is_human_input: Whether this is a human input request (disables agent selection features)
         toolbar_color: Color to use for the agent name in the toolbar (default: "ansiblue")
+        agent_provider: Optional agent provider for displaying agent info
 
     Returns:
         User input string
@@ -300,14 +355,15 @@ async def get_enhanced_input(
         if in_multiline_mode:
             mode_style = "ansired"  # More noticeable for multiline mode
             mode_text = "MULTILINE"
-            toggle_text = "Normal Editing"
+            toggle_text = "Normal"
         else:
             mode_style = "ansigreen"
             mode_text = "NORMAL"
-            toggle_text = "Multiline Editing"
+            toggle_text = "Multiline"
 
         shortcuts = [
             ("Ctrl+T", toggle_text),
+            ("Ctrl+E", "External"),
             ("Ctrl+L", "Clear"),
             ("↑/↓", "History"),
         ]
@@ -373,8 +429,13 @@ async def get_enhanced_input(
             rich_print("[dim]Type /help for commands. Ctrl+T toggles multiline mode.[/dim]")
         else:
             rich_print(
-                "[dim]Type /help for commands, @agent to switch agent. Ctrl+T toggles multiline mode.[/dim]"
+                "[dim]Type /help for commands, @agent to switch agent. Ctrl+T toggles multiline mode.[/dim]\n"
             )
+
+            # Display agent info right after help text if agent_provider is available
+            if agent_provider and not is_human_input:
+                await _display_agent_info_helper(agent_name, agent_provider)
+
         rich_print()
         help_message_shown = True
 
@@ -394,12 +455,8 @@ async def get_enhanced_input(
                 return "LIST_AGENTS"
             elif cmd == "usage":
                 return "SHOW_USAGE"
-            elif cmd == "prompts":
-                # Return a dictionary with select_prompt action instead of a string
-                # This way it will match what the command handler expects
-                return {"select_prompt": True, "prompt_name": None}
             elif cmd == "prompt":
-                # Handle /prompt with no arguments the same way as /prompts
+                # Handle /prompt with no arguments as interactive mode
                 if len(cmd_parts) > 1:
                     # Direct prompt selection with name or number
                     prompt_arg = cmd_parts[1].strip()
@@ -409,8 +466,11 @@ async def get_enhanced_input(
                     else:
                         return f"SELECT_PROMPT:{prompt_arg}"
                 else:
-                    # If /prompt is used without arguments, treat it the same as /prompts
+                    # If /prompt is used without arguments, show interactive selection
                     return {"select_prompt": True, "prompt_name": None}
+            elif cmd == "tools":
+                # Return a dictionary with list_tools action
+                return {"list_tools": True}
             elif cmd == "exit":
                 return "EXIT"
             elif cmd.lower() == "stop":

{fast_agent_mcp-0.2.35 → fast_agent_mcp-0.2.36}/src/mcp_agent/core/interactive_prompt.py

@@ -23,6 +23,7 @@ from rich.table import Table
 
 from mcp_agent.core.agent_types import AgentType
 from mcp_agent.core.enhanced_prompt import (
+    _display_agent_info_helper,
     get_argument_input,
     get_enhanced_input,
     get_selection_input,
@@ -121,6 +122,7 @@ class InteractivePrompt:
                     multiline=False,  # Default to single-line mode
                     available_agent_names=available_agents,
                     agent_types=self.agent_types,  # Pass agent types for display
+                    agent_provider=prompt_provider,  # Pass agent provider for info display
                 )
 
                 # Handle special commands - pass "True" to enable agent switching
@@ -132,6 +134,9 @@ class InteractivePrompt:
                         new_agent = command_result["switch_agent"]
                         if new_agent in available_agents_set:
                             agent = new_agent
+                            # Display new agent info immediately when switching
+                            rich_print()  # Add spacing
+                            await _display_agent_info_helper(agent, prompt_provider)
                             continue
                         else:
                             rich_print(f"[red]Agent '{new_agent}' not found[/red]")
@@ -174,6 +179,10 @@ class InteractivePrompt:
                             # Use the name-based selection
                             await self._select_prompt(prompt_provider, agent, prompt_name)
                         continue
+                    elif "list_tools" in command_result and prompt_provider:
+                        # Handle tools list display
+                        await self._list_tools(prompt_provider, agent)
+                        continue
                     elif "show_usage" in command_result:
                         # Handle usage display
                         await self._show_usage(prompt_provider, agent)
@@ -333,13 +342,17 @@ class InteractivePrompt:
             rich_print(f"[dim]{traceback.format_exc()}[/dim]")
 
     async def _select_prompt(
-        self, prompt_provider: PromptProvider, agent_name: str, requested_name: Optional[str] = None
+        self,
+        prompt_provider: PromptProvider,
+        agent_name: str,
+        requested_name: Optional[str] = None,
+        send_func: Optional[SendFunc] = None,
     ) -> None:
         """
         Select and apply a prompt.
 
         Args:
-            prompt_provider: Provider that implements list_prompts and apply_prompt
+            prompt_provider: Provider that implements list_prompts and get_prompt
             agent_name: Name of the agent
             requested_name: Optional name of the prompt to apply
         """
@@ -569,12 +582,54 @@ class InteractivePrompt:
                         if arg_value:
                             arg_values[arg_name] = arg_value
 
-            # Apply the prompt
+            # Apply the prompt using generate() for proper progress display
             namespaced_name = selected_prompt["namespaced_name"]
             rich_print(f"\n[bold]Applying prompt [cyan]{namespaced_name}[/cyan]...[/bold]")
 
-            # Call apply_prompt on the provider with the prompt name and arguments
-            await prompt_provider.apply_prompt(namespaced_name, arg_values, agent_name)
+            # Get the agent directly for generate() call
+            if hasattr(prompt_provider, "_agent"):
+                # This is an AgentApp - get the specific agent
+                agent = prompt_provider._agent(agent_name)
+            else:
+                # This is a single agent
+                agent = prompt_provider
+
+            try:
+                # Use agent.apply_prompt() which handles everything properly:
+                # - get_prompt() to fetch template
+                # - convert to multipart
+                # - call generate() for progress display
+                # - return response text
+                # Response display is handled by the agent's show_ methods, don't print it here
+
+                # Fetch the prompt first (without progress display)
+                prompt_result = await agent.get_prompt(namespaced_name, arg_values)
+
+                if not prompt_result or not prompt_result.messages:
+                    rich_print(
+                        f"[red]Prompt '{namespaced_name}' could not be found or contains no messages[/red]"
+                    )
+                    return
+
+                # Convert to multipart format
+                from mcp_agent.mcp.prompt_message_multipart import PromptMessageMultipart
+
+                multipart_messages = PromptMessageMultipart.from_get_prompt_result(prompt_result)
+
+                # Now start progress display for the actual generation
+                progress_display.resume()
+                try:
+                    await agent.generate(multipart_messages, None)
+                finally:
+                    # Pause again for the next UI interaction
+                    progress_display.pause()
+
+                # Show usage info after the turn (same as send_wrapper does)
+                if hasattr(prompt_provider, "_show_turn_usage"):
+                    prompt_provider._show_turn_usage(agent_name)
+
+            except Exception as e:
+                rich_print(f"[red]Error applying prompt: {e}[/red]")
 
         except Exception as e:
             import traceback
@@ -582,6 +637,61 @@ class InteractivePrompt:
             rich_print(f"[red]Error selecting or applying prompt: {e}[/red]")
             rich_print(f"[dim]{traceback.format_exc()}[/dim]")
 
+    async def _list_tools(self, prompt_provider: PromptProvider, agent_name: str) -> None:
+        """
+        List available tools for an agent.
+
+        Args:
+            prompt_provider: Provider that implements list_tools
+            agent_name: Name of the agent
+        """
+        console = Console()
+
+        try:
+            # Get agent to list tools from
+            if hasattr(prompt_provider, "_agent"):
+                # This is an AgentApp - get the specific agent
+                agent = prompt_provider._agent(agent_name)
+            else:
+                # This is a single agent
+                agent = prompt_provider
+
+            rich_print(f"\n[bold]Fetching tools for agent [cyan]{agent_name}[/cyan]...[/bold]")
+
+            # Get tools using list_tools
+            tools_result = await agent.list_tools()
+
+            if not tools_result or not hasattr(tools_result, "tools") or not tools_result.tools:
+                rich_print("[yellow]No tools available for this agent[/yellow]")
+                return
+
+            # Create a table for better display
+            table = Table(title="Available MCP Tools")
+            table.add_column("#", justify="right", style="cyan")
+            table.add_column("Tool Name", style="bright_blue")
+            table.add_column("Description")
+
+            # Add tools to table
+            for i, tool in enumerate(tools_result.tools):
+                table.add_row(
+                    str(i + 1),
+                    tool.name,
+                    getattr(tool, "description", "No description") or "No description",
+                )
+
+            console.print(table)
+
+            # Add usage instructions
+            rich_print("\n[bold]Usage:[/bold]")
+            rich_print("  • Tools are automatically available in your conversation")
+            rich_print("  • Just ask the agent to use a tool by name or description")
+
+        except Exception as e:
+            import traceback
+
+            rich_print(f"[red]Error listing tools: {e}[/red]")
+            rich_print(f"[dim]{traceback.format_exc()}[/dim]")
+
     async def _show_usage(self, prompt_provider: PromptProvider, agent_name: str) -> None:
         """
         Show usage statistics for the current agent(s) in a colorful table format.
@@ -593,13 +703,13 @@ class InteractivePrompt:
         try:
             # Collect all agents from the prompt provider
             agents_to_show = collect_agents_from_provider(prompt_provider, agent_name)
-            
+
             if not agents_to_show:
                 rich_print("[yellow]No usage data available[/yellow]")
                 return
-                
+
             # Use the shared display utility
             display_usage_report(agents_to_show, show_if_progress_disabled=True)
-            
+
         except Exception as e:
             rich_print(f"[red]Error showing usage: {e}[/red]")

{fast_agent_mcp-0.2.35 → fast_agent_mcp-0.2.36}/src/mcp_agent/llm/augmented_llm.py

@@ -554,6 +554,37 @@ class AugmentedLLM(ContextDependent, AugmentedLLMProtocol, Generic[MessageParamT
         }
         self.logger.debug("Chat in progress", data=data)
 
+    def _update_streaming_progress(self, content: str, model: str, estimated_tokens: int) -> int:
+        """Update streaming progress with token estimation and formatting.
+        
+        Args:
+            content: The text content from the streaming event
+            model: The model name
+            estimated_tokens: Current token count to update
+            
+        Returns:
+            Updated estimated token count
+        """
+        # Rough estimate: 1 token per 4 characters (OpenAI's typical ratio)
+        text_length = len(content)
+        additional_tokens = max(1, text_length // 4)
+        new_total = estimated_tokens + additional_tokens
+        
+        # Format token count for display
+        token_str = str(new_total).rjust(5)
+        
+        # Emit progress event
+        data = {
+            "progress_action": ProgressAction.STREAMING,
+            "model": model,
+            "agent_name": self.name,
+            "chat_turn": self.chat_turn(),
+            "details": token_str.strip(),  # Token count goes in details for STREAMING action
+        }
+        self.logger.info("Streaming progress", data=data)
+        
+        return new_total
+
     def _log_chat_finished(self, model: Optional[str] = None) -> None:
         """Log a chat finished event"""
         data = {

{fast_agent_mcp-0.2.35 → fast_agent_mcp-0.2.36}/src/mcp_agent/llm/providers/augmented_llm_anthropic.py

@@ -111,14 +111,8 @@ class AnthropicAugmentedLLM(AugmentedLLM[MessageParam, Message]):
                 and hasattr(event, "delta")
                 and event.delta.type == "text_delta"
             ):
-                # Rough estimate: 1 token per 4 characters (OpenAI's typical ratio)
-                text_length = len(event.delta.text)
-                estimated_tokens += max(1, text_length // 4)
-
-                # Update progress on every token for real-time display
-                token_str = str(estimated_tokens).rjust(5)
-                #                print(f"DEBUG: Streaming tokens: {token_str}")
-                self._emit_streaming_progress(model, token_str)
+                # Use base class method for token estimation and progress emission
+                estimated_tokens = self._update_streaming_progress(event.delta.text, model, estimated_tokens)
 
             # Also check for final message_delta events with actual usage info
             elif (
@@ -127,9 +121,16 @@ class AnthropicAugmentedLLM(AugmentedLLM[MessageParam, Message]):
                 and event.usage.output_tokens
             ):
                 actual_tokens = event.usage.output_tokens
+                # Emit final progress with actual token count
                 token_str = str(actual_tokens).rjust(5)
-                #               print(f"DEBUG: Final actual tokens: {token_str}")
-                self._emit_streaming_progress(model, token_str)
+                data = {
+                    "progress_action": ProgressAction.STREAMING,
+                    "model": model,
+                    "agent_name": self.name,
+                    "chat_turn": self.chat_turn(),
+                    "details": token_str.strip(),
+                }
+                self.logger.info("Streaming progress", data=data)
 
         # Get the final message with complete usage data
         message = await stream.get_final_message()
@@ -142,19 +143,6 @@ class AnthropicAugmentedLLM(AugmentedLLM[MessageParam, Message]):
 
         return message
 
-    def _emit_streaming_progress(self, model: str, token_str: str) -> None:
-        """Emit a streaming progress event that goes directly to progress display."""
-        data = {
-            "progress_action": ProgressAction.STREAMING,
-            "model": model,
-            "agent_name": self.name,
-            "chat_turn": self.chat_turn(),
-            "details": token_str.strip(),  # Token count goes in details for STREAMING action
-        }
-        #        print(f"DEBUG: Emitting streaming progress event with data: {data}")
-        # Use a special logger level or namespace to avoid polluting regular logs
-        self.logger.info("Streaming progress", data=data)
-
     async def _anthropic_completion(
         self,
         message_param,

{fast_agent_mcp-0.2.35 → fast_agent_mcp-0.2.36}/src/mcp_agent/llm/providers/augmented_llm_azure.py

@@ -1,4 +1,4 @@
-from openai import AuthenticationError, AzureOpenAI, OpenAI
+from openai import AsyncAzureOpenAI, AsyncOpenAI, AuthenticationError
 
 from mcp_agent.core.exceptions import ProviderKeyError
 from mcp_agent.llm.provider_types import Provider
@@ -93,7 +93,7 @@ class AzureOpenAIAugmentedLLM(OpenAIAugmentedLLM):
             if not self.resource_name and self.base_url:
                 self.resource_name = _extract_resource_name(self.base_url)
 
-    def _openai_client(self) -> OpenAI:
+    def _openai_client(self) -> AsyncOpenAI:
         """
         Returns an AzureOpenAI client, handling both API Key and DefaultAzureCredential.
         """
@@ -104,7 +104,7 @@ class AzureOpenAIAugmentedLLM(OpenAIAugmentedLLM):
                         "Missing Azure endpoint",
                         "azure_endpoint (base_url) is None at client creation time.",
                     )
-                return AzureOpenAI(
+                return AsyncAzureOpenAI(
                     azure_ad_token_provider=self.get_azure_token,
                     azure_endpoint=self.base_url,
                     api_version=self.api_version,
@@ -116,7 +116,7 @@ class AzureOpenAIAugmentedLLM(OpenAIAugmentedLLM):
                         "Missing Azure endpoint",
                         "azure_endpoint (base_url) is None at client creation time.",
                     )
-                return AzureOpenAI(
+                return AsyncAzureOpenAI(
                     api_key=self.api_key,
                     azure_endpoint=self.base_url,
                     api_version=self.api_version,