fast-agent-mcp 0.3.2__py3-none-any.whl → 0.3.3__py3-none-any.whl

fast_agent/agents/llm_decorator.py

@@ -189,6 +189,7 @@ class LlmDecorator(AgentProtocol):
             Sequence[Union[str, PromptMessage, PromptMessageExtended]],
         ],
         request_params: RequestParams | None = None,
+        tools: List[Tool] | None = None,
     ) -> PromptMessageExtended:
         """
         Create a completion with the LLM using the provided messages.
@@ -212,7 +213,7 @@ class LlmDecorator(AgentProtocol):
         multipart_messages = normalize_to_extended_list(messages)
 
         with self._tracer.start_as_current_span(f"Agent: '{self._name}' generate"):
-            return await self.generate_impl(multipart_messages, request_params, None)
+            return await self.generate_impl(multipart_messages, request_params, tools)
 
     async def generate_impl(
         self,

fast_agent/agents/tool_agent.py

@@ -97,7 +97,10 @@ class ToolAgent(LlmAgent):
             )
 
             if LlmStopReason.TOOL_USE == result.stop_reason:
-                messages = [await self.run_tools(result)]
+                if self.config.use_history:
+                    messages = [await self.run_tools(result)]
+                else:
+                    messages.extend([result, await self.run_tools(result)])
             else:
                 break
 

fast_agent/agents/workflow/orchestrator_models.py

@@ -72,7 +72,7 @@ class TaskWithResult(Task):
 class StepResult(BaseModel):
     """Result of executing a step"""
 
-    step: Step = Field(description="The step that was executed", default_factory=Step)
+    step: Step = Field(description="The step that was executed")
     task_results: List[TaskWithResult] = Field(
         description="Results of executing each task", default_factory=list
     )

fast_agent/cli/commands/url_parser.py

@@ -104,7 +104,7 @@ def generate_server_name(url: str) -> str:
 
 
 def parse_server_urls(
-    urls_param: str, auth_token: str = None
+    urls_param: str, auth_token: str | None = None
 ) -> List[Tuple[str, Literal["http", "sse"], str, Dict[str, str] | None]]:
     """
     Parse a comma-separated list of URLs into server configurations.
@@ -155,7 +155,7 @@ def generate_server_configs(
     Returns:
         Dictionary of server configurations
     """
-    server_configs = {}
+    server_configs: Dict[str, Dict[str, str | Dict[str, str]]] = {}
     # Keep track of server name occurrences to handle collisions
     name_counts = {}
 
@@ -178,7 +178,7 @@ def generate_server_configs(
                 final_name = f"{server_name}_{suffix}"
                 name_counts[server_name] += 1
 
-        config = {
+        config: Dict[str, str | Dict[str, str]] = {
             "transport": transport_type,
             "url": url,
         }

fast_agent/cli/main.py

@@ -85,7 +85,13 @@ def main(
     Use --help with any command for detailed usage information.
     """
     application.verbosity = 1 if verbose else 0 if not quiet else -1
-    application.console = application.console if color else None
+    if not color:
+        # Recreate consoles without color when --no-color is provided
+        from fast_agent.ui.console import console as base_console
+        from fast_agent.ui.console import error_console as base_error_console
+
+        application.console = base_console.__class__(color_system=None)
+        application.error_console = base_error_console.__class__(color_system=None, stderr=True)
 
     # Handle version flag
     if version:

fast_agent/config.py

@@ -547,6 +547,8 @@ def get_settings(config_path: str | None = None) -> Settings:
         return _settings
 
     # Handle config path - convert string to Path if needed
+    config_file: Path | None
+    secrets_file: Path | None
     if config_path:
         config_file = Path(config_path)
         # If it's a relative path and doesn't exist, try finding it

fast_agent/core/__init__.py

@@ -2,14 +2,19 @@
 Core interfaces and decorators for fast-agent.
 
 Public API:
-- `Core`: The core application container (lazy-loaded)
+- `Core`: The core application container (eagerly exported)
 - `FastAgent`: High-level, decorator-driven application class (lazy-loaded)
 - Decorators: `agent`, `custom`, `orchestrator`, `iterative_planner`,
   `router`, `chain`, `parallel`, `evaluator_optimizer` (lazy-loaded)
 """
 
+from typing import TYPE_CHECKING as _TYPE_CHECKING
+
+from .core_app import Core  # Eager export for external applications
+
 __all__ = [
     "Core",
+    "AgentApp",
     "FastAgent",
     # Decorators
     "agent",
@@ -25,14 +30,14 @@ __all__ = [
 
 def __getattr__(name: str):
     # Lazy imports to avoid heavy dependencies and circular imports at init time
-    if name == "Core":
-        from .core_app import Core
-
-        return Core
     if name == "FastAgent":
         from .fastagent import FastAgent
 
         return FastAgent
+    if name == "AgentApp":
+        from .agent_app import AgentApp
+
+        return AgentApp
 
     # Decorators from direct_decorators
     if name in {
@@ -50,3 +55,37 @@ def __getattr__(name: str):
         return getattr(_dd, name)
 
     raise AttributeError(f"module '{__name__}' has no attribute '{name}'")
+
+
+# Help static analyzers/IDEs resolve symbols and signatures without importing at runtime.
+if _TYPE_CHECKING:  # pragma: no cover - typing aid only
+    from .agent_app import AgentApp as AgentApp  # noqa: F401
+    from .direct_decorators import (
+        agent as agent,
+    )  # noqa: F401
+    from .direct_decorators import (
+        chain as chain,
+    )
+    from .direct_decorators import (
+        custom as custom,
+    )
+    from .direct_decorators import (
+        evaluator_optimizer as evaluator_optimizer,
+    )
+    from .direct_decorators import (
+        iterative_planner as iterative_planner,
+    )
+    from .direct_decorators import (
+        orchestrator as orchestrator,
+    )
+    from .direct_decorators import (
+        parallel as parallel,
+    )
+    from .direct_decorators import (
+        router as router,
+    )
+    from .fastagent import FastAgent as FastAgent  # noqa: F401
+
+
+def __dir__():  # pragma: no cover - developer experience aid
+    return sorted(__all__)

fast_agent/core/direct_decorators.py

@@ -186,7 +186,7 @@ def _decorator_impl(
     resources: Optional[Dict[str, List[str]]] = None,
     prompts: Optional[Dict[str, List[str]]] = None,
     **extra_kwargs,
-) -> Callable[[AgentCallable[P, R]], DecoratedAgentProtocol[P, R]]:
+) -> Callable[[AgentCallable[P, R]], AgentCallable[P, R]]:
     """
     Core implementation for agent decorators with common behavior and type safety.
 
@@ -203,7 +203,7 @@ def _decorator_impl(
         **extra_kwargs: Additional agent/workflow-specific parameters
     """
 
-    def decorator(func: AgentCallable[P, R]) -> DecoratedAgentProtocol[P, R]:
+    def decorator(func: AgentCallable[P, R]) -> AgentCallable[P, R]:
         @wraps(func)
         def wrapper(*args: P.args, **kwargs: P.kwargs) -> Awaitable[R]:
             # Call the original function
@@ -249,7 +249,7 @@ def _decorator_impl(
         for key, value in extra_kwargs.items():
             setattr(wrapper, f"_{key}", value)
 
-        return cast("DecoratedAgentProtocol[P, R]", wrapper)
+        return cast("AgentCallable[P, R]", wrapper)
 
     return decorator
 
@@ -271,7 +271,7 @@ def agent(
     default: bool = False,
     elicitation_handler: Optional[ElicitationFnT] = None,
     api_key: str | None = None,
-) -> Callable[[AgentCallable[P, R]], DecoratedAgentProtocol[P, R]]:
+) -> Callable[[AgentCallable[P, R]], AgentCallable[P, R]]:
     """
     Decorator to create and register a standard agent with type-safe signature.
 
@@ -336,7 +336,7 @@ def custom(
     default: bool = False,
     elicitation_handler: Optional[ElicitationFnT] = None,
     api_key: str | None = None,
-) -> Callable[[AgentCallable[P, R]], DecoratedAgentProtocol[P, R]]:
+) -> Callable[[AgentCallable[P, R]], AgentCallable[P, R]]:
     """
     Decorator to create and register a standard agent with type-safe signature.
 
@@ -400,7 +400,7 @@ def orchestrator(
     plan_iterations: int = 5,
     default: bool = False,
     api_key: str | None = None,
-) -> Callable[[AgentCallable[P, R]], DecoratedOrchestratorProtocol[P, R]]:
+) -> Callable[[AgentCallable[P, R]], AgentCallable[P, R]]:
     """
     Decorator to create and register an orchestrator agent with type-safe signature.
 
@@ -423,24 +423,21 @@ def orchestrator(
     # Create final request params with plan_iterations
     resolved_instruction = _resolve_instruction(instruction)
 
-    return cast(
-        "Callable[[AgentCallable[P, R]], DecoratedOrchestratorProtocol[P, R]]",
-        _decorator_impl(
-            self,
-            AgentType.ORCHESTRATOR,
-            name=name,
-            instruction=resolved_instruction,
-            servers=[],  # Orchestrators don't connect to servers directly
-            model=model,
-            use_history=use_history,
-            request_params=request_params,
-            human_input=human_input,
-            child_agents=agents,
-            plan_type=plan_type,
-            plan_iterations=plan_iterations,
-            default=default,
-            api_key=api_key,
-        ),
+    return _decorator_impl(
+        self,
+        AgentType.ORCHESTRATOR,
+        name=name,
+        instruction=resolved_instruction,
+        servers=[],  # Orchestrators don't connect to servers directly
+        model=model,
+        use_history=use_history,
+        request_params=request_params,
+        human_input=human_input,
+        child_agents=agents,
+        plan_type=plan_type,
+        plan_iterations=plan_iterations,
+        default=default,
+        api_key=api_key,
     )
 
 
@@ -455,7 +452,7 @@ def iterative_planner(
     plan_iterations: int = -1,
     default: bool = False,
     api_key: str | None = None,
-) -> Callable[[AgentCallable[P, R]], DecoratedOrchestratorProtocol[P, R]]:
+) -> Callable[[AgentCallable[P, R]], AgentCallable[P, R]]:
     """
     Decorator to create and register an orchestrator agent with type-safe signature.
 
@@ -478,22 +475,19 @@ def iterative_planner(
     # Create final request params with plan_iterations
     resolved_instruction = _resolve_instruction(instruction)
 
-    return cast(
-        "Callable[[AgentCallable[P, R]], DecoratedOrchestratorProtocol[P, R]]",
-        _decorator_impl(
-            self,
-            AgentType.ITERATIVE_PLANNER,
-            name=name,
-            instruction=resolved_instruction,
-            servers=[],  # Orchestrators don't connect to servers directly
-            model=model,
-            use_history=False,
-            request_params=request_params,
-            child_agents=agents,
-            plan_iterations=plan_iterations,
-            default=default,
-            api_key=api_key,
-        ),
+    return _decorator_impl(
+        self,
+        AgentType.ITERATIVE_PLANNER,
+        name=name,
+        instruction=resolved_instruction,
+        servers=[],  # Orchestrators don't connect to servers directly
+        model=model,
+        use_history=False,
+        request_params=request_params,
+        child_agents=agents,
+        plan_iterations=plan_iterations,
+        default=default,
+        api_key=api_key,
     )
 
 
@@ -516,7 +510,7 @@ def router(
         ElicitationFnT
     ] = None,  ## exclude from docs, decide whether allowable
     api_key: str | None = None,
-) -> Callable[[AgentCallable[P, R]], DecoratedRouterProtocol[P, R]]:
+) -> Callable[[AgentCallable[P, R]], AgentCallable[P, R]]:
     """
     Decorator to create and register a router agent with type-safe signature.
 
@@ -536,26 +530,23 @@ def router(
     """
     resolved_instruction = _resolve_instruction(instruction or ROUTING_SYSTEM_INSTRUCTION)
 
-    return cast(
-        "Callable[[AgentCallable[P, R]], DecoratedRouterProtocol[P, R]]",
-        _decorator_impl(
-            self,
-            AgentType.ROUTER,
-            name=name,
-            instruction=resolved_instruction,
-            servers=servers,
-            model=model,
-            use_history=use_history,
-            request_params=request_params,
-            human_input=human_input,
-            default=default,
-            router_agents=agents,
-            elicitation_handler=elicitation_handler,
-            api_key=api_key,
-            tools=tools,
-            prompts=prompts,
-            resources=resources,
-        ),
+    return _decorator_impl(
+        self,
+        AgentType.ROUTER,
+        name=name,
+        instruction=resolved_instruction,
+        servers=servers,
+        model=model,
+        use_history=use_history,
+        request_params=request_params,
+        human_input=human_input,
+        default=default,
+        router_agents=agents,
+        elicitation_handler=elicitation_handler,
+        api_key=api_key,
+        tools=tools,
+        prompts=prompts,
+        resources=resources,
     )
 
 
@@ -567,7 +558,7 @@ def chain(
     instruction: Optional[str | Path | AnyUrl] = None,
     cumulative: bool = False,
     default: bool = False,
-) -> Callable[[AgentCallable[P, R]], DecoratedChainProtocol[P, R]]:
+) -> Callable[[AgentCallable[P, R]], AgentCallable[P, R]]:
     """
     Decorator to create and register a chain agent with type-safe signature.
 
@@ -593,17 +584,14 @@ def chain(
     """
     resolved_instruction = _resolve_instruction(instruction or default_instruction)
 
-    return cast(
-        "Callable[[AgentCallable[P, R]], DecoratedChainProtocol[P, R]]",
-        _decorator_impl(
-            self,
-            AgentType.CHAIN,
-            name=name,
-            instruction=resolved_instruction,
-            sequence=sequence,
-            cumulative=cumulative,
-            default=default,
-        ),
+    return _decorator_impl(
+        self,
+        AgentType.CHAIN,
+        name=name,
+        instruction=resolved_instruction,
+        sequence=sequence,
+        cumulative=cumulative,
+        default=default,
     )
 
 
@@ -616,7 +604,7 @@ def parallel(
     instruction: Optional[str | Path | AnyUrl] = None,
     include_request: bool = True,
     default: bool = False,
-) -> Callable[[AgentCallable[P, R]], DecoratedParallelProtocol[P, R]]:
+) -> Callable[[AgentCallable[P, R]], AgentCallable[P, R]]:
     """
     Decorator to create and register a parallel agent with type-safe signature.
 
@@ -637,19 +625,16 @@ def parallel(
     """
     resolved_instruction = _resolve_instruction(instruction or default_instruction)
 
-    return cast(
-        "Callable[[AgentCallable[P, R]], DecoratedParallelProtocol[P, R]]",
-        _decorator_impl(
-            self,
-            AgentType.PARALLEL,
-            name=name,
-            instruction=resolved_instruction,
-            servers=[],  # Parallel agents don't connect to servers directly
-            fan_in=fan_in,
-            fan_out=fan_out,
-            include_request=include_request,
-            default=default,
-        ),
+    return _decorator_impl(
+        self,
+        AgentType.PARALLEL,
+        name=name,
+        instruction=resolved_instruction,
+        servers=[],  # Parallel agents don't connect to servers directly
+        fan_in=fan_in,
+        fan_out=fan_out,
+        include_request=include_request,
+        default=default,
     )
 
 
@@ -663,7 +648,7 @@ def evaluator_optimizer(
     min_rating: str = "GOOD",
     max_refinements: int = 3,
     default: bool = False,
-) -> Callable[[AgentCallable[P, R]], DecoratedEvaluatorOptimizerProtocol[P, R]]:
+) -> Callable[[AgentCallable[P, R]], AgentCallable[P, R]]:
     """
     Decorator to create and register an evaluator-optimizer agent with type-safe signature.
 
@@ -686,18 +671,15 @@ def evaluator_optimizer(
     """
     resolved_instruction = _resolve_instruction(instruction or default_instruction)
 
-    return cast(
-        "Callable[[AgentCallable[P, R]], DecoratedEvaluatorOptimizerProtocol[P, R]]",
-        _decorator_impl(
-            self,
-            AgentType.EVALUATOR_OPTIMIZER,
-            name=name,
-            instruction=resolved_instruction,
-            servers=[],  # Evaluator-optimizer doesn't connect to servers directly
-            generator=generator,
-            evaluator=evaluator,
-            min_rating=min_rating,
-            max_refinements=max_refinements,
-            default=default,
-        ),
+    return _decorator_impl(
+        self,
+        AgentType.EVALUATOR_OPTIMIZER,
+        name=name,
+        instruction=resolved_instruction,
+        servers=[],  # Evaluator-optimizer doesn't connect to servers directly
+        generator=generator,
+        evaluator=evaluator,
+        min_rating=min_rating,
+        max_refinements=max_refinements,
+        default=default,
     )

fast_agent/core/error_handling.py

@@ -5,7 +5,7 @@ Error handling utilities for agent operations.
 from rich import print
 
 
-def handle_error(e: Exception, error_type: str, suggestion: str = None) -> None:
+def handle_error(e: Exception, error_type: str, suggestion: str | None = None) -> None:
     """
     Handle errors with consistent formatting and messaging.
 

fast_agent/core/fastagent.py

@@ -10,7 +10,19 @@ import sys
 from contextlib import asynccontextmanager
 from importlib.metadata import version as get_version
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional, TypeVar
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    AsyncIterator,
+    Awaitable,
+    Callable,
+    Dict,
+    List,
+    Literal,
+    Optional,
+    ParamSpec,
+    TypeVar,
+)
 
 import yaml
 from opentelemetry import trace
@@ -67,6 +79,9 @@ from fast_agent.mcp.prompts.prompt_load import load_prompt_multipart
 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.interfaces import AgentProtocol
     from fast_agent.types import PromptMessageExtended
 
@@ -250,32 +265,137 @@ class FastAgent:
         """Access the application context"""
         return self.app.context
 
-    # Decorator methods with type-safe implementations
+    # Decorator methods with precise signatures for IDE completion
     # Provide annotations so IDEs can discover these attributes on instances
     if TYPE_CHECKING:  # pragma: no cover - typing aid only
-        from typing import Awaitable, ParamSpec, Protocol, TypeVar  # re-import for type block
-
-        from fast_agent.core.direct_decorators import (
-            DecoratedAgentProtocol,
-            DecoratedChainProtocol,
-            DecoratedEvaluatorOptimizerProtocol,
-            DecoratedOrchestratorProtocol,
-            DecoratedParallelProtocol,
-            DecoratedRouterProtocol,
-        )
+        from pathlib import Path
+
+        from fast_agent.types import RequestParams
 
         P = ParamSpec("P")
         R = TypeVar("R")
 
-        # These are declared as attributes so IDEs show autocomplete on `fast.agent` etc.
-        def agent(self, *args, **kwargs) -> "DecoratedAgentProtocol[P, R]": ...
-        def custom(self, *args, **kwargs) -> "DecoratedAgentProtocol[P, R]": ...
-        def orchestrator(self, *args, **kwargs) -> "DecoratedOrchestratorProtocol[P, R]": ...
-        def iterative_planner(self, *args, **kwargs) -> "DecoratedOrchestratorProtocol[P, R]": ...
-        def router(self, *args, **kwargs) -> "DecoratedRouterProtocol[P, R]": ...
-        def chain(self, *args, **kwargs) -> "DecoratedChainProtocol[P, R]": ...
-        def parallel(self, *args, **kwargs) -> "DecoratedParallelProtocol[P, R]": ...
-        def evaluator_optimizer(self, *args, **kwargs) -> "DecoratedEvaluatorOptimizerProtocol[P, R]": ...
+        def agent(
+            self,
+            name: str = "default",
+            instruction_or_kwarg: Optional[str | Path | AnyUrl] = None,
+            *,
+            instruction: str | Path | AnyUrl = "You are a helpful agent.",
+            servers: List[str] = [],
+            tools: Optional[Dict[str, List[str]]] = None,
+            resources: Optional[Dict[str, List[str]]] = None,
+            prompts: Optional[Dict[str, List[str]]] = None,
+            model: Optional[str] = None,
+            use_history: bool = True,
+            request_params: RequestParams | None = None,
+            human_input: bool = False,
+            default: bool = False,
+            elicitation_handler: Optional[ElicitationFnT] = None,
+            api_key: str | None = None,
+        ) -> Callable[[Callable[P, Awaitable[R]]], Callable[P, Awaitable[R]]]: ...
+
+        def custom(
+            self,
+            cls,
+            name: str = "default",
+            instruction_or_kwarg: Optional[str | Path | AnyUrl] = None,
+            *,
+            instruction: str | Path | AnyUrl = "You are a helpful agent.",
+            servers: List[str] = [],
+            tools: Optional[Dict[str, List[str]]] = None,
+            resources: Optional[Dict[str, List[str]]] = None,
+            prompts: Optional[Dict[str, List[str]]] = None,
+            model: Optional[str] = None,
+            use_history: bool = True,
+            request_params: RequestParams | None = None,
+            human_input: bool = False,
+            default: bool = False,
+            elicitation_handler: Optional[ElicitationFnT] = None,
+            api_key: str | None = None,
+        ) -> Callable[[Callable[P, Awaitable[R]]], Callable[P, Awaitable[R]]]: ...
+
+        def orchestrator(
+            self,
+            name: str,
+            *,
+            agents: List[str],
+            instruction: str
+            | Path
+            | AnyUrl = "You are an expert planner. Given an objective task and a list of Agents\n(which are collections of capabilities), your job is to break down the objective\ninto a series of steps, which can be performed by these agents.\n",
+            model: Optional[str] = None,
+            request_params: RequestParams | None = None,
+            use_history: bool = False,
+            human_input: bool = False,
+            plan_type: Literal["full", "iterative"] = "full",
+            plan_iterations: int = 5,
+            default: bool = False,
+            api_key: str | None = None,
+        ) -> Callable[[Callable[P, Awaitable[R]]], Callable[P, Awaitable[R]]]: ...
+
+        def iterative_planner(
+            self,
+            name: str,
+            *,
+            agents: List[str],
+            instruction: str | Path | AnyUrl = "You are an expert planner. Plan iteratively.",
+            model: Optional[str] = None,
+            request_params: RequestParams | None = None,
+            plan_iterations: int = -1,
+            default: bool = False,
+            api_key: str | None = None,
+        ) -> Callable[[Callable[P, Awaitable[R]]], Callable[P, Awaitable[R]]]: ...
+
+        def router(
+            self,
+            name: str,
+            *,
+            agents: List[str],
+            instruction: Optional[str | Path | AnyUrl] = None,
+            servers: List[str] = [],
+            tools: Optional[Dict[str, List[str]]] = None,
+            resources: Optional[Dict[str, List[str]]] = None,
+            prompts: Optional[Dict[str, List[str]]] = None,
+            model: Optional[str] = None,
+            use_history: bool = False,
+            request_params: RequestParams | None = None,
+            human_input: bool = False,
+            default: bool = False,
+            elicitation_handler: Optional[ElicitationFnT] = None,
+            api_key: str | None = None,
+        ) -> Callable[[Callable[P, Awaitable[R]]], Callable[P, Awaitable[R]]]: ...
+
+        def chain(
+            self,
+            name: str,
+            *,
+            sequence: List[str],
+            instruction: Optional[str | Path | AnyUrl] = None,
+            cumulative: bool = False,
+            default: bool = False,
+        ) -> Callable[[Callable[P, Awaitable[R]]], Callable[P, Awaitable[R]]]: ...
+
+        def parallel(
+            self,
+            name: str,
+            *,
+            fan_out: List[str],
+            fan_in: str | None = None,
+            instruction: Optional[str | Path | AnyUrl] = None,
+            include_request: bool = True,
+            default: bool = False,
+        ) -> Callable[[Callable[P, Awaitable[R]]], Callable[P, Awaitable[R]]]: ...
+
+        def evaluator_optimizer(
+            self,
+            name: str,
+            *,
+            generator: str,
+            evaluator: str,
+            instruction: Optional[str | Path | AnyUrl] = None,
+            min_rating: str = "GOOD",
+            max_refinements: int = 3,
+            default: bool = False,
+        ) -> Callable[[Callable[P, Awaitable[R]]], Callable[P, Awaitable[R]]]: ...
 
     # Runtime bindings (actual implementations)
     agent = agent_decorator
@@ -288,7 +408,7 @@ class FastAgent:
     evaluator_optimizer = evaluator_optimizer_decorator
 
     @asynccontextmanager
-    async def run(self):
+    async def run(self) -> AsyncIterator["AgentApp"]:
         """
         Context manager for running the application.
         Initializes all registered agents.
@@ -308,15 +428,14 @@ class FastAgent:
             try:
                 async with self.app.run():
                     # Apply quiet mode if requested
-                    if (
-                        quiet_mode
-                        and hasattr(self.app.context, "config")
-                        and hasattr(self.app.context.config, "logger")
-                    ):
-                        # Update our app's config directly
-                        self.app.context.config.logger.progress_display = False
-                        self.app.context.config.logger.show_chat = False
-                        self.app.context.config.logger.show_tools = False
+                    if quiet_mode:
+                        cfg = self.app.context.config
+                        if cfg is not None and cfg.logger is not None:
+                            # Update our app's config directly
+                            cfg_logger = cfg.logger
+                            cfg_logger.progress_display = False
+                            cfg_logger.show_chat = False
+                            cfg_logger.show_tools = False
 
                         # Directly disable the progress display singleton
                         from fast_agent.ui.progress_display import progress_display
@@ -437,12 +556,12 @@ class FastAgent:
                         try:
                             # Get response from the agent
                             agent = active_agents[agent_name]
-                            response = await agent.generate(prompt)
+                            prompt_result = await agent.generate(prompt)
 
                             # In quiet mode, just print the raw response
                             # The chat display should already be turned off by the configuration
                             if self.args.quiet:
-                                print(f"{response.last_text()}")
+                                print(f"{prompt_result.last_text()}")
 
                             raise SystemExit(0)
                         except Exception as e:
@@ -590,7 +709,7 @@ class FastAgent:
             original_args.quiet if original_args and hasattr(original_args, "quiet") else False
         )
         self.args.model = None
-        if hasattr(original_args, "model"):
+        if original_args is not None and hasattr(original_args, "model"):
             self.args.model = original_args.model
 
         # Run the application, which will detect the server flag and start server mode

fast_agent/core/logging/events.py

@@ -5,12 +5,7 @@ Events and event filters for the logger module for the MCP Agent
 import logging
 import random
 from datetime import datetime
-from typing import (
-    Any,
-    Dict,
-    Literal,
-    Set,
-)
+from typing import Any, Dict, Literal
 
 from pydantic import BaseModel, ConfigDict, Field
 
@@ -64,9 +59,9 @@ class EventFilter(BaseModel):
       - a minimum severity level (DEBUG < INFO < WARNING < ERROR)
     """
 
-    types: Set[EventType] | None = Field(default_factory=set)
-    names: Set[str] | None = Field(default_factory=set)
-    namespaces: Set[str] | None = Field(default_factory=set)
+    types: set[EventType] = Field(default_factory=set)
+    names: set[str] = Field(default_factory=set)
+    namespaces: set[str] = Field(default_factory=set)
     min_level: EventType | None = "debug"
 
     def matches(self, event: Event) -> bool:

fast_agent/llm/prompt_utils.py

@@ -2,7 +2,7 @@
 XML formatting utilities for consistent prompt engineering across components.
 """
 
-from typing import Dict, List, Optional, Union
+from typing import Dict, List, Optional, TypedDict
 
 
 def format_xml_tag(
@@ -100,10 +100,16 @@ def format_server_info(
     return format_fastagent_tag("server", f"\n{server_content}\n", {"name": server_name})
 
 
+class ServerInfo(TypedDict, total=False):
+    name: str
+    description: str
+    tools: List[Dict[str, str]]
+
+
 def format_agent_info(
     agent_name: str,
     description: Optional[str] = None,
-    servers: Optional[List[Dict[str, Union[str, List[Dict[str, str]]]]]] = None,
+    servers: Optional[List[ServerInfo]] = None,
 ) -> str:
     """
     Format agent information consistently across router and orchestrator modules.
@@ -133,8 +139,8 @@ def format_agent_info(
         server_tags = []
         for server in servers:
             server_name = server.get("name", "")
-            server_desc = server.get("description", "")
-            server_tools = server.get("tools", [])
+            server_desc = server.get("description")
+            server_tools = server.get("tools")
             server_tag = format_server_info(server_name, server_desc, server_tools)
             server_tags.append(server_tag)
 

fast_agent/llm/provider/anthropic/llm_anthropic.py

@@ -291,6 +291,7 @@ class AnthropicLLM(FastAgentLLM[MessageParam, Message]):
         request_params: RequestParams | None = None,
         structured_model: Type[ModelT] | None = None,
         tools: List[Tool] | None = None,
+        pre_messages: List[MessageParam] | None = None,
     ) -> PromptMessageExtended:
         """
         Process a query using an LLM and available tools.
@@ -304,7 +305,7 @@ class AnthropicLLM(FastAgentLLM[MessageParam, Message]):
 
         try:
             anthropic = AsyncAnthropic(api_key=api_key, base_url=base_url)
-            messages: List[MessageParam] = []
+            messages: List[MessageParam] = list(pre_messages) if pre_messages else []
             params = self.get_request_params(request_params)
         except AuthenticationError as e:
             raise ProviderKeyError(
@@ -312,7 +313,7 @@ class AnthropicLLM(FastAgentLLM[MessageParam, Message]):
                 "The configured Anthropic API key was rejected.\nPlease check that your API key is valid and not expired.",
             ) from e
 
-        # Always include prompt messages, but only include conversation history
+        # Always include prompt messages, but only include conversation history if enabled
         messages.extend(self.history.get(include_completion_history=params.use_history))
         messages.append(message_param)  # message_param is the current user turn
 
@@ -470,6 +471,9 @@ class AnthropicLLM(FastAgentLLM[MessageParam, Message]):
         tools: List[Tool] | None = None,
         is_template: bool = False,
     ) -> PromptMessageExtended:
+        # Effective params for this turn
+        params = self.get_request_params(request_params)
+
         # Check the last message role
         last_message = multipart_messages[-1]
 
@@ -477,7 +481,7 @@ class AnthropicLLM(FastAgentLLM[MessageParam, Message]):
         messages_to_add = (
             multipart_messages[:-1] if last_message.role == "user" else multipart_messages
         )
-        converted = []
+        converted: List[MessageParam] = []
 
         # Get cache mode configuration
         cache_mode = self._get_cache_mode()
@@ -499,12 +503,19 @@ class AnthropicLLM(FastAgentLLM[MessageParam, Message]):
 
             converted.append(anthropic_msg)
 
-        self.history.extend(converted, is_prompt=is_template)
+        # Persist prior only when history is enabled; otherwise inline for this call
+        pre_messages: List[MessageParam] | None = None
+        if params.use_history:
+            self.history.extend(converted, is_prompt=is_template)
+        else:
+            pre_messages = converted
 
         if last_message.role == "user":
             logger.debug("Last message in prompt is from user, generating assistant response")
             message_param = AnthropicConverter.convert_to_anthropic(last_message)
-            return await self._anthropic_completion(message_param, request_params, tools=tools)
+            return await self._anthropic_completion(
+                message_param, request_params, tools=tools, pre_messages=pre_messages
+            )
         else:
             # For assistant messages: Return the last message content as text
             logger.debug("Last message in prompt is from assistant, returning it directly")

fast_agent/llm/provider/bedrock/llm_bedrock.py

@@ -1192,6 +1192,7 @@ class BedrockLLM(FastAgentLLM[BedrockMessageParam, BedrockMessage]):
         message_param: BedrockMessageParam,
         request_params: RequestParams | None = None,
         tools: List[Tool] | None = None,
+        pre_messages: List[BedrockMessageParam] | None = None,
     ) -> PromptMessageExtended:
         """
         Process a query using Bedrock and available tools.
@@ -1200,7 +1201,7 @@ class BedrockLLM(FastAgentLLM[BedrockMessageParam, BedrockMessage]):
         client = self._get_bedrock_runtime_client()
 
         try:
-            messages: List[BedrockMessageParam] = []
+            messages: List[BedrockMessageParam] = list(pre_messages) if pre_messages else []
             params = self.get_request_params(request_params)
         except (ClientError, BotoCoreError) as e:
             error_msg = str(e)
@@ -1869,8 +1870,13 @@ class BedrockLLM(FastAgentLLM[BedrockMessageParam, BedrockMessage]):
             bedrock_msg = self._convert_multipart_to_bedrock_message(msg)
             converted.append(bedrock_msg)
 
-        # Add messages to history
-        self.history.extend(converted, is_prompt=is_template)
+        # Only persist prior messages when history is enabled; otherwise inline for this call
+        params = self.get_request_params(request_params)
+        pre_messages: List[BedrockMessageParam] | None = None
+        if params.use_history:
+            self.history.extend(converted, is_prompt=is_template)
+        else:
+            pre_messages = converted
 
         if last_message.role == "assistant":
             # For assistant messages: Return the last message (no completion needed)
@@ -1884,8 +1890,10 @@ class BedrockLLM(FastAgentLLM[BedrockMessageParam, BedrockMessage]):
             # Convert the last user message to Bedrock message parameter format
             message_param = self._convert_multipart_to_bedrock_message(last_message)
 
-        # Call the refactored completion method directly
-        return await self._bedrock_completion(message_param, request_params, tools)
+        # Call the completion method with optional pre_messages for no-history mode
+        return await self._bedrock_completion(
+            message_param, request_params, tools, pre_messages=pre_messages
+        )
 
     def _generate_simplified_schema(self, model: Type[ModelT]) -> str:
         """Generates a simplified, human-readable schema with inline enum constraints."""

fast_agent/llm/provider/google/llm_google_native.py

@@ -280,9 +280,15 @@ class GoogleNativeLLM(FastAgentLLM[types.Content, types.Content]):
         )
 
         if messages_to_add:
-            # Convert prior messages to google.genai Content and store in provider history
+            # Convert prior messages to google.genai Content
             converted_prior = self._converter.convert_to_google_content(messages_to_add)
-            self.history.extend(converted_prior, is_prompt=is_template)
+            # Only persist prior context when history is enabled; otherwise inline later
+            if request_params.use_history:
+                self.history.extend(converted_prior, is_prompt=is_template)
+            else:
+                # Prepend prior context directly to the turn message list
+                # This keeps the single-turn chain intact without relying on provider memory
+                pass
 
         if last_message.role == "assistant":
             # No generation required; the provided assistant message is the output
@@ -322,6 +328,11 @@ class GoogleNativeLLM(FastAgentLLM[types.Content, types.Content]):
             # convert_to_google_content returns a list; preserve order after tool responses
             turn_messages.extend(user_contents)
 
+        # If not using provider history, include prior messages inline for this turn
+        if messages_to_add and not request_params.use_history:
+            prior_contents = self._converter.convert_to_google_content(messages_to_add)
+            turn_messages = prior_contents + turn_messages
+
         # If we somehow have no provider-native parts, ensure we send an empty user content
         if not turn_messages:
             turn_messages.append(types.Content(role="user", parts=[types.Part.from_text("")]))

fast_agent/llm/provider/openai/llm_openai.py

@@ -448,32 +448,41 @@ class OpenAILLM(FastAgentLLM[ChatCompletionMessageParam, ChatCompletionMessage])
         tools: List[Tool] | None = None,
         is_template: bool = False,
     ) -> PromptMessageExtended:
-        # Reset tool call counter for new turn
+        # Determine effective params to respect use_history for this turn
+        req_params = self.get_request_params(request_params)
 
         last_message = multipart_messages[-1]
 
-        # Add all previous messages to history (or all messages if last is from assistant)
-        # if the last message is a "user" inference is required
+        # Prepare prior messages (everything before the last user message), or all if last is assistant
         messages_to_add = (
             multipart_messages[:-1] if last_message.role == "user" else multipart_messages
         )
-        converted = []
+
+        converted_prior: List[ChatCompletionMessageParam] = []
         for msg in messages_to_add:
             # convert_to_openai now returns a list of messages
-            converted.extend(OpenAIConverter.convert_to_openai(msg))
-
-        self.history.extend(converted, is_prompt=is_template)
+            converted_prior.extend(OpenAIConverter.convert_to_openai(msg))
 
-        if "assistant" == last_message.role:
+        # If the last message is from the assistant, no inference required
+        if last_message.role == "assistant":
             return last_message
 
-        converted_messages = OpenAIConverter.convert_to_openai(last_message)
-        if not converted_messages:
+        # Convert the last user message
+        converted_last = OpenAIConverter.convert_to_openai(last_message)
+        if not converted_last:
             # Fallback for empty conversion
-            converted_messages = [{"role": "user", "content": ""}]
+            converted_last = [{"role": "user", "content": ""}]
+
+        # History-aware vs stateless turn construction
+        if req_params.use_history:
+            # Persist prior context to provider memory; send only the last message for this turn
+            self.history.extend(converted_prior, is_prompt=is_template)
+            turn_messages = converted_last
+        else:
+            # Do NOT persist; inline the full turn context to the provider call
+            turn_messages = converted_prior + converted_last
 
-        # Call completion without additional messages (all messages are now in history)
-        return await self._openai_completion(converted_messages, request_params, tools)
+        return await self._openai_completion(turn_messages, req_params, tools)
 
     def _prepare_api_request(
         self, messages, tools: List[ChatCompletionToolParam] | None, request_params: RequestParams

fast_agent/ui/rich_progress.py

@@ -5,7 +5,7 @@ from contextlib import contextmanager
 from typing import Optional
 
 from rich.console import Console
-from rich.progress import Progress, SpinnerColumn, TextColumn
+from rich.progress import Progress, SpinnerColumn, TaskID, TextColumn
 
 from fast_agent.event_progress import ProgressAction, ProgressEvent
 from fast_agent.ui.console import console as default_console
@@ -17,7 +17,7 @@ class RichProgressDisplay:
     def __init__(self, console: Optional[Console] = None) -> None:
         """Initialize the progress display."""
         self.console = console or default_console
-        self._taskmap = {}
+        self._taskmap: dict[str, TaskID] = {}
         self._progress = Progress(
             SpinnerColumn(spinner_name="simpleDotsScrolling"),
             TextColumn(
@@ -134,11 +134,13 @@ class RichProgressDisplay:
             description = f"[{self._get_action_style(event.action)}]▎ {event.action.value:<15}"
 
         # Update basic task information
-        update_kwargs = {
+        update_kwargs: dict[str, object] = {
             "description": description,
-            "target": event.target or task_name,  # Use task_name as fallback for target
-            "details": event.details or "",
-            "task_name": task_name,
+            "fields": {
+                "target": event.target or task_name,  # Use task_name as fallback for target
+                "details": event.details or "",
+                "task_name": task_name,
+            },
         }
 
         # For TOOL_PROGRESS events, update progress if available

{fast_agent_mcp-0.3.2.dist-info → fast_agent_mcp-0.3.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fast-agent-mcp
-Version: 0.3.2
+Version: 0.3.3
 Summary: Define, Prompt and Test MCP enabled Agents and Workflows
 Author-email: Shaun Smith <fastagent@llmindset.co.uk>
 License:                                  Apache License

{fast_agent_mcp-0.3.2.dist-info → fast_agent_mcp-0.3.3.dist-info}/RECORD

@@ -1,5 +1,5 @@
 fast_agent/__init__.py,sha256=sljPsYHqDmv5v0fBpQdhtwBm5IDyu37lwdSQA0IPEwQ,3628
-fast_agent/config.py,sha256=8CPbTctXGdSneAkMory5ZRXkUsUj4AyKnaf_nmEamQA,19886
+fast_agent/config.py,sha256=RLCYW9k4lgnfJVc3JpBWJscOC2mHw35gkVGrBS46M-4,19945
 fast_agent/constants.py,sha256=d5EMSO2msRkjRFz8MgnnhpMnO3woqKP0EcQ4b_yI60w,235
 fast_agent/context.py,sha256=nBelOqehSH91z3aG2nYhwETP-biRzz-iuA2fqmKdHP8,7700
 fast_agent/context_dependent.py,sha256=KU1eydVBoIt4bYOZroqxDgE1AUexDaZi7hurE26QsF4,1584
@@ -10,35 +10,35 @@ fast_agent/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fast_agent/agents/__init__.py,sha256=kBI2VWTitLyWf8K3dFMyuE-K7Ufp7mkHBomM2K3I8H8,1128
 fast_agent/agents/agent_types.py,sha256=ugolD3lC2KxSfBYjjRf9HjNATZaFx1o4Fhjb15huSgk,1776
 fast_agent/agents/llm_agent.py,sha256=iuy3kO5Q-f9bm3tjYLG2Wurd0gK2sLhTfTkSnfVWzSw,8311
-fast_agent/agents/llm_decorator.py,sha256=yzaYqsT8lqey4dbZrv1oK9qUqf8I2RMPYiWOy0uVHqA,16443
+fast_agent/agents/llm_decorator.py,sha256=IhvMOZVjo1qT4GII0KP000VYTCprzBQBGZPbZwBIEd0,16485
 fast_agent/agents/mcp_agent.py,sha256=BMSTcGd9_SdoyEGNGVAWXu8ubaE1TAeAMl-2c_wymQU,35240
-fast_agent/agents/tool_agent.py,sha256=zSaVQH-mBICgE3ildeZx24i00u_KMOk5P4OuJBTiQ3g,6571
+fast_agent/agents/tool_agent.py,sha256=owGcc1an9P8jb8ZfNYjCsLK6lv85IL7friWcSbZxMIo,6717
 fast_agent/agents/workflow/chain_agent.py,sha256=Pd8dOH_YdKu3LXsKa4fwqzY_B2qVuhzdfCUiKi5v17s,6293
 fast_agent/agents/workflow/evaluator_optimizer.py,sha256=rhzazy8Aj-ydId6kmBC77TmtYZ5mirSe7eV6PPMWkBA,12040
 fast_agent/agents/workflow/iterative_planner.py,sha256=CTtDpK-YGrFFZMQQmFeE-2I_9-cZv23pNwUoh8w5voA,20478
-fast_agent/agents/workflow/orchestrator_models.py,sha256=X_hD66_YvdGIsNra3XWbVKj2KyNVL7usCdNsMsDXV3Q,7238
+fast_agent/agents/workflow/orchestrator_models.py,sha256=VNnnVegnjimgiuL8ZhxkBPhg8tjbeJRGq2JAIl0FAbU,7216
 fast_agent/agents/workflow/orchestrator_prompts.py,sha256=EXKEI174sshkZyPPEnWbwwNafzSPuA39MXL7iqG9cWc,9106
 fast_agent/agents/workflow/parallel_agent.py,sha256=DlJXDURAfx-WBF297tKBLfH93gDFSAPUyEmJr7QNGyw,7476
 fast_agent/agents/workflow/router_agent.py,sha256=KWLOZMFI4YPn0fqzR001qLFbOe7DYxx-E2c0BgIgO-g,11081
 fast_agent/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fast_agent/cli/__main__.py,sha256=VD-UuXvIHJtrDGgVVpsAZGJ_GfVTalSD1Kx9vzixzfM,1129
 fast_agent/cli/constants.py,sha256=KawdkaN289nVB02DKPB4IVUJ8-fohIUD0gLfOp0P7B8,551
-fast_agent/cli/main.py,sha256=EkNOpNobFW83fkzJL4lkdhtqOq7c_f55KFpBR9VrFTU,3905
+fast_agent/cli/main.py,sha256=H3brvpmDGE0g4WCJc2-volADCjpPmh7cSjedSfzqfOQ,4242
 fast_agent/cli/terminal.py,sha256=tDN1fJ91Nc_wZJTNafkQuD7Z7gFscvo1PHh-t7Wl-5s,1066
 fast_agent/cli/commands/check_config.py,sha256=nMiOBs-Sc7XqUU6tLReLn1JPXHqjR0Kuz4rCa3mDXp0,22831
 fast_agent/cli/commands/go.py,sha256=VRiHq9h1UGIndLdQJMAwEM6bwTGy-h5n6w__bYCGaHM,15094
 fast_agent/cli/commands/quickstart.py,sha256=hQZYlvktPdDNdaZOZkBgcvi8u0bMW5yFhz4BLBZ251I,21175
 fast_agent/cli/commands/server_helpers.py,sha256=BmljUNLIcZdFpffYxEPfJf8rrX3JhTzMA7VONoZLAjM,3650
 fast_agent/cli/commands/setup.py,sha256=rCp5wUs5kjbHJqi3Jz9ByCpOSvJ7L4KB0hpcKB8qpCM,6377
-fast_agent/cli/commands/url_parser.py,sha256=ivWrsODeVO9GGERkaTawYIxZuf57uRga1gubwT3n3vU,5907
-fast_agent/core/__init__.py,sha256=RsHaeZTQmmNC6cd--kGsnu-jp053cr7h0TUMEnBcMQ0,1223
+fast_agent/cli/commands/url_parser.py,sha256=v9KoprPBEEST5Fo7qXgbW50GC5vMpxFteKqAT6mFkdI,5991
+fast_agent/core/__init__.py,sha256=CnEL3AiklrG7jc0O-8RaF8_PTwBoDaHfmbXo3hOqR-I,2371
 fast_agent/core/agent_app.py,sha256=cdzNwpb--SUNYbhkUX6RolqVnxJ5WSchxw5I4gFrvpk,16836
 fast_agent/core/core_app.py,sha256=_8Di00HD2BzWhCAaopAUS0Hzc7pg0249QUUfPuLZ36A,4266
-fast_agent/core/direct_decorators.py,sha256=eHhQfKLbeaoH-W0snzAVJRxga7wTNGXBk5DEJTAbZB8,23642
+fast_agent/core/direct_decorators.py,sha256=0U4_qJl7pdom9mjQ5qwCeb0zBwc5hj-lKFF6zXs62sI,22621
 fast_agent/core/direct_factory.py,sha256=HGGnnF4Z9k_N3r0Iin_sp2Ch308To1oKX8JTKHjuUq0,21350
-fast_agent/core/error_handling.py,sha256=xoyS2kLe0eG0bj2eSJCJ2odIhGUve2SbDR7jP-A-uRw,624
+fast_agent/core/error_handling.py,sha256=tZkO8LnXO-qf6jD8a12Pv5fD4NhnN1Ag5_tJ6DwbXjg,631
 fast_agent/core/exceptions.py,sha256=ENAD_qGG67foxy6vDkIvc-lgopIUQy6O7zvNPpPXaQg,2289
-fast_agent/core/fastagent.py,sha256=PJPeRREuQqlqdVub7RqamfsArpoZ1D50B8Hz-CsDenA,26792
+fast_agent/core/fastagent.py,sha256=5f9jOteVVV7BzX3b_BsUSo_kdciVukVKw567uu-u3qE,30848
 fast_agent/core/prompt.py,sha256=qNUFlK3KtU7leYysYUglzBYQnEYiXu__iR_T8189zc0,203
 fast_agent/core/validation.py,sha256=GZ0hUTxkr5KMY1wr6_ifDy91Ycvcx384gZEMOwdie9w,12681
 fast_agent/core/executor/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -46,7 +46,7 @@ fast_agent/core/executor/executor.py,sha256=egmu1bBJmNjfkMZRdaF2CowyHu0t20TiroKB
 fast_agent/core/executor/task_registry.py,sha256=PCALFeYtkQrPBg4RBJnlA0aDI8nHclrNkHGUS4kV3W8,1242
 fast_agent/core/executor/workflow_signal.py,sha256=Cg1uZBk3fn8kXhPOg-wINNuVaf3v9pvLD6NbqWy5Z6E,11142
 fast_agent/core/logging/__init__.py,sha256=dFW2bbTtz45zebUuQs7RVi7mg1RJm4DHH6TGfBMhW14,167
-fast_agent/core/logging/events.py,sha256=kmk6sWxYm4DZGRRNVUi2cOL4X1Pr1cr535uBmStBZxo,4254
+fast_agent/core/logging/events.py,sha256=WTjr26uIxtbxhnoLNPROVUIt0HNJrzK1g1fUMZ-zVsQ,4207
 fast_agent/core/logging/json_serializer.py,sha256=kQDkwTHIkHSQgbhDOJhMoetNvfJVMZGOScaKoLX8kmw,5797
 fast_agent/core/logging/listeners.py,sha256=dubbGJoieryyhXN-JF-GrjkW-dgMq93bElM-NBkwA_Q,9366
 fast_agent/core/logging/logger.py,sha256=L-hLfUGFCIABoNYDiUkNHWvFxL6j-6zn5Pc5E7aC44M,11074
@@ -64,7 +64,7 @@ fast_agent/llm/memory.py,sha256=POFoBVMHK0wX4oLd3Gz-6Ru3uC4kTCvAqsVQ77e7KJA,8551
 fast_agent/llm/model_database.py,sha256=CXpAncjfFGmzjVyvAaKE5QuvDoLwMWXqUHngv_4oDl8,12609
 fast_agent/llm/model_factory.py,sha256=0quhsqz816GxEM_vuRaJ4n6U8C3lp5KxtIphxepIXVI,12862
 fast_agent/llm/model_info.py,sha256=DAIMW70W-EFqNLIudhjHJE2gobHUAKg90gkwOPuaFUc,4125
-fast_agent/llm/prompt_utils.py,sha256=yWQHykoK13QRF7evHUKxVF0SpVLN-Bsft0Yixzvn0g0,4825
+fast_agent/llm/prompt_utils.py,sha256=1WU67G-BFqftja5I8FKPMMzsvDk1K_1jDi9A9kkFdOg,4899
 fast_agent/llm/provider_key_manager.py,sha256=igzs1ghXsUp0wA4nJVVfWCWiYOib8Ux4jMGlhWbgXu8,3396
 fast_agent/llm/provider_types.py,sha256=Ya0MGo_4cE0oCwinqPvr9SJUwx4hEJ7CFbCrLB_27FI,1142
 fast_agent/llm/request_params.py,sha256=OW9WnQAD-I2fz2JzMsqPY2wwwHFG0SI4yAvC1WxTfNY,1735
@@ -75,19 +75,19 @@ fast_agent/llm/internal/playback.py,sha256=HzV0BitORA977_3OWAbMZjLZpIHBKt-_PeOO3
 fast_agent/llm/internal/silent.py,sha256=TVhjp0sEcPpR35n_QjYrMu0CKVX2humAt1GBR6y_itE,1563
 fast_agent/llm/internal/slow.py,sha256=MQf21cK7aM0yPN1_j1hSJRTEp4UGbrPo_sCP81WDcxQ,1310
 fast_agent/llm/provider/anthropic/anthropic_utils.py,sha256=zkeMpAlV9YW9pP1FObkyqR8wg8e-Xir9SCwsom94zao,3246
-fast_agent/llm/provider/anthropic/llm_anthropic.py,sha256=GGfNM9dTVy17YTGOxaat-YlJlW2iWi-pcBmVg_ejJPE,25288
+fast_agent/llm/provider/anthropic/llm_anthropic.py,sha256=EYd3_xy0OwSz4vM6XRkmQyG62_hTho-bsKpcg7CL9JI,25797
 fast_agent/llm/provider/anthropic/multipart_converter_anthropic.py,sha256=fO6qoKvG2ede85CvdvMipOlATwLjbGKahvsu2OzJhvk,16460
 fast_agent/llm/provider/bedrock/bedrock_utils.py,sha256=mqWCCeB1gUQSL2KRUMqpFjvHZ0ZTJugCsd5YOrx6U30,7750
-fast_agent/llm/provider/bedrock/llm_bedrock.py,sha256=XGB4bGZt74nQnGz0LY4HOSffdaRbz-5UWXX6fyjPPmk,99755
+fast_agent/llm/provider/bedrock/llm_bedrock.py,sha256=VSwl-UbU5Qh7umqNzQ5NofeO8p7aHhGl89eL4wTJchY,100199
 fast_agent/llm/provider/google/google_converter.py,sha256=iQZps4773Bc8SUODduLpfkVpT3J1rIg1bFgLQ2CCqZc,18926
-fast_agent/llm/provider/google/llm_google_native.py,sha256=jHJ3dXDltFE9tJhvPe8OuHardIHAJqmDrJkhYpYZkeY,18843
+fast_agent/llm/provider/google/llm_google_native.py,sha256=Uzkz8GXH-tzRO1mHnO1N7qiLuPdQ5NFkRoSa9_3uAPc,19451
 fast_agent/llm/provider/openai/llm_aliyun.py,sha256=ti7VHTpwl0AG3ytwBERpDzVtacvCfamKnl2bAnTE96s,1213
 fast_agent/llm/provider/openai/llm_azure.py,sha256=O-TIEL6hGOArqRlvEjocaeW4OMUaelSnh6xpqhrrcHQ,6070
 fast_agent/llm/provider/openai/llm_deepseek.py,sha256=aAMX7pd1qDfl54Z9pLvJTVYETc4yKKMRYrEMiPIhd7w,3762
 fast_agent/llm/provider/openai/llm_generic.py,sha256=O_mmu3o9LeAZ6Kp405I-GfwrS8AuVkyX3tT6aCDCfLY,1168
 fast_agent/llm/provider/openai/llm_google_oai.py,sha256=u1yZVeDds9z2hvydz_kUpFe2RANTNwEtlPgB-OEmgrY,1095
 fast_agent/llm/provider/openai/llm_groq.py,sha256=trNSy3T94_fJWAhVn51iESP_J7sQh_23ufVegKKNHBs,5247
-fast_agent/llm/provider/openai/llm_openai.py,sha256=OW1IwDn9sKBoITwUZYc3kHNyRLzJnC4qYcBwVytG8eA,22196
+fast_agent/llm/provider/openai/llm_openai.py,sha256=I4qcAjqUsMDRJtNdSmol57XYar8rj0mqV3VRtkOCZ_8,22681
 fast_agent/llm/provider/openai/llm_openrouter.py,sha256=RBTUkNBRqE8WoucCoVnXP5GhnMwc2tiRacXbMHVf1xM,1943
 fast_agent/llm/provider/openai/llm_tensorzero_openai.py,sha256=yrV0kZ2zRohErdjhvWGDTl0OnPi2SbuzY_8MchXiVTU,5466
 fast_agent/llm/provider/openai/llm_xai.py,sha256=fEyO9XlU3Ef1a-cXdJl0Qe-FmE562cA-UJOGvzqLO6M,1375
@@ -194,10 +194,10 @@ fast_agent/ui/interactive_prompt.py,sha256=lxY26PNBNihtccO4iI7CxIag_9CxEcbajbIPd
 fast_agent/ui/mcp_ui_utils.py,sha256=UVX-VZI7PaJ8JlYuWsletml4K3XrUGUFRn4lqFwsAWg,8099
 fast_agent/ui/mermaid_utils.py,sha256=MpcRyVCPMTwU1XeIxnyFg0fQLjcyXZduWRF8NhEqvXE,5332
 fast_agent/ui/progress_display.py,sha256=hajDob65PttiJ2mPS6FsCtnmTcnyvDWGn-UqQboXqkQ,361
-fast_agent/ui/rich_progress.py,sha256=vMeDD5cybsPf_0IjOM98U8TVaE_yYIOKZa8JnRgTYUo,7451
+fast_agent/ui/rich_progress.py,sha256=jy6VuUOYFkWXdyvnRTSBPAmmNAP6TJDFw_lgbt_YYLo,7548
 fast_agent/ui/usage_display.py,sha256=ltJpn_sDzo8PDNSXWx-QdEUbQWUnhmajCItNt5mA5rM,7285
-fast_agent_mcp-0.3.2.dist-info/METADATA,sha256=iaD5FYCGdDqTIAnGvq32PatCS2P-SbVzy-x79bmfIUA,30462
-fast_agent_mcp-0.3.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-fast_agent_mcp-0.3.2.dist-info/entry_points.txt,sha256=i6Ujja9J-hRxttOKqTYdbYP_tyaS4gLHg53vupoCSsg,199
-fast_agent_mcp-0.3.2.dist-info/licenses/LICENSE,sha256=Gx1L3axA4PnuK4FxsbX87jQ1opoOkSFfHHSytW6wLUU,10935
-fast_agent_mcp-0.3.2.dist-info/RECORD,,
+fast_agent_mcp-0.3.3.dist-info/METADATA,sha256=OaL4vvtEurj2Cffo53cry42F1aGNlJxWGMkZj9qmDVg,30462
+fast_agent_mcp-0.3.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+fast_agent_mcp-0.3.3.dist-info/entry_points.txt,sha256=i6Ujja9J-hRxttOKqTYdbYP_tyaS4gLHg53vupoCSsg,199
+fast_agent_mcp-0.3.3.dist-info/licenses/LICENSE,sha256=Gx1L3axA4PnuK4FxsbX87jQ1opoOkSFfHHSytW6wLUU,10935
+fast_agent_mcp-0.3.3.dist-info/RECORD,,