fast-agent-mcp 0.3.14__py3-none-any.whl → 0.3.16__py3-none-any.whl

fast_agent/__init__.py

@@ -23,6 +23,7 @@ from fast_agent.config import (
     OpenRouterSettings,
     OpenTelemetrySettings,
     Settings,
+    SkillsSettings,
     TensorZeroSettings,
     XAISettings,
 )
@@ -126,6 +127,7 @@ __all__ = [
     "BedrockSettings",
     "HuggingFaceSettings",
     "LoggerSettings",
+    "SkillsSettings",
     # Progress and event tracking (lazy loaded)
     "ProgressAction",
     "ProgressEvent",

fast_agent/agents/agent_types.py

@@ -4,10 +4,13 @@ Type definitions for agents and agent configurations.
 
 from dataclasses import dataclass, field
 from enum import StrEnum, auto
+from pathlib import Path
 from typing import Dict, List, Optional
 
 from mcp.client.session import ElicitationFnT
 
+from fast_agent.skills import SkillManifest, SkillRegistry
+
 # Forward imports to avoid circular dependencies
 from fast_agent.types import RequestParams
 
@@ -36,6 +39,8 @@ class AgentConfig:
     tools: Optional[Dict[str, List[str]]] = None
     resources: Optional[Dict[str, List[str]]] = None
     prompts: Optional[Dict[str, List[str]]] = None
+    skills: SkillManifest | SkillRegistry | Path | str | None = None
+    skill_manifests: List[SkillManifest] = field(default_factory=list, repr=False)
     model: str | None = None
     use_history: bool = True
     default_request_params: RequestParams | None = None

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,52 @@ 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
+            remove_tool_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)
+                    remove_tool_listener = self.llm.add_tool_stream_listener(
+                        stream_handle.handle_tool_event
+                    )
+                except Exception:
+                    remove_listener = None
+                    remove_tool_listener = None
+
+                try:
+                    result, summary = await self._generate_with_summary(
+                        messages, request_params, tools
+                    )
+                finally:
+                    if remove_listener:
+                        remove_listener()
+                    if remove_tool_listener:
+                        remove_tool_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/llm_decorator.py

@@ -718,6 +718,12 @@ class LlmDecorator(AgentProtocol):
             return self._llm.message_history
         return []
 
+    def pop_last_message(self) -> PromptMessageExtended | None:
+        """Remove and return the most recent message from the conversation history."""
+        if self._llm:
+            return self._llm.pop_last_message()
+        return None
+
     @property
     def usage_accumulator(self) -> UsageAccumulator | None:
         """

fast_agent/agents/mcp_agent.py

@@ -42,12 +42,15 @@ from fast_agent.core.exceptions import PromptExitError
 from fast_agent.core.logging.logger import get_logger
 from fast_agent.interfaces import FastAgentLLMProtocol
 from fast_agent.mcp.mcp_aggregator import MCPAggregator, ServerStatus
+from fast_agent.skills.registry import format_skills_for_prompt
 from fast_agent.tools.elicitation import (
     get_elicitation_tool,
     run_elicitation_form,
     set_elicitation_input_callback,
 )
+from fast_agent.tools.shell_runtime import ShellRuntime
 from fast_agent.types import PromptMessageExtended, RequestParams
+from fast_agent.ui import console
 
 # Define a TypeVar for models
 ModelT = TypeVar("ModelT", bound=BaseModel)
@@ -59,6 +62,7 @@ if TYPE_CHECKING:
 
     from fast_agent.context import Context
     from fast_agent.llm.usage_tracking import UsageAccumulator
+    from fast_agent.skills import SkillManifest
 
 
 class McpAgent(ABC, ToolAgent):
@@ -73,7 +77,6 @@ class McpAgent(ABC, ToolAgent):
         self,
         config: AgentConfig,
         connection_persistence: bool = True,
-        # legacy human_input_callback removed
         context: "Context | None" = None,
         **kwargs,
     ) -> None:
@@ -96,6 +99,69 @@ class McpAgent(ABC, ToolAgent):
         self.instruction = self.config.instruction
         self.executor = context.executor if context else None
         self.logger = get_logger(f"{__name__}.{self._name}")
+        manifests: List[SkillManifest] = list(getattr(self.config, "skill_manifests", []) or [])
+        if not manifests and context and getattr(context, "skill_registry", None):
+            try:
+                manifests = list(context.skill_registry.load_manifests())  # type: ignore[assignment]
+            except Exception:
+                manifests = []
+
+        self._skill_manifests = list(manifests)
+        self._skill_map: Dict[str, SkillManifest] = {
+            manifest.name: manifest for manifest in manifests
+        }
+        self._agent_skills_warning_shown = False
+        shell_flag_requested = bool(context and getattr(context, "shell_runtime", False))
+        skills_configured = bool(self._skill_manifests)
+        self._shell_runtime_activation_reason: str | None = None
+
+        if shell_flag_requested and skills_configured:
+            self._shell_runtime_activation_reason = (
+                "via --shell flag and agent skills configuration"
+            )
+        elif shell_flag_requested:
+            self._shell_runtime_activation_reason = "via --shell flag"
+        elif skills_configured:
+            self._shell_runtime_activation_reason = "because agent skills are configured"
+
+        # Get timeout configuration from context
+        timeout_seconds = 90  # default
+        warning_interval_seconds = 30  # default
+        if context and context.config:
+            shell_config = getattr(context.config, "shell_execution", None)
+            if shell_config:
+                timeout_seconds = getattr(shell_config, "timeout_seconds", 90)
+                warning_interval_seconds = getattr(shell_config, "warning_interval_seconds", 30)
+
+        # Derive skills directory from this agent's manifests (respects per-agent config)
+        skills_directory = None
+        if self._skill_manifests:
+            # Get the skills directory from the first manifest's path
+            # Path structure: .fast-agent/skills/skill-name/SKILL.md
+            # So we need parent.parent of the manifest path
+            first_manifest = self._skill_manifests[0]
+            if first_manifest.path:
+                skills_directory = first_manifest.path.parent.parent
+
+        self._shell_runtime = ShellRuntime(
+            self._shell_runtime_activation_reason,
+            self.logger,
+            timeout_seconds=timeout_seconds,
+            warning_interval_seconds=warning_interval_seconds,
+            skills_directory=skills_directory,
+        )
+        self._shell_runtime_enabled = self._shell_runtime.enabled
+        self._shell_access_modes: tuple[str, ...] = ()
+        if self._shell_runtime_enabled:
+            modes: list[str] = ["[red]direct[/red]"]
+            if skills_configured:
+                modes.append("skills")
+            if shell_flag_requested:
+                modes.append("command switch")
+            self._shell_access_modes = tuple(modes)
+        self._bash_tool = self._shell_runtime.tool
+        if self._shell_runtime_enabled:
+            self._shell_runtime.announce()
 
         # Store the default request params from config
         self._default_request_params = self.config.default_request_params
@@ -207,6 +273,24 @@ class McpAgent(ABC, ToolAgent):
                 "{{serverInstructions}}", server_instructions
             )
 
+        skills_placeholder_present = "{{agentSkills}}" in self.instruction
+
+        if skills_placeholder_present:
+            agent_skills = format_skills_for_prompt(self._skill_manifests)
+            self.instruction = self.instruction.replace("{{agentSkills}}", agent_skills)
+            self._agent_skills_warning_shown = True
+        elif self._skill_manifests and not self._agent_skills_warning_shown:
+            warning_message = (
+                "Agent skills are configured but the system prompt does not include {{agentSkills}}. "
+                "Skill descriptions will not be added to the system prompt."
+            )
+            self.logger.warning(warning_message)
+            try:
+                console.console.print(f"[yellow]{warning_message}[/yellow]")
+            except Exception:  # pragma: no cover - console fallback
+                pass
+            self._agent_skills_warning_shown = True
+
         # Update default request params to match
         if self._default_request_params:
             self._default_request_params.systemPrompt = self.instruction
@@ -315,11 +399,12 @@ class McpAgent(ABC, ToolAgent):
         """
         # Get all tools from the aggregator
         result = await self._aggregator.list_tools()
+        aggregator_tools = list(result.tools)
 
         # Apply filtering if tools are specified in config
         if self.config.tools is not None:
             filtered_tools = []
-            for tool in result.tools:
+            for tool in aggregator_tools:
                 # Extract server name from tool name, handling server names with hyphens
                 server_name = None
                 for configured_server in self.config.tools.keys():
@@ -334,7 +419,12 @@ class McpAgent(ABC, ToolAgent):
                         if self._matches_pattern(tool.name, pattern, server_name):
                             filtered_tools.append(tool)
                             break
-            result.tools = filtered_tools
+            aggregator_tools = filtered_tools
+
+        result.tools = aggregator_tools
+
+        if self._bash_tool and all(tool.name != self._bash_tool.name for tool in result.tools):
+            result.tools.append(self._bash_tool)
 
         # Append human input tool if enabled and available
         if self.config.human_input and getattr(self, "_human_input_tool", None):
@@ -353,6 +443,9 @@ class McpAgent(ABC, ToolAgent):
         Returns:
             Result of the tool call
         """
+        if self._shell_runtime.tool and name == self._shell_runtime.tool.name:
+            return await self._shell_runtime.execute(arguments)
+
         if name == HUMAN_INPUT_TOOL_NAME:
             # Call the elicitation-backed human input tool
             return await self._call_human_input_tool(arguments)
@@ -608,13 +701,17 @@ 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 = [
             namespaced_tool.tool.name
             for namespaced_tool in self._aggregator._namespaced_tool_map.values()
         ]
+        if self._shell_runtime.tool:
+            available_tools.append(self._shell_runtime.tool.name)
+
+        available_tools = list(dict.fromkeys(available_tools))
 
         # Process each tool call using our aggregator
         for correlation_id, tool_request in request.tool_calls.items():
@@ -628,6 +725,8 @@ class McpAgent(ABC, ToolAgent):
             tool_available = False
             if tool_name == HUMAN_INPUT_TOOL_NAME:
                 tool_available = True
+            elif self._bash_tool and tool_name == self._bash_tool.name:
+                tool_available = True
             elif namespaced_tool:
                 tool_available = True
             else:
@@ -639,7 +738,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,
@@ -654,6 +753,14 @@ class McpAgent(ABC, ToolAgent):
                 # Tool not found in list, no highlighting
                 pass
 
+            metadata: dict[str, Any] | None = None
+            if (
+                self._shell_runtime_enabled
+                and self._shell_runtime.tool
+                and display_tool_name == self._shell_runtime.tool.name
+            ):
+                metadata = self._shell_runtime.metadata(tool_args.get("command"))
+
             self.display.show_tool_call(
                 name=self._name,
                 tool_args=tool_args,
@@ -661,10 +768,11 @@ class McpAgent(ABC, ToolAgent):
                 tool_name=display_tool_name,
                 highlight_index=highlight_index,
                 max_item_length=12,
+                metadata=metadata,
             )
 
             try:
-                # Use our aggregator to call the MCP tool
+                # Use the appropriate handler for this tool
                 result = await self.call_tool(tool_name, tool_args)
                 tool_results[correlation_id] = result
 
@@ -675,12 +783,13 @@ class McpAgent(ABC, ToolAgent):
                         namespaced_tool.server_name
                     )
 
-                self.display.show_tool_result(
-                    name=self._name,
-                    result=result,
-                    tool_name=display_tool_name,
-                    skybridge_config=skybridge_config,
-                )
+                if not getattr(result, "_suppress_display", False):
+                    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:
@@ -694,7 +803,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:
         """
@@ -873,6 +982,9 @@ class McpAgent(ABC, ToolAgent):
 
             result[special_server_name].append(self._human_input_tool)
 
+        # if self._skill_lookup_tool:
+        #     result.setdefault("__skills__", []).append(self._skill_lookup_tool)
+
         return result
 
     @property
@@ -985,6 +1097,18 @@ class McpAgent(ABC, ToolAgent):
         Convert a Tool to an AgentSkill.
         """
 
+        if tool.name in self._skill_map:
+            manifest = self._skill_map[tool.name]
+            return AgentSkill(
+                id=f"skill:{manifest.name}",
+                name=manifest.name,
+                description=manifest.description or "",
+                tags=["skill"],
+                examples=None,
+                input_modes=None,
+                output_modes=None,
+            )
+
         _, tool_without_namespace = await self._parse_resource_name(tool.name, "tool")
         return AgentSkill(
             id=tool.name,

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/__main__.py

@@ -1,3 +1,5 @@
+import asyncio
+import json
 import sys
 
 from fast_agent.cli.constants import GO_SPECIFIC_OPTIONS, KNOWN_SUBCOMMANDS
@@ -8,6 +10,39 @@ from fast_agent.cli.main import app
 
 def main():
     """Main entry point that handles auto-routing to 'go' command."""
+    try:
+        loop = asyncio.get_event_loop()
+
+        def _log_asyncio_exception(loop: asyncio.AbstractEventLoop, context: dict) -> None:
+            import logging
+
+            logger = logging.getLogger("fast_agent.asyncio")
+
+            message = context.get("message", "(no message)")
+            task = context.get("task")
+            future = context.get("future")
+            handle = context.get("handle")
+            source_traceback = context.get("source_traceback")
+            exception = context.get("exception")
+
+            details = {
+                "message": message,
+                "task": repr(task) if task else None,
+                "future": repr(future) if future else None,
+                "handle": repr(handle) if handle else None,
+                "source_traceback": [str(frame) for frame in source_traceback] if source_traceback else None,
+            }
+
+            logger.error("Unhandled asyncio error: %s", message)
+            logger.error("Asyncio context: %s", json.dumps(details, indent=2))
+
+            if exception:
+                logger.exception("Asyncio exception", exc_info=exception)
+
+        loop.set_exception_handler(_log_asyncio_exception)
+    except RuntimeError:
+        # No running loop yet (rare for sync entry), safe to ignore
+        pass
     # Check if we should auto-route to 'go'
     if len(sys.argv) > 1:
         # Check if first arg is not already a subcommand