fast-agent-mcp 0.3.14__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
@@ -218,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],
@@ -232,11 +239,45 @@ class LlmAgent(LlmDecorator):
             self.show_user_message(message=messages[-1])
 
         # 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(

fast_agent/agents/mcp_agent.py

@@ -608,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 = [
@@ -639,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,
@@ -694,7 +694,7 @@ class McpAgent(ABC, ToolAgent):
                 # 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

@@ -39,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 []
@@ -96,18 +95,23 @@ 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
@@ -131,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():
@@ -141,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,7 +174,7 @@ class ToolAgent(LlmAgent):
             tool_results[correlation_id] = 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,
@@ -178,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

@@ -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,
@@ -198,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
                 ),
@@ -221,8 +223,7 @@ def get_config_summary(config_path: Optional[Path]) -> dict:
                 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."
+                    "[yellow]Warning:[/yellow] Invalid mcp_timeline configuration; using defaults."
                 )
                 console.print(f"[yellow]Details:[/yellow] {exc}")
             else:
@@ -432,6 +433,8 @@ def show_check_summary() -> None:
         ("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))),

fast_agent/config.py

@@ -448,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]]:

fast_agent/core/fastagent.py

@@ -293,7 +293,9 @@ class FastAgent:
             default: bool = False,
             elicitation_handler: Optional[ElicitationFnT] = None,
             api_key: str | None = None,
-        ) -> Callable[[Callable[P, Coroutine[Any, Any, R]]], Callable[P, Coroutine[Any, Any, R]]]: ...
+        ) -> Callable[
+            [Callable[P, Coroutine[Any, Any, R]]], Callable[P, Coroutine[Any, Any, R]]
+        ]: ...
 
         def custom(
             self,
@@ -474,6 +476,17 @@ class FastAgent:
                     # Create a wrapper with all agents for simplified access
                     wrapper = AgentApp(active_agents)
 
+                    # Disable streaming if parallel agents are present
+                    from fast_agent.agents.agent_types import AgentType
+
+                    has_parallel = any(
+                        agent.agent_type == AgentType.PARALLEL for agent in active_agents.values()
+                    )
+                    if has_parallel:
+                        cfg = self.app.context.config
+                        if cfg is not None and cfg.logger is not None:
+                            cfg.logger.streaming = "none"
+
                     # Handle command line options that should be processed after agent initialization
 
                     # Handle --server option

fast_agent/core/validation.py

@@ -200,6 +200,34 @@ def get_dependencies(
     return deps
 
 
+def get_agent_dependencies(agent_data: dict[str, Any]) -> set[str]:
+    deps: set[str] = set()
+    agent_dependency_attribute_names = {
+        AgentType.CHAIN: ("sequence",),
+        AgentType.EVALUATOR_OPTIMIZER: ("evaluator", "generator", "eval_optimizer_agents"),
+        AgentType.ITERATIVE_PLANNER: ("child_agents",),
+        AgentType.ORCHESTRATOR: ("child_agents",),
+        AgentType.PARALLEL: ("fan_out", "fan_in", "parallel_agents"),
+        AgentType.ROUTER: ("router_agents",),
+    }
+    agent_type = agent_data["type"]
+    dependency_names = agent_dependency_attribute_names.get(agent_type, None)
+    if dependency_names is None:
+        return deps
+
+    for dependency_name in dependency_names:
+        dependency_value = agent_data.get(dependency_name)
+        if dependency_value is None:
+            continue
+        if isinstance(dependency_value, str):
+            deps.add(dependency_value)
+        else:
+            # here, we have an implicit assumption that if it is not a None or a string, then it is a list
+            deps.update(dependency_value)
+
+    return deps
+
+
 def get_dependencies_groups(
     agents_dict: Dict[str, Dict[str, Any]], allow_cycles: bool = False
 ) -> List[List[str]]:
@@ -221,39 +249,9 @@ def get_dependencies_groups(
     agent_names = list(agents_dict.keys())
 
     # Dictionary to store dependencies for each agent
-    dependencies = {name: set() for name in agent_names}
-
-    # Build the dependency graph
-    for name, agent_data in agents_dict.items():
-        agent_type = agent_data["type"]  # This is a string from config
-
-        # Note: Compare string values from config with the Enum's string value
-        if agent_type == AgentType.PARALLEL.value:
-            # Parallel agents depend on their fan-out and fan-in agents
-            dependencies[name].update(agent_data.get("parallel_agents", []))
-            # Also add explicit fan_out dependencies if present
-            if "fan_out" in agent_data:
-                dependencies[name].update(agent_data["fan_out"])
-            # Add explicit fan_in dependency if present
-            if "fan_in" in agent_data and agent_data["fan_in"]:
-                dependencies[name].add(agent_data["fan_in"])
-        elif agent_type == AgentType.CHAIN.value:
-            # Chain agents depend on the agents in their sequence
-            dependencies[name].update(agent_data.get("sequence", []))
-        elif agent_type == AgentType.ROUTER.value:
-            # Router agents depend on the agents they route to
-            dependencies[name].update(agent_data.get("router_agents", []))
-        elif agent_type == AgentType.ORCHESTRATOR.value:
-            # Orchestrator agents depend on their child agents
-            dependencies[name].update(agent_data.get("child_agents", []))
-        elif agent_type == AgentType.EVALUATOR_OPTIMIZER.value:
-            # Evaluator-Optimizer agents depend on their evaluator and generator agents
-            if "evaluator" in agent_data:
-                dependencies[name].add(agent_data["evaluator"])
-            if "generator" in agent_data:
-                dependencies[name].add(agent_data["generator"])
-            # For backward compatibility - also check eval_optimizer_agents if present
-            dependencies[name].update(agent_data.get("eval_optimizer_agents", []))
+    dependencies = {
+        name: get_agent_dependencies(agent_data) for name, agent_data in agents_dict.items()
+    }
 
     # Check for cycles if not allowed
     if not allow_cycles:

fast_agent/human_input/form_fields.py

@@ -29,6 +29,8 @@ class StringField:
             schema["minLength"] = self.min_length
         if self.max_length is not None:
             schema["maxLength"] = self.max_length
+        if self.pattern is not None:
+            schema["pattern"] = self.pattern
         if self.format:
             schema["format"] = self.format
 
@@ -178,10 +180,11 @@ def string(
     default: Optional[str] = None,
     min_length: Optional[int] = None,
     max_length: Optional[int] = None,
+    pattern: Optional[str] = None,
     format: Optional[str] = None,
 ) -> StringField:
     """Create a string field."""
-    return StringField(title, description, default, min_length, max_length, format)
+    return StringField(title, description, default, min_length, max_length, pattern, format)
 
 
 def email(

fast_agent/interfaces.py

@@ -8,6 +8,7 @@ without pulling in MCP-specific code, helping to avoid circular imports.
 from typing import (
     TYPE_CHECKING,
     Any,
+    Callable,
     Dict,
     List,
     Mapping,
@@ -83,7 +84,9 @@ class FastAgentLLMProtocol(Protocol):
         self,
         request_params: RequestParams | None = None,
     ) -> RequestParams: ...
-        
+
+    def add_stream_listener(self, listener: Callable[[str], None]) -> Callable[[], None]: ...
+
     @property
     def message_history(self) -> List[PromptMessageExtended]: ...
 

fast_agent/llm/fastagent_llm.py

@@ -3,6 +3,7 @@ from contextvars import ContextVar
 from typing import (
     TYPE_CHECKING,
     Any,
+    Callable,
     Dict,
     Generic,
     List,
@@ -157,6 +158,7 @@ class FastAgentLLM(ContextDependent, FastAgentLLMProtocol, Generic[MessageParamT
 
         # Initialize usage tracking
         self._usage_accumulator = UsageAccumulator()
+        self._stream_listeners: set[Callable[[str], None]] = set()
 
     def _initialize_default_params(self, kwargs: dict) -> RequestParams:
         """Initialize default parameters for the LLM.
@@ -483,6 +485,8 @@ class FastAgentLLM(ContextDependent, FastAgentLLMProtocol, Generic[MessageParamT
         Returns:
             Updated estimated token count
         """
+        self._notify_stream_listeners(content)
+
         # Rough estimate: 1 token per 4 characters (OpenAI's typical ratio)
         text_length = len(content)
         additional_tokens = max(1, text_length // 4)
@@ -503,6 +507,33 @@ class FastAgentLLM(ContextDependent, FastAgentLLMProtocol, Generic[MessageParamT
 
         return new_total
 
+    def add_stream_listener(self, listener: Callable[[str], None]) -> Callable[[], None]:
+        """
+        Register a callback invoked with streaming text chunks.
+
+        Args:
+            listener: Callable receiving the text chunk emitted by the provider.
+
+        Returns:
+            A function that removes the listener when called.
+        """
+        self._stream_listeners.add(listener)
+
+        def remove() -> None:
+            self._stream_listeners.discard(listener)
+
+        return remove
+
+    def _notify_stream_listeners(self, chunk: str) -> None:
+        """Notify registered listeners with a streaming text chunk."""
+        if not chunk:
+            return
+        for listener in list(self._stream_listeners):
+            try:
+                listener(chunk)
+            except Exception:
+                self.logger.exception("Stream listener raised an exception")
+
     def _log_chat_finished(self, model: Optional[str] = None) -> None:
         """Log a chat finished event"""
         data = {

fast_agent/llm/model_database.py

@@ -130,11 +130,9 @@ class ModelDatabase:
         context_window=400000, max_output_tokens=128000, tokenizes=OPENAI_MULTIMODAL
     )
 
-    # TODO update to 32000
     ANTHROPIC_OPUS_4_VERSIONED = ModelParameters(
         context_window=200000, max_output_tokens=32000, tokenizes=ANTHROPIC_MULTIMODAL
     )
-    # TODO update to 64000
     ANTHROPIC_SONNET_4_VERSIONED = ModelParameters(
         context_window=200000, max_output_tokens=64000, tokenizes=ANTHROPIC_MULTIMODAL
     )
@@ -237,6 +235,8 @@ class ModelDatabase:
         "claude-opus-4-0": ANTHROPIC_OPUS_4_VERSIONED,
         "claude-opus-4-1": ANTHROPIC_OPUS_4_VERSIONED,
         "claude-opus-4-20250514": ANTHROPIC_OPUS_4_VERSIONED,
+        "claude-haiku-4-5-20251001": ANTHROPIC_SONNET_4_VERSIONED,
+        "claude-haiku-4-5": ANTHROPIC_SONNET_4_VERSIONED,
         # DeepSeek Models
         "deepseek-chat": DEEPSEEK_CHAT_STANDARD,
         # Google Gemini Models (vanilla aliases and versioned)

fast_agent/llm/model_factory.py

@@ -86,6 +86,7 @@ class ModelFactory:
         "claude-sonnet-4-0": Provider.ANTHROPIC,
         "claude-sonnet-4-5-20250929": Provider.ANTHROPIC,
         "claude-sonnet-4-5": Provider.ANTHROPIC,
+        "claude-haiku-4-5": Provider.ANTHROPIC,
         "deepseek-chat": Provider.DEEPSEEK,
         "gemini-2.0-flash": Provider.GOOGLE,
         "gemini-2.5-flash-preview-05-20": Provider.GOOGLE,
@@ -109,9 +110,10 @@ class ModelFactory:
         "sonnet35": "claude-3-5-sonnet-latest",
         "sonnet37": "claude-3-7-sonnet-latest",
         "claude": "claude-sonnet-4-0",
-        "haiku": "claude-3-5-haiku-latest",
+        "haiku": "claude-haiku-4-5",
         "haiku3": "claude-3-haiku-20240307",
         "haiku35": "claude-3-5-haiku-latest",
+        "hauku45": "claude-haiku-4-5",
         "opus": "claude-opus-4-1",
         "opus4": "claude-opus-4-1",
         "opus3": "claude-3-opus-latest",
@@ -319,6 +321,7 @@ class ModelFactory:
                 return GroqLLM
             if provider == Provider.RESPONSES:
                 from fast_agent.llm.provider.openai.responses import ResponsesLLM
+
                 return ResponsesLLM
 
         except Exception as e:

fast_agent/mcp/prompt_message_extended.py

@@ -1,4 +1,4 @@
-from typing import Dict, List, Optional
+from typing import Dict, List, Mapping, Optional, Sequence
 
 from mcp.types import (
     CallToolRequest,
@@ -27,7 +27,7 @@ class PromptMessageExtended(BaseModel):
     content: List[ContentBlock] = []
     tool_calls: Dict[str, CallToolRequest] | None = None
     tool_results: Dict[str, CallToolResult] | None = None
-    channels: Dict[str, List[ContentBlock]] | None = None
+    channels: Mapping[str, Sequence[ContentBlock]] | None = None
     stop_reason: LlmStopReason | None = None
 
     @classmethod

fast_agent/resources/setup/fastagent.config.yaml

@@ -16,9 +16,9 @@ default_model: gpt-5-mini.low
 # mcp_ui_mode: enabled
 
 # MCP timeline display (adjust activity window/intervals in MCP UI + fast-agent check)
-#mcp_timeline:
-#  steps: 20         # number of timeline buckets to render
-#  step_seconds: 30  # seconds per bucket (accepts values like "45s", "2m")
+mcp_timeline:
+  steps: 20 # number of timeline buckets to render
+  step_seconds: 15 # seconds per bucket (accepts values like "45s", "2m")
 
 # Logging and Console Configuration:
 logger:
@@ -28,13 +28,14 @@ logger:
 
   # Switch the progress display on or off
   progress_display: true
-
   # Show chat User/Assistant messages on the console
   show_chat: true
   # Show tool calls on the console
   show_tools: true
   # Truncate long tool responses on the console
   truncate_tools: true
+  # Streaming renderer for assistant responses: "markdown", "plain", or "none"
+  streaming: markdown
 
 # MCP Servers
 mcp: