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

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/mcp/ui_agent.py

@@ -9,7 +9,7 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING, Any
 
-from fast_agent.agents.mcp_agent import McpAgent
+from fast_agent.agents import McpAgent
 from fast_agent.mcp.ui_mixin import McpUIMixin
 
 if TYPE_CHECKING:

fast_agent/resources/examples/data-analysis/analysis-campaign.py

@@ -1,6 +1,6 @@
 import asyncio
 
-from fast_agent.core.fastagent import FastAgent
+from fast_agent import FastAgent
 from fast_agent.llm.fastagent_llm import RequestParams
 
 # Create the application

fast_agent/resources/examples/data-analysis/analysis.py

@@ -1,6 +1,6 @@
 import asyncio
 
-from fast_agent.core.fastagent import FastAgent
+from fast_agent import FastAgent
 
 # Create the application
 fast = FastAgent("Data Analysis (Roots)")

fast_agent/resources/examples/mcp/elicitations/forms_demo.py

@@ -13,7 +13,7 @@ import asyncio
 from rich.console import Console
 from rich.panel import Panel
 
-from fast_agent.core.fastagent import FastAgent
+from fast_agent import FastAgent
 from fast_agent.mcp.helpers.content_helpers import get_resource_text
 
 fast = FastAgent("Elicitation Forms Demo", quiet=True)

fast_agent/resources/examples/mcp/elicitations/game_character.py

@@ -14,7 +14,7 @@ from game_character_handler import game_character_elicitation_handler
 from rich.console import Console
 from rich.panel import Panel
 
-from fast_agent.core.fastagent import FastAgent
+from fast_agent import FastAgent
 from fast_agent.mcp.helpers.content_helpers import get_resource_text
 
 fast = FastAgent("Game Character Creator", quiet=True)

fast_agent/resources/examples/mcp/elicitations/tool_call.py

@@ -1,6 +1,6 @@
 import asyncio
 
-from fast_agent.core.fastagent import FastAgent
+from fast_agent import FastAgent
 
 # Create the application
 fast = FastAgent("fast-agent example")

fast_agent/resources/examples/mcp/state-transfer/agent_one.py

@@ -1,6 +1,6 @@
 import asyncio
 
-from fast_agent.core.fastagent import FastAgent
+from fast_agent import FastAgent
 
 # Create the application
 fast = FastAgent("fast-agent agent_one (mcp server)")

fast_agent/resources/examples/mcp/state-transfer/agent_two.py

@@ -1,6 +1,6 @@
 import asyncio
 
-from fast_agent.core.fastagent import FastAgent
+from fast_agent import FastAgent
 
 # Create the application
 fast = FastAgent("fast-agent agent_two (mcp client)")

fast_agent/resources/examples/researcher/researcher-eval.py

@@ -1,6 +1,6 @@
 import asyncio
 
-from fast_agent.core.fastagent import FastAgent
+from fast_agent import FastAgent
 
 agents = FastAgent(name="Researcher Agent (EO)")
 

fast_agent/resources/examples/researcher/researcher-imp.py

@@ -1,6 +1,6 @@
 import asyncio
 
-from fast_agent.core.fastagent import FastAgent
+from fast_agent import FastAgent
 
 agents = FastAgent(name="Enhanced Researcher")
 

fast_agent/resources/examples/researcher/researcher.py

@@ -1,6 +1,6 @@
 import asyncio
 
-from fast_agent.core.fastagent import FastAgent
+from fast_agent import FastAgent
 
 # from rich import print
 

fast_agent/resources/examples/tensorzero/agent.py

@@ -1,6 +1,6 @@
 import asyncio
 
-from fast_agent.core.fastagent import FastAgent
+from fast_agent import FastAgent
 from fast_agent.llm.request_params import RequestParams
 
 # Explicitly provide the path to the config file in the current directory

fast_agent/resources/examples/tensorzero/image_demo.py

@@ -6,7 +6,7 @@ from typing import List, Union
 
 from mcp.types import ImageContent, TextContent
 
-from fast_agent.core.fastagent import FastAgent
+from fast_agent import FastAgent
 from fast_agent.core.prompt import Prompt
 from fast_agent.llm.request_params import RequestParams
 

fast_agent/resources/examples/tensorzero/simple_agent.py

@@ -1,6 +1,6 @@
 import asyncio
 
-from fast_agent.core.fastagent import FastAgent
+from fast_agent import FastAgent
 
 CONFIG_FILE = "fastagent.config.yaml"
 fast = FastAgent("fast-agent example", config_path=CONFIG_FILE, ignore_unknown_args=True)

fast_agent/resources/examples/workflows/chaining.py

@@ -1,6 +1,6 @@
 import asyncio
 
-from fast_agent.core.fastagent import FastAgent
+from fast_agent import FastAgent
 
 # Create the application
 fast = FastAgent("Agent Chaining")