fast-agent-mcp 0.3.13__py3-none-any.whl → 0.3.15__py3-none-any.whl

fast_agent/agents/llm_agent.py

@@ -8,7 +8,7 @@ This class extends LlmDecorator with LLM-specific interaction behaviors includin
 - Chat display integration
 """
 
-from typing import List, Optional, Tuple
+from typing import Callable, List, Optional, Tuple
 
 try:
     from a2a.types import AgentCapabilities  # type: ignore
@@ -58,7 +58,16 @@ class LlmAgent(LlmDecorator):
         super().__init__(config=config, context=context)
 
         # Initialize display component
-        self.display = ConsoleDisplay(config=self._context.config if self._context else None)
+        self._display = ConsoleDisplay(config=self._context.config if self._context else None)
+
+    @property
+    def display(self) -> ConsoleDisplay:
+        """UI display helper for presenting messages and tool activity."""
+        return self._display
+
+    @display.setter
+    def display(self, value: ConsoleDisplay) -> None:
+        self._display = value
 
     async def show_assistant_message(
         self,
@@ -139,7 +148,10 @@ class LlmAgent(LlmDecorator):
                         else:
                             # Fallback if we couldn't extract text
                             additional_segments.append(
-                                Text(f"\n\nError details: {str(error_blocks[0])}", style="dim red italic")
+                                Text(
+                                    f"\n\nError details: {str(error_blocks[0])}",
+                                    style="dim red italic",
+                                )
                             )
                 else:
                     # Fallback if no detailed error is available
@@ -206,6 +218,13 @@ class LlmAgent(LlmDecorator):
         chat_turn = self._llm.chat_turn()
         self.display.show_user_message(message.last_text() or "", model, chat_turn, name=self.name)
 
+    def _should_stream(self) -> bool:
+        """Determine whether streaming display should be used."""
+        if getattr(self, "display", None):
+            enabled, _ = self.display.resolve_streaming_preferences()
+            return enabled
+        return True
+
     async def generate_impl(
         self,
         messages: List[PromptMessageExtended],
@@ -219,13 +238,46 @@ class LlmAgent(LlmDecorator):
         if "user" == messages[-1].role:
             self.show_user_message(message=messages[-1])
 
-        # TODO -- we should merge the request parameters here with the LLM defaults?
         # TODO - manage error catch, recovery, pause
-        result, summary = await self._generate_with_summary(messages, request_params, tools)
+        summary_text: Text | None = None
 
-        summary_text = Text(f"\n\n{summary.message}", style="dim red italic") if summary else None
+        if self._should_stream():
+            display_name = self.name
+            display_model = self.llm.model_name if self._llm else None
+
+            remove_listener: Callable[[], None] | None = None
+
+            with self.display.streaming_assistant_message(
+                name=display_name,
+                model=display_model,
+            ) as stream_handle:
+                try:
+                    remove_listener = self.llm.add_stream_listener(stream_handle.update)
+                except Exception:
+                    remove_listener = None
+
+                try:
+                    result, summary = await self._generate_with_summary(
+                        messages, request_params, tools
+                    )
+                finally:
+                    if remove_listener:
+                        remove_listener()
+
+                if summary:
+                    summary_text = Text(f"\n\n{summary.message}", style="dim red italic")
+
+                stream_handle.finalize(result)
+
+            await self.show_assistant_message(result, additional_message=summary_text)
+        else:
+            result, summary = await self._generate_with_summary(messages, request_params, tools)
+
+            summary_text = (
+                Text(f"\n\n{summary.message}", style="dim red italic") if summary else None
+            )
+            await self.show_assistant_message(result, additional_message=summary_text)
 
-        await self.show_assistant_message(result, additional_message=summary_text)
         return result
 
     async def structured_impl(
@@ -243,33 +295,3 @@ class LlmAgent(LlmDecorator):
         summary_text = Text(f"\n\n{summary.message}", style="dim red italic") if summary else None
         await self.show_assistant_message(message=message, additional_message=summary_text)
         return result, message
-
-    # async def show_prompt_loaded(
-    #     self,
-    #     prompt_name: str,
-    #     description: Optional[str] = None,
-    #     message_count: int = 0,
-    #     arguments: Optional[dict[str, str]] = None,
-    # ) -> None:
-    #     """
-    #     Display information about a loaded prompt template.
-
-    #     Args:
-    #         prompt_name: The name of the prompt
-    #         description: Optional description of the prompt
-    #         message_count: Number of messages in the prompt
-    #         arguments: Optional dictionary of arguments passed to the prompt
-    #     """
-    #     # Get aggregator from attached LLM if available
-    #     aggregator = None
-    #     if self._llm and hasattr(self._llm, "aggregator"):
-    #         aggregator = self._llm.aggregator
-
-    #     await self.display.show_prompt_loaded(
-    #         prompt_name=prompt_name,
-    #         description=description,
-    #         message_count=message_count,
-    #         agent_name=self.name,
-    #         aggregator=aggregator,
-    #         arguments=arguments,
-    #     )

fast_agent/agents/llm_decorator.py

@@ -110,6 +110,11 @@ class LlmDecorator(AgentProtocol):
         self._llm: Optional[FastAgentLLMProtocol] = None
         self._initialized = False
 
+    @property
+    def context(self) -> Context | None:
+        """Optional execution context supplied at construction time."""
+        return self._context
+
     @property
     def initialized(self) -> bool:
         """Check if the agent is initialized."""
@@ -243,9 +248,12 @@ class LlmDecorator(AgentProtocol):
         """
         # Normalize all input types to a list of PromptMessageExtended
         multipart_messages = normalize_to_extended_list(messages)
+        final_request_params = (
+            self.llm.get_request_params(request_params) if self._llm else request_params
+        )
 
         with self._tracer.start_as_current_span(f"Agent: '{self._name}' generate"):
-            return await self.generate_impl(multipart_messages, request_params, tools)
+            return await self.generate_impl(multipart_messages, final_request_params, tools)
 
     async def generate_impl(
         self,
@@ -352,9 +360,12 @@ class LlmDecorator(AgentProtocol):
         """
         # Normalize all input types to a list of PromptMessageExtended
         multipart_messages = normalize_to_extended_list(messages)
+        final_request_params = (
+            self.llm.get_request_params(request_params) if self._llm else request_params
+        )
 
         with self._tracer.start_as_current_span(f"Agent: '{self._name}' structured"):
-            return await self.structured_impl(multipart_messages, model, request_params)
+            return await self.structured_impl(multipart_messages, model, final_request_params)
 
     async def structured_impl(
         self,

fast_agent/agents/mcp_agent.py

@@ -169,6 +169,11 @@ class McpAgent(ABC, ToolAgent):
             return {}
         return await self._aggregator.collect_server_status()
 
+    @property
+    def aggregator(self) -> MCPAggregator:
+        """Expose the MCP aggregator for UI integrations."""
+        return self._aggregator
+
     @property
     def initialized(self) -> bool:
         """Check if both the agent and aggregator are initialized."""
@@ -603,7 +608,7 @@ class McpAgent(ABC, ToolAgent):
             return PromptMessageExtended(role="user", tool_results={})
 
         tool_results: dict[str, CallToolResult] = {}
-        self._tool_loop_error = None
+        tool_loop_error: str | None = None
 
         # Cache available tool names (original, not namespaced) for display
         available_tools = [
@@ -634,7 +639,7 @@ class McpAgent(ABC, ToolAgent):
             if not tool_available:
                 error_message = f"Tool '{display_tool_name}' is not available"
                 self.logger.error(error_message)
-                self._mark_tool_loop_error(
+                tool_loop_error = self._mark_tool_loop_error(
                     correlation_id=correlation_id,
                     error_message=error_message,
                     tool_results=tool_results,
@@ -664,7 +669,18 @@ class McpAgent(ABC, ToolAgent):
                 tool_results[correlation_id] = result
 
                 # Show tool result (like ToolAgent does)
-                self.display.show_tool_result(name=self._name, result=result)
+                skybridge_config = None
+                if namespaced_tool:
+                    skybridge_config = await self._aggregator.get_skybridge_config(
+                        namespaced_tool.server_name
+                    )
+
+                self.display.show_tool_result(
+                    name=self._name,
+                    result=result,
+                    tool_name=display_tool_name,
+                    skybridge_config=skybridge_config,
+                )
 
                 self.logger.debug(f"MCP tool {display_tool_name} executed successfully")
             except Exception as e:
@@ -675,10 +691,10 @@ class McpAgent(ABC, ToolAgent):
                 )
                 tool_results[correlation_id] = error_result
 
-                # Show error result too
+                # Show error result too (no need for skybridge config on errors)
                 self.display.show_tool_result(name=self._name, result=error_result)
 
-        return self._finalize_tool_results(tool_results)
+        return self._finalize_tool_results(tool_results, tool_loop_error=tool_loop_error)
 
     async def apply_prompt_template(self, prompt_result: GetPromptResult, prompt_name: str) -> str:
         """

fast_agent/agents/tool_agent.py

@@ -5,7 +5,11 @@ from mcp.types import CallToolResult, ListToolsResult, Tool
 
 from fast_agent.agents.agent_types import AgentConfig
 from fast_agent.agents.llm_agent import LlmAgent
-from fast_agent.constants import FAST_AGENT_ERROR_CHANNEL, HUMAN_INPUT_TOOL_NAME
+from fast_agent.constants import (
+    DEFAULT_MAX_ITERATIONS,
+    FAST_AGENT_ERROR_CHANNEL,
+    HUMAN_INPUT_TOOL_NAME,
+)
 from fast_agent.context import Context
 from fast_agent.core.logging.logger import get_logger
 from fast_agent.mcp.helpers.content_helpers import text_content
@@ -15,13 +19,6 @@ from fast_agent.types.llm_stop_reason import LlmStopReason
 
 logger = get_logger(__name__)
 
-DEFAULT_MAX_TOOL_CALLS = 20
-
-
-# should we have MAX_TOOL_CALLS instead to constrain by number of tools rather than turns...?
-DEFAULT_MAX_ITERATIONS = 20
-"""Maximum number of User/Assistant turns to take"""
-
 
 class ToolAgent(LlmAgent):
     """
@@ -42,7 +39,6 @@ class ToolAgent(LlmAgent):
 
         self._execution_tools: dict[str, FastMCPTool] = {}
         self._tool_schemas: list[Tool] = []
-        self._tool_loop_error: str | None = None
 
         # Build a working list of tools and auto-inject human-input tool if missing
         working_tools: list[FastMCPTool | Callable] = list(tools) if tools else []
@@ -91,6 +87,7 @@ class ToolAgent(LlmAgent):
             tools = (await self.list_tools()).tools
 
         iterations = 0
+        max_iterations = request_params.max_iterations if request_params else DEFAULT_MAX_ITERATIONS
 
         while True:
             result = await super().generate_impl(
@@ -98,24 +95,29 @@ class ToolAgent(LlmAgent):
             )
 
             if LlmStopReason.TOOL_USE == result.stop_reason:
-                self._tool_loop_error = None
+                tool_message = await self.run_tools(result)
+                error_channel_messages = (tool_message.channels or {}).get(FAST_AGENT_ERROR_CHANNEL)
+                if error_channel_messages:
+                    tool_result_contents = [
+                        content
+                        for tool_result in (tool_message.tool_results or {}).values()
+                        for content in tool_result.content
+                    ]
+                    if tool_result_contents:
+                        if result.content is None:
+                            result.content = []
+                        result.content.extend(tool_result_contents)
+                    result.stop_reason = LlmStopReason.ERROR
+                    break
                 if self.config.use_history:
-                    tool_message = await self.run_tools(result)
-                    if self._tool_loop_error:
-                        result.stop_reason = LlmStopReason.ERROR
-                        break
                     messages = [tool_message]
                 else:
-                    tool_message = await self.run_tools(result)
-                    if self._tool_loop_error:
-                        result.stop_reason = LlmStopReason.ERROR
-                        break
                     messages.extend([result, tool_message])
             else:
                 break
 
             iterations += 1
-            if iterations > DEFAULT_MAX_ITERATIONS:
+            if iterations > max_iterations:
                 logger.warning("Max iterations reached, stopping tool loop")
                 break
         return result
@@ -133,7 +135,7 @@ class ToolAgent(LlmAgent):
             return PromptMessageExtended(role="user", tool_results={})
 
         tool_results: dict[str, CallToolResult] = {}
-        self._tool_loop_error = None
+        tool_loop_error: str | None = None
         # TODO -- use gather() for parallel results, update display
         available_tools = [t.name for t in (await self.list_tools()).tools]
         for correlation_id, tool_request in request.tool_calls.items():
@@ -143,7 +145,7 @@ class ToolAgent(LlmAgent):
             if tool_name not in self._execution_tools:
                 error_message = f"Tool '{tool_name}' is not available"
                 logger.error(error_message)
-                self._mark_tool_loop_error(
+                tool_loop_error = self._mark_tool_loop_error(
                     correlation_id=correlation_id,
                     error_message=error_message,
                     tool_results=tool_results,
@@ -170,9 +172,9 @@ class ToolAgent(LlmAgent):
             # Delegate to call_tool for execution (overridable by subclasses)
             result = await self.call_tool(tool_name, tool_args)
             tool_results[correlation_id] = result
-            self.display.show_tool_result(name=self.name, result=result)
+            self.display.show_tool_result(name=self.name, result=result, tool_name=tool_name)
 
-        return self._finalize_tool_results(tool_results)
+        return self._finalize_tool_results(tool_results, tool_loop_error=tool_loop_error)
 
     def _mark_tool_loop_error(
         self,
@@ -180,24 +182,34 @@ class ToolAgent(LlmAgent):
         correlation_id: str,
         error_message: str,
         tool_results: dict[str, CallToolResult],
-    ) -> None:
+    ) -> str:
         error_result = CallToolResult(
             content=[text_content(error_message)],
             isError=True,
         )
         tool_results[correlation_id] = error_result
         self.display.show_tool_result(name=self.name, result=error_result)
-        self._tool_loop_error = error_message
+        return error_message
 
     def _finalize_tool_results(
-        self, tool_results: dict[str, CallToolResult]
+        self,
+        tool_results: dict[str, CallToolResult],
+        *,
+        tool_loop_error: str | None = None,
     ) -> PromptMessageExtended:
         channels = None
-        if self._tool_loop_error:
+        content = []
+        if tool_loop_error:
+            content.append(text_content(tool_loop_error))
             channels = {
-                FAST_AGENT_ERROR_CHANNEL: [text_content(self._tool_loop_error)],
+                FAST_AGENT_ERROR_CHANNEL: [text_content(tool_loop_error)],
             }
-        return PromptMessageExtended(role="user", tool_results=tool_results, channels=channels)
+        return PromptMessageExtended(
+            role="user",
+            content=content,
+            tool_results=tool_results,
+            channels=channels,
+        )
 
     async def list_tools(self) -> ListToolsResult:
         """Return available tools for this agent. Overridable by subclasses."""

fast_agent/agents/workflow/router_agent.py

@@ -213,7 +213,8 @@ class RouterAgent(LlmAgent):
             agent: LlmAgent = self.agent_map[route.agent]
 
             # Dispatch the request to the selected agent
-            return await agent.generate_impl(messages, request_params)
+            # discarded request_params: use llm defaults for subagents
+            return await agent.generate_impl(messages)
 
     async def structured_impl(
         self,

fast_agent/cli/commands/check_config.py

@@ -144,7 +144,7 @@ def get_fastagent_version() -> str:
 
 def get_config_summary(config_path: Optional[Path]) -> dict:
     """Extract key information from the configuration file."""
-    from fast_agent.config import Settings
+    from fast_agent.config import MCPTimelineSettings, Settings
 
     # Get actual defaults from Settings class
     default_settings = Settings()
@@ -156,6 +156,7 @@ def get_config_summary(config_path: Optional[Path]) -> dict:
         "logger": {
             "level": default_settings.logger.level,
             "type": default_settings.logger.type,
+            "streaming": default_settings.logger.streaming,
             "progress_display": default_settings.logger.progress_display,
             "show_chat": default_settings.logger.show_chat,
             "show_tools": default_settings.logger.show_tools,
@@ -163,6 +164,10 @@ def get_config_summary(config_path: Optional[Path]) -> dict:
             "enable_markup": default_settings.logger.enable_markup,
         },
         "mcp_ui_mode": default_settings.mcp_ui_mode,
+        "timeline": {
+            "steps": default_settings.mcp_timeline.steps,
+            "step_seconds": default_settings.mcp_timeline.step_seconds,
+        },
         "mcp_servers": [],
     }
 
@@ -194,6 +199,7 @@ def get_config_summary(config_path: Optional[Path]) -> dict:
             result["logger"] = {
                 "level": logger_config.get("level", default_settings.logger.level),
                 "type": logger_config.get("type", default_settings.logger.type),
+                "streaming": logger_config.get("streaming", default_settings.logger.streaming),
                 "progress_display": logger_config.get(
                     "progress_display", default_settings.logger.progress_display
                 ),
@@ -211,6 +217,21 @@ def get_config_summary(config_path: Optional[Path]) -> dict:
         if "mcp_ui_mode" in config:
             result["mcp_ui_mode"] = config["mcp_ui_mode"]
 
+        # Get timeline settings
+        if "mcp_timeline" in config:
+            try:
+                timeline_override = MCPTimelineSettings(**(config.get("mcp_timeline") or {}))
+            except Exception as exc:  # pragma: no cover - defensive
+                console.print(
+                    "[yellow]Warning:[/yellow] Invalid mcp_timeline configuration; using defaults."
+                )
+                console.print(f"[yellow]Details:[/yellow] {exc}")
+            else:
+                result["timeline"] = {
+                    "steps": timeline_override.steps,
+                    "step_seconds": timeline_override.step_seconds,
+                }
+
         # Get MCP server info
         if "mcp" in config and "servers" in config["mcp"]:
             for server_name, server_config in config["mcp"]["servers"].items():
@@ -385,16 +406,42 @@ def show_check_summary() -> None:
     else:
         mcp_ui_display = f"[green]{mcp_ui_mode}[/green]"
 
+    timeline_settings = config_summary.get("timeline", {})
+    timeline_steps = timeline_settings.get("steps", 20)
+    timeline_step_seconds = timeline_settings.get("step_seconds", 30)
+
+    def format_step_interval(seconds: int) -> str:
+        try:
+            total = int(seconds)
+        except (TypeError, ValueError):
+            return str(seconds)
+        if total <= 0:
+            return "0s"
+        if total % 86400 == 0:
+            return f"{total // 86400}d"
+        if total % 3600 == 0:
+            return f"{total // 3600}h"
+        if total % 60 == 0:
+            return f"{total // 60}m"
+        minutes, secs = divmod(total, 60)
+        if minutes:
+            return f"{minutes}m{secs:02d}s"
+        return f"{secs}s"
+
     # Prepare all settings as pairs
     settings_data = [
         ("Log Level", logger.get("level", "warning (default)")),
         ("Log Type", logger.get("type", "file (default)")),
         ("MCP-UI", mcp_ui_display),
+        ("Streaming Mode", f"[green]{logger.get('streaming', 'markdown')}[/green]"),
+        ("Streaming Display", bool_to_symbol(logger.get("streaming_display", True))),
         ("Progress Display", bool_to_symbol(logger.get("progress_display", True))),
         ("Show Chat", bool_to_symbol(logger.get("show_chat", True))),
         ("Show Tools", bool_to_symbol(logger.get("show_tools", True))),
         ("Truncate Tools", bool_to_symbol(logger.get("truncate_tools", True))),
         ("Enable Markup", bool_to_symbol(logger.get("enable_markup", True))),
+        ("Timeline Steps", f"[green]{timeline_steps}[/green]"),
+        ("Timeline Interval", f"[green]{format_step_interval(timeline_step_seconds)}[/green]"),
     ]
 
     # Add rows in two-column layout, styling some values in green

fast_agent/config.py

@@ -49,6 +49,66 @@ class MCPElicitationSettings(BaseModel):
     model_config = ConfigDict(extra="allow", arbitrary_types_allowed=True)
 
 
+class MCPTimelineSettings(BaseModel):
+    """Configuration for MCP activity timeline display."""
+
+    steps: int = 20
+    """Number of timeline buckets to render."""
+
+    step_seconds: int = 30
+    """Duration of each timeline bucket in seconds."""
+
+    model_config = ConfigDict(extra="allow", arbitrary_types_allowed=True)
+
+    @staticmethod
+    def _parse_duration(value: str) -> int:
+        """Parse simple duration strings like '30s', '2m', '1h' into seconds."""
+        pattern = re.compile(r"^\s*(\d+)\s*([smhd]?)\s*$", re.IGNORECASE)
+        match = pattern.match(value)
+        if not match:
+            raise ValueError("Expected duration in seconds (e.g. 30, '45s', '2m').")
+        amount = int(match.group(1))
+        unit = match.group(2).lower()
+        multiplier = {
+            "": 1,
+            "s": 1,
+            "m": 60,
+            "h": 3600,
+            "d": 86400,
+        }.get(unit)
+        if multiplier is None:
+            raise ValueError("Duration unit must be one of s, m, h, or d.")
+        return amount * multiplier
+
+    @field_validator("steps", mode="before")
+    @classmethod
+    def _coerce_steps(cls, value: Any) -> int:
+        if isinstance(value, str):
+            if not value.strip().isdigit():
+                raise ValueError("Timeline steps must be a positive integer.")
+            value = int(value.strip())
+        elif isinstance(value, float):
+            value = int(value)
+        if not isinstance(value, int):
+            raise TypeError("Timeline steps must be an integer.")
+        if value <= 0:
+            raise ValueError("Timeline steps must be greater than zero.")
+        return value
+
+    @field_validator("step_seconds", mode="before")
+    @classmethod
+    def _coerce_step_seconds(cls, value: Any) -> int:
+        if isinstance(value, str):
+            value = cls._parse_duration(value)
+        elif isinstance(value, (int, float)):
+            value = int(value)
+        else:
+            raise TypeError("Timeline step duration must be a number of seconds.")
+        if value <= 0:
+            raise ValueError("Timeline step duration must be greater than zero.")
+        return value
+
+
 class MCPRootSettings(BaseModel):
     """Represents a root directory configuration for an MCP server."""
 
@@ -388,8 +448,8 @@ class LoggerSettings(BaseModel):
     """Truncate display of long tool calls"""
     enable_markup: bool = True
     """Enable markup in console output. Disable for outputs that may conflict with rich console formatting"""
-    use_legacy_display: bool = False
-    """Use the legacy console display instead of the new style display"""
+    streaming: Literal["markdown", "plain", "none"] = "markdown"
+    """Streaming renderer for assistant responses"""
 
 
 def find_fastagent_config_files(start_path: Path) -> Tuple[Optional[Path], Optional[Path]]:
@@ -528,6 +588,9 @@ class Settings(BaseSettings):
     mcp_ui_output_dir: str = ".fast-agent/ui"
     """Directory where MCP-UI HTML files are written. Relative paths are resolved from CWD."""
 
+    mcp_timeline: MCPTimelineSettings = MCPTimelineSettings()
+    """Display settings for MCP activity timelines."""
+
     @classmethod
     def find_config(cls) -> Path | None:
         """Find the config file in the current directory or parent directories."""

fast_agent/constants.py

@@ -8,3 +8,6 @@ MCP_UI = "mcp-ui"
 REASONING = "reasoning"
 FAST_AGENT_ERROR_CHANNEL = "fast-agent-error"
 FAST_AGENT_REMOVED_METADATA_CHANNEL = "fast-agent-removed-meta"
+# should we have MAX_TOOL_CALLS instead to constrain by number of tools rather than turns...?
+DEFAULT_MAX_ITERATIONS = 20
+"""Maximum number of User/Assistant turns to take"""