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

fast_agent/core/fastagent.py

@@ -6,6 +6,7 @@ directly creates Agent instances without proxies.
 
 import argparse
 import asyncio
+import pathlib
 import sys
 from contextlib import asynccontextmanager
 from importlib.metadata import version as get_version
@@ -76,12 +77,14 @@ from fast_agent.core.validation import (
     validate_workflow_references,
 )
 from fast_agent.mcp.prompts.prompt_load import load_prompt
+from fast_agent.skills import SkillManifest, SkillRegistry
 from fast_agent.ui.usage_display import display_usage_report
 
 if TYPE_CHECKING:
     from mcp.client.session import ElicitationFnT
     from pydantic import AnyUrl
 
+    from fast_agent.constants import DEFAULT_AGENT_INSTRUCTION
     from fast_agent.interfaces import AgentProtocol
     from fast_agent.types import PromptMessageExtended
 
@@ -102,6 +105,7 @@ class FastAgent:
         ignore_unknown_args: bool = False,
         parse_cli_args: bool = True,
         quiet: bool = False,  # Add quiet parameter
+        skills_directory: str | pathlib.Path | None = None,
         **kwargs,
     ) -> None:
         """
@@ -119,6 +123,10 @@ class FastAgent:
         """
         self.args = argparse.Namespace()  # Initialize args always
         self._programmatic_quiet = quiet  # Store the programmatic quiet setting
+        self._skills_directory_override = (
+            Path(skills_directory).expanduser() if skills_directory else None
+        )
+        self._default_skill_manifests: List[SkillManifest] = []
 
         # --- Wrap argument parsing logic ---
         if parse_cli_args:
@@ -173,6 +181,10 @@ class FastAgent:
                 default="0.0.0.0",
                 help="Host address to bind to when running as a server with SSE transport",
             )
+            parser.add_argument(
+                "--skills",
+                help="Path to skills directory to use instead of default .claude/skills",
+            )
 
             if ignore_unknown_args:
                 known_args, _ = parser.parse_known_args()
@@ -200,6 +212,14 @@ class FastAgent:
         if self._programmatic_quiet:
             self.args.quiet = True
 
+        # Apply CLI skills directory if not already set programmatically
+        if (
+            self._skills_directory_override is None
+            and hasattr(self.args, "skills")
+            and self.args.skills
+        ):
+            self._skills_directory_override = Path(self.args.skills).expanduser()
+
         self.name = name
         self.config_path = config_path
 
@@ -271,6 +291,7 @@ class FastAgent:
         from collections.abc import Coroutine
         from pathlib import Path
 
+        from fast_agent.skills import SkillManifest, SkillRegistry
         from fast_agent.types import RequestParams
 
         P = ParamSpec("P")
@@ -281,11 +302,12 @@ class FastAgent:
             name: str = "default",
             instruction_or_kwarg: Optional[str | Path | AnyUrl] = None,
             *,
-            instruction: str | Path | AnyUrl = "You are a helpful agent.",
+            instruction: str | Path | AnyUrl = DEFAULT_AGENT_INSTRUCTION,
             servers: List[str] = [],
             tools: Optional[Dict[str, List[str]]] = None,
             resources: Optional[Dict[str, List[str]]] = None,
             prompts: Optional[Dict[str, List[str]]] = None,
+            skills: Optional[List[SkillManifest | SkillRegistry | Path | str | None]] = None,
             model: Optional[str] = None,
             use_history: bool = True,
             request_params: RequestParams | None = None,
@@ -293,7 +315,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,
@@ -428,6 +452,21 @@ class FastAgent:
         with tracer.start_as_current_span(self.name):
             try:
                 async with self.app.run():
+                    registry = getattr(self.context, "skill_registry", None)
+                    if self._skills_directory_override is not None:
+                        override_registry = SkillRegistry(
+                            base_dir=Path.cwd(),
+                            override_directory=self._skills_directory_override,
+                        )
+                        self.context.skill_registry = override_registry
+                        registry = override_registry
+
+                    default_skills: List[SkillManifest] = []
+                    if registry:
+                        default_skills = registry.load_manifests()
+
+                    self._apply_skills_to_agent_configs(default_skills)
+
                     # Apply quiet mode if requested
                     if quiet_mode:
                         cfg = self.app.context.config
@@ -474,6 +513,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
@@ -608,6 +658,69 @@ class FastAgent:
                         except Exception:
                             pass
 
+    def _apply_skills_to_agent_configs(self, default_skills: List[SkillManifest]) -> None:
+        self._default_skill_manifests = list(default_skills)
+
+        for agent_data in self.agents.values():
+            config_obj = agent_data.get("config")
+            if not config_obj:
+                continue
+
+            resolved = self._resolve_skills(config_obj.skills)
+            if not resolved:
+                resolved = list(default_skills)
+            else:
+                resolved = self._deduplicate_skills(resolved)
+
+            config_obj.skill_manifests = resolved
+
+    def _resolve_skills(
+        self,
+        entry: SkillManifest
+        | SkillRegistry
+        | Path
+        | str
+        | List[SkillManifest | SkillRegistry | Path | str | None]
+        | None,
+    ) -> List[SkillManifest]:
+        if entry is None:
+            return []
+        if isinstance(entry, list):
+            manifests: List[SkillManifest] = []
+            for item in entry:
+                manifests.extend(self._resolve_skills(item))
+            return manifests
+        if isinstance(entry, SkillManifest):
+            return [entry]
+        if isinstance(entry, SkillRegistry):
+            try:
+                return entry.load_manifests()
+            except Exception:
+                logger.debug(
+                    "Failed to load skills from registry",
+                    data={"registry": type(entry).__name__},
+                )
+                return []
+        if isinstance(entry, Path):
+            return SkillRegistry.load_directory(entry.expanduser().resolve())
+        if isinstance(entry, str):
+            return SkillRegistry.load_directory(Path(entry).expanduser().resolve())
+
+        logger.debug(
+            "Unsupported skill entry type",
+            data={"type": type(entry).__name__},
+        )
+        return []
+
+    @staticmethod
+    def _deduplicate_skills(manifests: List[SkillManifest]) -> List[SkillManifest]:
+        unique: Dict[str, SkillManifest] = {}
+        for manifest in manifests:
+            key = manifest.name.lower()
+            if key not in unique:
+                unique[key] = manifest
+        return list(unique.values())
+
     def _handle_error(self, e: Exception, error_type: Optional[str] = None) -> None:
         """
         Handle errors with consistent formatting and messaging.

fast_agent/core/logging/listeners.py

@@ -64,6 +64,14 @@ def convert_log_event(event: Event) -> "ProgressEvent | None":
         chat_turn = event_data.get("chat_turn")
         if chat_turn is not None:
             details = f"{model} turn {chat_turn}"
+
+        tool_name = event_data.get("tool_name")
+        tool_event = event_data.get("tool_event")
+        if tool_name:
+            tool_suffix = tool_name
+            if tool_event:
+                tool_suffix = f"{tool_suffix} ({tool_event})"
+            details = f"{details} • {tool_suffix}".strip()
     else:
         if not target:
             target = event_data.get("target", "unknown")

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,10 +84,18 @@ class FastAgentLLMProtocol(Protocol):
         self,
         request_params: RequestParams | None = None,
     ) -> RequestParams: ...
-        
+
+    def add_stream_listener(self, listener: Callable[[str], None]) -> Callable[[], None]: ...
+
+    def add_tool_stream_listener(
+        self, listener: Callable[[str, Dict[str, Any] | None], None]
+    ) -> Callable[[], None]: ...
+
     @property
     def message_history(self) -> List[PromptMessageExtended]: ...
 
+    def pop_last_message(self) -> PromptMessageExtended | None: ...
+
     @property
     def usage_accumulator(self) -> UsageAccumulator | None: ...
 
@@ -120,6 +129,8 @@ class LlmAgentProtocol(Protocol):
 
     def clear(self, *, clear_prompts: bool = False) -> None: ...
 
+    def pop_last_message(self) -> PromptMessageExtended | None: ...
+
 
 class AgentProtocol(LlmAgentProtocol, Protocol):
     """Standard agent interface with flexible input types."""

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,8 @@ class FastAgentLLM(ContextDependent, FastAgentLLMProtocol, Generic[MessageParamT
 
         # Initialize usage tracking
         self._usage_accumulator = UsageAccumulator()
+        self._stream_listeners: set[Callable[[str], None]] = set()
+        self._tool_stream_listeners: set[Callable[[str, Dict[str, Any] | None], None]] = set()
 
     def _initialize_default_params(self, kwargs: dict) -> RequestParams:
         """Initialize default parameters for the LLM.
@@ -483,6 +486,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 +508,64 @@ 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 add_tool_stream_listener(
+        self, listener: Callable[[str, Dict[str, Any] | None], None]
+    ) -> Callable[[], None]:
+        """Register a callback invoked with tool streaming events.
+
+        Args:
+            listener: Callable receiving event_type (str) and optional info dict.
+
+        Returns:
+            A function that removes the listener when called.
+        """
+
+        self._tool_stream_listeners.add(listener)
+
+        def remove() -> None:
+            self._tool_stream_listeners.discard(listener)
+
+        return remove
+
+    def _notify_tool_stream_listeners(
+        self, event_type: str, payload: Dict[str, Any] | None = None
+    ) -> None:
+        """Notify listeners about tool streaming lifecycle events."""
+
+        data = payload or {}
+        for listener in list(self._tool_stream_listeners):
+            try:
+                listener(event_type, data)
+            except Exception:
+                self.logger.exception("Tool stream listener raised an exception")
+
     def _log_chat_finished(self, model: Optional[str] = None) -> None:
         """Log a chat finished event"""
         data = {
@@ -612,6 +675,19 @@ class FastAgentLLM(ContextDependent, FastAgentLLMProtocol, Generic[MessageParamT
         """
         return self._message_history
 
+    def pop_last_message(self) -> PromptMessageExtended | None:
+        """Remove and return the most recent message from the conversation history."""
+        if not self._message_history:
+            return None
+
+        removed = self._message_history.pop()
+        try:
+            self.history.pop()
+        except Exception:
+            # If provider-specific memory isn't available, ignore to avoid crashing UX
+            pass
+        return removed
+
     def clear(self, *, clear_prompts: bool = False) -> None:
         """Reset stored message history while optionally retaining prompt templates."""
 

fast_agent/llm/memory.py

@@ -1,4 +1,4 @@
-from typing import Generic, List, Protocol, TypeVar
+from typing import Generic, List, Optional, Protocol, TypeVar
 
 # Define our own type variable for implementation use
 MessageParamT = TypeVar("MessageParamT")
@@ -23,6 +23,8 @@ class Memory(Protocol, Generic[MessageParamT]):
 
     def clear(self, clear_prompts: bool = False) -> None: ...
 
+    def pop(self, *, from_prompts: bool = False) -> Optional[MessageParamT]: ...
+
 
 class SimpleMemory(Memory, Generic[MessageParamT]):
     """
@@ -108,6 +110,29 @@ class SimpleMemory(Memory, Generic[MessageParamT]):
         if clear_prompts:
             self.prompt_messages = []
 
+    def pop(self, *, from_prompts: bool = False) -> Optional[MessageParamT]:
+        """
+        Remove and return the most recent message from history or prompt messages.
+
+        Args:
+            from_prompts: If True, pop from prompt_messages instead of history
+
+        Returns:
+            The removed message if available, otherwise None
+        """
+        if from_prompts:
+            if not self.prompt_messages:
+                return None
+            return self.prompt_messages.pop()
+
+        if not self.history:
+            return None
+
+        removed = self.history.pop()
+        # Recalculate cache positions now that the history shrank
+        self.conversation_cache_positions = self._calculate_cache_positions(len(self.history))
+        return removed
+
     def should_apply_conversation_cache(self) -> bool:
         """
         Determine if conversation caching should be applied based on walking algorithm.

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: