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

fast_agent/context.py

@@ -1,10 +1,10 @@
-"""
-A central context object to store global state that is shared across the application.
-"""
+from __future__ import annotations
 
 import asyncio
 import concurrent.futures
+import logging
 import uuid
+from pathlib import Path
 from typing import TYPE_CHECKING, Any, Optional, Union
 
 from opentelemetry import trace
@@ -29,12 +29,18 @@ from fast_agent.mcp_server_registry import ServerRegistry
 
 if TYPE_CHECKING:
     from fast_agent.core.executor.workflow_signal import SignalWaitCallback
+    from fast_agent.mcp.mcp_connection_manager import MCPConnectionManager
 else:
     # Runtime placeholders for the types
     SignalWaitCallback = Any
+    MCPConnectionManager = Any
 
 logger = get_logger(__name__)
 
+"""
+A central context object to store global state that is shared across the application.
+"""
+
 
 class Context(BaseModel):
     """
@@ -52,6 +58,7 @@ class Context(BaseModel):
     task_registry: Optional[ActivityRegistry] = None
 
     tracer: trace.Tracer | None = None
+    _connection_manager: "MCPConnectionManager | None" = None
 
     model_config = ConfigDict(
         extra="allow",
@@ -130,16 +137,42 @@ async def configure_logger(config: "Settings") -> None:
     """
     Configure logging and tracing based on the application config.
     """
+    settings = config.logger
+
+    # Configure the standard Python logger used by LoggingListener so it respects settings.
+    python_logger = logging.getLogger("fast_agent")
+    python_logger.handlers.clear()
+    python_logger.setLevel(settings.level.upper())
+    python_logger.propagate = False
+
+    handler: logging.Handler
+    if settings.type == "console":
+        handler = logging.StreamHandler()
+    elif settings.type == "file":
+        log_path = Path(settings.path)
+        if log_path.parent:
+            log_path.parent.mkdir(parents=True, exist_ok=True)
+        handler = logging.FileHandler(log_path)
+    elif settings.type == "none":
+        handler = logging.NullHandler()
+    else:
+        # For transports that handle output elsewhere (e.g., HTTP), suppress console output.
+        handler = logging.NullHandler()
+
+    handler.setLevel(settings.level.upper())
+    handler.setFormatter(logging.Formatter("%(message)s"))
+    python_logger.addHandler(handler)
+
     # Use StreamingExclusionFilter to prevent streaming events from flooding logs
-    event_filter: EventFilter = StreamingExclusionFilter(min_level=config.logger.level)
-    logger.info(f"Configuring logger with level: {config.logger.level}")
-    transport = create_transport(settings=config.logger, event_filter=event_filter)
+    event_filter: EventFilter = StreamingExclusionFilter(min_level=settings.level)
+    logger.info(f"Configuring logger with level: {settings.level}")
+    transport = create_transport(settings=settings, event_filter=event_filter)
     await LoggingConfig.configure(
         event_filter=event_filter,
         transport=transport,
-        batch_size=config.logger.batch_size,
-        flush_interval=config.logger.flush_interval,
-        progress_display=config.logger.progress_display,
+        batch_size=settings.batch_size,
+        flush_interval=settings.flush_interval,
+        progress_display=settings.progress_display,
     )
 
 

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/logging/listeners.py

@@ -70,7 +70,7 @@ def convert_log_event(event: Event) -> "ProgressEvent | None":
 
     # Extract streaming token count for STREAMING actions
     streaming_tokens = None
-    if progress_action == ProgressAction.STREAMING:
+    if progress_action == ProgressAction.STREAMING or progress_action == ProgressAction.THINKING:
         streaming_tokens = event_data.get("details", "")
 
     # Extract progress data for TOOL_PROGRESS actions

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

@@ -14,6 +14,7 @@ class ProgressAction(str, Enum):
     INITIALIZED = "Initialized"
     CHATTING = "Chatting"
     STREAMING = "Streaming"  # Special action for real-time streaming updates
+    THINKING = "Thinking"  # Special action for real-time thinking updates
     ROUTING = "Routing"
     PLANNING = "Planning"
     READY = "Ready"
@@ -53,9 +54,7 @@ class ProgressEvent(BaseModel):
             base = f"{self.action.ljust(11)}. {self.target}"
             if self.details:
                 base += f" - {self.details}"
-        
+
         if self.agent_name:
             base = f"[{self.agent_name}] {base}"
         return base
-
-

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,
@@ -21,7 +22,7 @@ from typing import (
 
 from a2a.types import AgentCard
 from mcp import Tool
-from mcp.types import GetPromptResult, Prompt, PromptMessage, ReadResourceResult
+from mcp.types import GetPromptResult, ListToolsResult, Prompt, PromptMessage, ReadResourceResult
 from pydantic import BaseModel
 from rich.text import Text
 
@@ -79,6 +80,13 @@ class FastAgentLLMProtocol(Protocol):
         self, prompt_result: "GetPromptResult", prompt_name: str
     ) -> str: ...
 
+    def get_request_params(
+        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]: ...
 
@@ -116,7 +124,7 @@ class LlmAgentProtocol(Protocol):
     def clear(self, *, clear_prompts: bool = False) -> None: ...
 
 
-class AgentProtocol(LlmAgentProtocol):
+class AgentProtocol(LlmAgentProtocol, Protocol):
     """Standard agent interface with flexible input types."""
 
     async def __call__(
@@ -190,6 +198,8 @@ class AgentProtocol(LlmAgentProtocol):
 
     async def list_mcp_tools(self, namespace: str | None = None) -> Mapping[str, List[Tool]]: ...
 
+    async def list_tools(self) -> ListToolsResult: ...
+
     async def get_resource(
         self, resource_uri: str, namespace: str | None = None
     ) -> ReadResourceResult: ...

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",
@@ -317,6 +319,11 @@ class ModelFactory:
                 from fast_agent.llm.provider.openai.llm_groq import GroqLLM
 
                 return GroqLLM
+            if provider == Provider.RESPONSES:
+                from fast_agent.llm.provider.openai.responses import ResponsesLLM
+
+                return ResponsesLLM
+
         except Exception as e:
             raise ModelConfigError(
                 f"Provider '{provider.value}' is unavailable or missing dependencies: {e}"

fast_agent/llm/provider_key_manager.py

@@ -14,6 +14,7 @@ PROVIDER_ENVIRONMENT_MAP: Dict[str, str] = {
     # default behaviour in _get_env_key_name is to capitalize the
     # provider name and suffix "_API_KEY" - so no specific mapping needed unless overriding
     "huggingface": "HF_TOKEN",
+    "responses": "OPENAI_API_KEY",  # Temporary workaround
 }
 API_KEY_HINT_TEXT = "<your-api-key-here>"
 

fast_agent/llm/provider_types.py

@@ -31,3 +31,4 @@ class Provider(Enum):
     XAI = ("xai", "XAI")  # For xAI Grok models
     BEDROCK = ("bedrock", "Bedrock")
     GROQ = ("groq", "Groq")
+    RESPONSES = ("responses", "responses")

fast_agent/llm/request_params.py

@@ -8,6 +8,8 @@ from mcp import SamplingMessage
 from mcp.types import CreateMessageRequestParams
 from pydantic import Field
 
+from fast_agent.constants import DEFAULT_MAX_ITERATIONS
+
 
 class RequestParams(CreateMessageRequestParams):
     """
@@ -34,7 +36,7 @@ class RequestParams(CreateMessageRequestParams):
     Agent/LLM maintains conversation history. Does not include applied Prompts
     """
 
-    max_iterations: int = 20
+    max_iterations: int = DEFAULT_MAX_ITERATIONS
     """
     The maximum number of tool calls allowed in a conversation turn
     """