fast-agent-mcp 0.3.7__py3-none-any.whl → 0.3.9__py3-none-any.whl

fast_agent/agents/llm_agent.py

@@ -27,7 +27,9 @@ from rich.text import Text
 
 from fast_agent.agents.agent_types import AgentConfig
 from fast_agent.agents.llm_decorator import LlmDecorator, ModelT
+from fast_agent.constants import FAST_AGENT_ERROR_CHANNEL
 from fast_agent.context import Context
+from fast_agent.mcp.helpers.content_helpers import get_text
 from fast_agent.types import PromptMessageExtended, RequestParams
 from fast_agent.types.llm_stop_reason import LlmStopReason
 from fast_agent.ui.console_display import ConsoleDisplay
@@ -45,7 +47,7 @@ class LlmAgent(LlmDecorator):
 
     This class provides LLM-specific functionality including UI display methods,
     tool call tracking, and chat interaction patterns while delegating core
-    LLM operations to the attached AugmentedLLMProtocol.
+    LLM operations to the attached FastAgentLLMProtocol.
     """
 
     def __init__(
@@ -123,6 +125,28 @@ class LlmAgent(LlmDecorator):
                         Text("The assistant requested tool calls", style="dim green italic")
                     )
 
+            case LlmStopReason.ERROR:
+                # Check if there's detailed error information in the error channel
+                if message.channels and FAST_AGENT_ERROR_CHANNEL in message.channels:
+                    error_blocks = message.channels[FAST_AGENT_ERROR_CHANNEL]
+                    if error_blocks:
+                        # Extract text from the error block using the helper function
+                        error_text = get_text(error_blocks[0])
+                        if error_text:
+                            additional_segments.append(
+                                Text(f"\n\nError details: {error_text}", style="dim red italic")
+                            )
+                        else:
+                            # Fallback if we couldn't extract text
+                            additional_segments.append(
+                                Text(f"\n\nError details: {str(error_blocks[0])}", style="dim red italic")
+                            )
+                else:
+                    # Fallback if no detailed error is available
+                    additional_segments.append(
+                        Text("\n\nAn error occurred during generation.", style="dim red italic")
+                    )
+
             case _:
                 if message.stop_reason:
                     additional_segments.append(
@@ -134,7 +158,9 @@ class LlmAgent(LlmDecorator):
 
         if additional_message is not None:
             additional_segments.append(
-                additional_message if isinstance(additional_message, Text) else Text(str(additional_message))
+                additional_message
+                if isinstance(additional_message, Text)
+                else Text(str(additional_message))
             )
 
         additional_message_text = None
@@ -197,9 +223,7 @@ class LlmAgent(LlmDecorator):
         # TODO - manage error catch, recovery, pause
         result, summary = await self._generate_with_summary(messages, request_params, tools)
 
-        summary_text = (
-            Text(f"\n\n{summary.message}", style="dim red italic") if summary else None
-        )
+        summary_text = Text(f"\n\n{summary.message}", style="dim red italic") if summary else None
 
         await self.show_assistant_message(result, additional_message=summary_text)
         return result
@@ -216,9 +240,7 @@ class LlmAgent(LlmDecorator):
         (result, message), summary = await self._structured_with_summary(
             messages, model, request_params
         )
-        summary_text = (
-            Text(f"\n\n{summary.message}", style="dim red italic") if summary else None
-        )
+        summary_text = Text(f"\n\n{summary.message}", style="dim red italic") if summary else None
         await self.show_assistant_message(message=message, additional_message=summary_text)
         return result, message
 

fast_agent/agents/llm_decorator.py

@@ -57,7 +57,6 @@ from fast_agent.types import PromptMessageExtended, RequestParams
 # Define a TypeVar for models
 ModelT = TypeVar("ModelT", bound=BaseModel)
 
-# Define a TypeVar for AugmentedLLM and its subclasses
 LLM = TypeVar("LLM", bound=FastAgentLLMProtocol)
 
 
@@ -533,9 +532,7 @@ class LlmDecorator(AgentProtocol):
         if isinstance(block, EmbeddedResource):
             resource = getattr(block, "resource", None)
             mime = getattr(resource, "mimeType", None)
-            if isinstance(resource, TextResourceContents) or (
-                mime and is_text_mime_type(mime)
-            ):
+            if isinstance(resource, TextResourceContents) or (mime and is_text_mime_type(mime)):
                 return mime or "text/plain", "text"
             if mime and mime.startswith("image/"):
                 return mime, "vision"
@@ -593,9 +590,7 @@ class LlmDecorator(AgentProtocol):
             entries.append(metadata_text)
         return entries
 
-    def _build_removed_summary(
-        self, removed: List[_RemovedBlock]
-    ) -> RemovedContentSummary | None:
+    def _build_removed_summary(self, removed: List[_RemovedBlock]) -> RemovedContentSummary | None:
         if not removed:
             return None
 

fast_agent/agents/mcp_agent.py

@@ -2,7 +2,7 @@
 Base Agent class that implements the AgentProtocol interface.
 
 This class provides default implementations of the standard agent methods
-and delegates operations to an attached AugmentedLLMProtocol instance.
+and delegates operations to an attached FastAgentLLMProtocol instance.
 """
 
 import asyncio
@@ -41,7 +41,7 @@ from fast_agent.constants import HUMAN_INPUT_TOOL_NAME
 from fast_agent.core.exceptions import PromptExitError
 from fast_agent.core.logging.logger import get_logger
 from fast_agent.interfaces import FastAgentLLMProtocol
-from fast_agent.mcp.mcp_aggregator import MCPAggregator
+from fast_agent.mcp.mcp_aggregator import MCPAggregator, ServerStatus
 from fast_agent.tools.elicitation import (
     get_elicitation_tool,
     run_elicitation_form,
@@ -52,7 +52,6 @@ from fast_agent.types import PromptMessageExtended, RequestParams
 # Define a TypeVar for models
 ModelT = TypeVar("ModelT", bound=BaseModel)
 
-# Define a TypeVar for AugmentedLLM and its subclasses
 LLM = TypeVar("LLM", bound=FastAgentLLMProtocol)
 
 if TYPE_CHECKING:
@@ -67,7 +66,7 @@ class McpAgent(ABC, ToolAgent):
     A base Agent class that implements the AgentProtocol interface.
 
     This class provides default implementations of the standard agent methods
-    and delegates LLM operations to an attached AugmentedLLMProtocol instance.
+    and delegates LLM operations to an attached FastAgentLLMProtocol instance.
     """
 
     def __init__(
@@ -164,6 +163,12 @@ class McpAgent(ABC, ToolAgent):
         """
         await self._aggregator.close()
 
+    async def get_server_status(self) -> Dict[str, ServerStatus]:
+        """Expose server status details for UI and diagnostics consumers."""
+        if not self._aggregator:
+            return {}
+        return await self._aggregator.collect_server_status()
+
     @property
     def initialized(self) -> bool:
         """Check if both the agent and aggregator are initialized."""

fast_agent/cli/commands/auth.py

@@ -293,7 +293,9 @@ def main(
 
 @app.command()
 def login(
-    target: str = typer.Argument(..., help="Server name (from config) or identity (base URL)"),
+    target: Optional[str] = typer.Argument(
+        None, help="Server name (from config) or identity (base URL)"
+    ),
     transport: Optional[str] = typer.Option(
         None, "--transport", help="Transport for identity mode: http or sse"
     ),
@@ -311,6 +313,17 @@ def login(
     cfg = None
     resolved_transport = None
 
+    if target is None or not target.strip():
+        typer.echo("Provide a server name or identity URL to log in.")
+        typer.echo(
+            "Example: `fast-agent auth login my-server` "
+            "or `fast-agent auth login https://example.com`."
+        )
+        typer.echo("Run `fast-agent auth login --help` for more details.")
+        raise typer.Exit(1)
+
+    target = target.strip()
+
     if "://" in target:
         # Identity mode
         base = _derive_base_server_url(target)

fast_agent/core/direct_factory.py

@@ -153,14 +153,6 @@ async def create_agents_by_type(
 
     # Get all agents of the specified type
     for name, agent_data in agents_dict.items():
-        logger.info(
-            f"Loaded {name}",
-            data={
-                "progress_action": ProgressAction.LOADED,
-                "agent_name": name,
-            },
-        )
-
         # Compare type string from config with Enum value
         if agent_data["type"] == agent_type.value:
             # Get common configuration
@@ -187,6 +179,16 @@ async def create_agents_by_type(
                 )
                 result_agents[name] = agent
 
+                # Log successful agent creation
+                logger.info(
+                    f"Loaded {name}",
+                    data={
+                        "progress_action": ProgressAction.LOADED,
+                        "agent_name": name,
+                        "target": name,
+                    },
+                )
+
             elif agent_type == AgentType.CUSTOM:
                 # Get the class to instantiate (support legacy 'agent_class' and new 'cls')
                 cls = agent_data.get("agent_class") or agent_data.get("cls")
@@ -212,6 +214,16 @@ async def create_agents_by_type(
                 )
                 result_agents[name] = agent
 
+                # Log successful agent creation
+                logger.info(
+                    f"Loaded {name}",
+                    data={
+                        "progress_action": ProgressAction.LOADED,
+                        "agent_name": name,
+                        "target": name,
+                    },
+                )
+
             elif agent_type == AgentType.ORCHESTRATOR or agent_type == AgentType.ITERATIVE_PLANNER:
                 # Get base params configured with model settings
                 base_params = (

fast_agent/core/logging/listeners.py

@@ -55,7 +55,8 @@ def convert_log_event(event: Event) -> "ProgressEvent | None":
             if progress_message:  # Only override if message is non-empty
                 details = progress_message
 
-    elif "augmented_llm" in namespace:
+    # TODO: there must be a better way :D?!
+    elif "llm" in namespace:
         model = event_data.get("model", "")
 
         # For all augmented_llm events, put model info in details column

fast_agent/interfaces.py

@@ -47,7 +47,7 @@ ModelT = TypeVar("ModelT", bound=BaseModel)
 
 
 class LLMFactoryProtocol(Protocol):
-    """Protocol for LLM factory functions that create AugmentedLLM instances."""
+    """Protocol for LLM factory functions that create FastAgentLLM instances."""
 
     def __call__(self, agent: "LlmAgentProtocol", **kwargs: Any) -> "FastAgentLLMProtocol": ...
 
@@ -59,7 +59,7 @@ class ModelFactoryFunctionProtocol(Protocol):
 
 
 class FastAgentLLMProtocol(Protocol):
-    """Protocol defining the interface for augmented LLMs"""
+    """Protocol defining the interface for LLMs"""
 
     async def structured(
         self,

fast_agent/llm/model_database.py

@@ -164,7 +164,11 @@ class ModelDatabase:
     )
 
     # FIXME: xAI has not documented the max output tokens for Grok 4. Using Grok 3 as a placeholder. Will need to update when available (if ever)
-    GROK_4 = ModelParameters(context_window=256000, max_output_tokens=16385, tokenizes=XAI_VISION)
+    GROK_4 = ModelParameters(context_window=256000, max_output_tokens=16385, tokenizes=TEXT_ONLY)
+
+    GROK_4_VLM = ModelParameters(
+        context_window=2000000, max_output_tokens=16385, tokenizes=XAI_VISION
+    )
 
     # Source for Grok 3 max output: https://www.reddit.com/r/grok/comments/1j7209p/exploring_grok_3_beta_output_capacity_a_simple/
     # xAI does not document Grok 3 max output tokens, using the above source as a reference.
@@ -240,6 +244,8 @@ class ModelDatabase:
         "gemini-2.5-flash-preview-05-20": GEMINI_FLASH,
         "gemini-2.5-pro-preview-05-06": GEMINI_PRO,
         # xAI Grok Models
+        "grok-4-fast-reasoning": GROK_4_VLM,
+        "grok-4-fast-non-reasoning": GROK_4_VLM,
         "grok-4": GROK_4,
         "grok-4-0709": GROK_4,
         "grok-3": GROK_3,

fast_agent/llm/model_factory.py

@@ -12,9 +12,6 @@ from fast_agent.llm.internal.slow import SlowLLM
 from fast_agent.llm.provider_types import Provider
 from fast_agent.types import RequestParams
 
-# from fast_agent.workflows.llm.augmented_llm_deepseek import DeekSeekAugmentedLLM
-
-
 # Type alias for LLM classes
 LLMClass = Union[Type[PassthroughLLM], Type[PlaybackLLM], Type[SilentLLM], Type[SlowLLM], type]
 
@@ -123,6 +120,8 @@ class ModelFactory:
         "kimi": "groq.moonshotai/kimi-k2-instruct-0905",
         "gpt-oss": "groq.openai/gpt-oss-120b",
         "gpt-oss-20b": "groq.openai/gpt-oss-20b",
+        "grok-4-fast": "xai.grok-4-fast-non-reasoning",
+        "grok-4-fast-reasoning": "xai.grok-4-fast-reasoning",
     }
 
     @staticmethod

fast_agent/llm/provider/anthropic/llm_anthropic.py

@@ -1,7 +1,7 @@
 import json
 from typing import Any, List, Tuple, Type, Union, cast
 
-from anthropic import AsyncAnthropic, AuthenticationError
+from anthropic import APIError, AsyncAnthropic, AuthenticationError
 from anthropic.lib.streaming import AsyncMessageStream
 from anthropic.types import (
     Message,
@@ -22,6 +22,7 @@ from mcp.types import (
     TextContent,
 )
 
+from fast_agent.constants import FAST_AGENT_ERROR_CHANNEL
 from fast_agent.core.exceptions import ProviderKeyError
 from fast_agent.core.logging.logger import get_logger
 from fast_agent.core.prompt import Prompt
@@ -36,6 +37,7 @@ from fast_agent.llm.provider.anthropic.multipart_converter_anthropic import (
 )
 from fast_agent.llm.provider_types import Provider
 from fast_agent.llm.usage_tracking import TurnUsage
+from fast_agent.mcp.helpers.content_helpers import text_content
 from fast_agent.types import PromptMessageExtended
 from fast_agent.types.llm_stop_reason import LlmStopReason
 
@@ -243,47 +245,102 @@ class AnthropicLLM(FastAgentLLM[MessageParam, Message]):
         # Track estimated output tokens by counting text chunks
         estimated_tokens = 0
 
-        # Process the raw event stream to get token counts
-        async for event in stream:
-            # Count tokens in real-time from content_block_delta events
-            if (
-                event.type == "content_block_delta"
-                and hasattr(event, "delta")
-                and event.delta.type == "text_delta"
-            ):
-                # Use base class method for token estimation and progress emission
-                estimated_tokens = self._update_streaming_progress(
-                    event.delta.text, model, estimated_tokens
+        try:
+            # Process the raw event stream to get token counts
+            async for event in stream:
+                # Count tokens in real-time from content_block_delta events
+                if (
+                    event.type == "content_block_delta"
+                    and hasattr(event, "delta")
+                    and event.delta.type == "text_delta"
+                ):
+                    # Use base class method for token estimation and progress emission
+                    estimated_tokens = self._update_streaming_progress(
+                        event.delta.text, model, estimated_tokens
+                    )
+
+                # Also check for final message_delta events with actual usage info
+                elif (
+                    event.type == "message_delta"
+                    and hasattr(event, "usage")
+                    and event.usage.output_tokens
+                ):
+                    actual_tokens = event.usage.output_tokens
+                    # Emit final progress with actual token count
+                    token_str = str(actual_tokens).rjust(5)
+                    data = {
+                        "progress_action": ProgressAction.STREAMING,
+                        "model": model,
+                        "agent_name": self.name,
+                        "chat_turn": self.chat_turn(),
+                        "details": token_str.strip(),
+                    }
+                    logger.info("Streaming progress", data=data)
+
+            # Get the final message with complete usage data
+            message = await stream.get_final_message()
+
+            # Log final usage information
+            if hasattr(message, "usage") and message.usage:
+                logger.info(
+                    f"Streaming complete - Model: {model}, Input tokens: {message.usage.input_tokens}, Output tokens: {message.usage.output_tokens}"
                 )
 
-            # Also check for final message_delta events with actual usage info
-            elif (
-                event.type == "message_delta"
-                and hasattr(event, "usage")
-                and event.usage.output_tokens
-            ):
-                actual_tokens = event.usage.output_tokens
-                # Emit final progress with actual token count
-                token_str = str(actual_tokens).rjust(5)
-                data = {
-                    "progress_action": ProgressAction.STREAMING,
-                    "model": model,
-                    "agent_name": self.name,
-                    "chat_turn": self.chat_turn(),
-                    "details": token_str.strip(),
-                }
-                logger.info("Streaming progress", data=data)
-
-        # Get the final message with complete usage data
-        message = await stream.get_final_message()
-
-        # Log final usage information
-        if hasattr(message, "usage") and message.usage:
-            logger.info(
-                f"Streaming complete - Model: {model}, Input tokens: {message.usage.input_tokens}, Output tokens: {message.usage.output_tokens}"
+            return message
+        except APIError as error:
+            logger.error("Streaming APIError during Anthropic completion", exc_info=error)
+            raise  # Re-raise to be handled by _anthropic_completion
+        except Exception as error:
+            logger.error("Unexpected error during Anthropic stream processing", exc_info=error)
+            # Convert to APIError for consistent handling
+            raise APIError(f"Stream processing error: {str(error)}") from error
+
+    def _stream_failure_response(self, error: APIError, model_name: str) -> PromptMessageExtended:
+        """Convert streaming API errors into a graceful assistant reply."""
+
+        provider_label = (
+            self.provider.value if isinstance(self.provider, Provider) else str(self.provider)
+        )
+        detail = getattr(error, "message", None) or str(error)
+        detail = detail.strip() if isinstance(detail, str) else ""
+
+        parts: list[str] = [f"{provider_label} request failed"]
+        if model_name:
+            parts.append(f"for model '{model_name}'")
+        code = getattr(error, "code", None)
+        if code:
+            parts.append(f"(code: {code})")
+        status = getattr(error, "status_code", None)
+        if status:
+            parts.append(f"(status={status})")
+
+        message = " ".join(parts)
+        if detail:
+            message = f"{message}: {detail}"
+
+        user_summary = " ".join(message.split()) if message else ""
+        if user_summary and len(user_summary) > 280:
+            user_summary = user_summary[:277].rstrip() + "..."
+
+        if user_summary:
+            assistant_text = f"I hit an internal error while calling the model: {user_summary}"
+            if not assistant_text.endswith((".", "!", "?")):
+                assistant_text += "."
+            assistant_text += " See fast-agent-error for additional details."
+        else:
+            assistant_text = (
+                "I hit an internal error while calling the model; see fast-agent-error for details."
             )
 
-        return message
+        assistant_block = text_content(assistant_text)
+        error_block = text_content(message)
+
+        return PromptMessageExtended(
+            role="assistant",
+            content=[assistant_block],
+            channels={FAST_AGENT_ERROR_CHANNEL: [error_block]},
+            stop_reason=LlmStopReason.ERROR,
+        )
 
     async def _anthropic_completion(
         self,
@@ -369,9 +426,13 @@ class AnthropicLLM(FastAgentLLM[MessageParam, Message]):
 
         logger.debug(f"{arguments}")
         # Use streaming API with helper
-        async with anthropic.messages.stream(**arguments) as stream:
-            # Process the stream
-            response = await self._process_stream(stream, model)
+        try:
+            async with anthropic.messages.stream(**arguments) as stream:
+                # Process the stream
+                response = await self._process_stream(stream, model)
+        except APIError as error:
+            logger.error("Streaming APIError during Anthropic completion", exc_info=error)
+            return self._stream_failure_response(error, model)
 
         # Track usage if response is valid and has usage data
         if (
@@ -393,27 +454,11 @@ class AnthropicLLM(FastAgentLLM[MessageParam, Message]):
                 "The configured Anthropic API key was rejected.\nPlease check that your API key is valid and not expired.",
             ) from response
         elif isinstance(response, BaseException):
-            error_details = str(response)
-            logger.error(f"Error: {error_details}", data=BaseException)
-
-            # Try to extract more useful information for API errors
-            if hasattr(response, "status_code") and hasattr(response, "response"):
-                try:
-                    error_json = response.response.json()
-                    error_details = f"Error code: {response.status_code} - {error_json}"
-                except:  # noqa: E722
-                    error_details = f"Error code: {response.status_code} - {str(response)}"
-
-            # Convert other errors to text response
-            error_message = f"Error during generation: {error_details}"
-            response = Message(
-                id="error",
-                model="error",
-                role="assistant",
-                type="message",
-                content=[TextBlock(type="text", text=error_message)],
-                stop_reason="end_turn",
-                usage=Usage(input_tokens=0, output_tokens=0),
+            # This path shouldn't be reached anymore since we handle APIError above,
+            # but keeping for backward compatibility
+            logger.error(f"Unexpected error type: {type(response).__name__}", exc_info=response)
+            return self._stream_failure_response(
+                APIError(f"Unexpected error: {str(response)}"), model
             )
 
         logger.debug(

fast_agent/llm/provider/anthropic/multipart_converter_anthropic.py

@@ -273,7 +273,7 @@ class AnthropicConverter:
                     title=title,
                     source=URLPDFSourceParam(type="url", url=uri_str),
                 )
-            elif hasattr(resource_content, "blob"):
+            elif isinstance(resource_content, BlobResourceContents):
                 return DocumentBlockParam(
                     type="document",
                     title=title,
@@ -362,8 +362,9 @@ class AnthropicConverter:
         Returns:
             A TextBlockParam with formatted SVG content
         """
-        if hasattr(resource_content, "text"):
-            svg_content = resource_content.text
+        # Use get_text helper to extract text from various content types
+        svg_content = get_text(resource_content)
+        if svg_content:
             return TextBlockParam(type="text", text=f"```xml\n{svg_content}\n```")
         return TextBlockParam(type="text", text="[SVG content could not be extracted]")
 

fast_agent/llm/provider/bedrock/llm_bedrock.py

@@ -126,7 +126,7 @@ class ModelCapabilities:
 
 class BedrockLLM(FastAgentLLM[BedrockMessageParam, BedrockMessage]):
     """
-    AWS Bedrock implementation of AugmentedLLM using the Converse API.
+    AWS Bedrock implementation of FastAgentLLM using the Converse API.
     Supports all Bedrock models including Nova, Claude, Meta, etc.
     """
 

fast_agent/llm/provider/google/google_converter.py

@@ -142,7 +142,6 @@ class GoogleConverter:
                     assert isinstance(part_content, EmbeddedResource)
                     if (
                         "application/pdf" == part_content.resource.mimeType
-                        and hasattr(part_content.resource, "blob")
                         and isinstance(part_content.resource, BlobResourceContents)
                     ):
                         pdf_bytes = base64.b64decode(part_content.resource.blob)
@@ -154,31 +153,15 @@ class GoogleConverter:
                         )
                     else:
                         # Check if the resource itself has text content
-                        resource_text = None
-                        if hasattr(part_content.resource, "text"):  # Direct text attribute
-                            resource_text = part_content.resource.text
-                        # Example: if EmbeddedResource wraps a TextContent-like object in its 'resource' field
-                        elif (
-                            hasattr(part_content.resource, "type")
-                            and part_content.resource.type == "text"
-                            and hasattr(part_content.resource, "text")
-                        ):
-                            resource_text = get_text(part_content.resource)
+                        # Use get_text helper to extract text from various content types
+                        resource_text = get_text(part_content.resource)
 
                         if resource_text is not None:
                             parts.append(types.Part.from_text(text=resource_text))
                         else:
                             # Fallback for other binary types or types without direct text
-                            uri_str = (
-                                part_content.resource.uri
-                                if hasattr(part_content.resource, "uri")
-                                else "unknown_uri"
-                            )
-                            mime_str = (
-                                part_content.resource.mimeType
-                                if hasattr(part_content.resource, "mimeType")
-                                else "unknown_mime"
-                            )
+                            uri_str = getattr(part_content.resource, "uri", "unknown_uri")
+                            mime_str = getattr(part_content.resource, "mimeType", "unknown_mime")
                             parts.append(
                                 types.Part.from_text(
                                     text=f"[Resource: {uri_str}, MIME: {mime_str}]"
@@ -291,30 +274,14 @@ class GoogleConverter:
                             textual_outputs.append(f"[Error processing PDF from tool result: {e}]")
                     else:
                         # Check if the resource itself has text content
-                        resource_text = None
-                        if hasattr(item.resource, "text"):  # Direct text attribute
-                            resource_text = item.resource.text
-                        # Example: if EmbeddedResource wraps a TextContent-like object in its 'resource' field
-                        elif (
-                            hasattr(item.resource, "type")
-                            and item.resource.type == "text"
-                            and hasattr(item.resource, "text")
-                        ):
-                            resource_text = get_text(item.resource)
+                        # Use get_text helper to extract text from various content types
+                        resource_text = get_text(item.resource)
 
                         if resource_text is not None:
                             textual_outputs.append(resource_text)
                         else:
-                            uri_str = (
-                                item.resource.uri
-                                if hasattr(item.resource, "uri")
-                                else "unknown_uri"
-                            )
-                            mime_str = (
-                                item.resource.mimeType
-                                if hasattr(item.resource, "mimeType")
-                                else "unknown_mime"
-                            )
+                            uri_str = getattr(item.resource, "uri", "unknown_uri")
+                            mime_str = getattr(item.resource, "mimeType", "unknown_mime")
                             textual_outputs.append(
                                 f"[Unhandled Resource in Tool: {uri_str}, MIME: {mime_str}]"
                             )

fast_agent/llm/provider/google/llm_google_native.py

@@ -36,10 +36,8 @@ GOOGLE_EXCLUDE_FIELDS = {
     FastAgentLLM.PARAM_MESSAGES,  # Handled by contents
     FastAgentLLM.PARAM_MODEL,  # Handled during client/call setup
     FastAgentLLM.PARAM_SYSTEM_PROMPT,  # Handled by system_instruction in config
-    # AugmentedLLM.PARAM_PARALLEL_TOOL_CALLS, # Handled by tool_config in config
-    FastAgentLLM.PARAM_USE_HISTORY,  # Handled by AugmentedLLM base / this class's logic
+    FastAgentLLM.PARAM_USE_HISTORY,  # Handled by FastAgentLLM base / this class's logic
     FastAgentLLM.PARAM_MAX_ITERATIONS,  # Handled by this class's loop
-    # Add any other OpenAI-specific params not applicable to google.genai
     FastAgentLLM.PARAM_MCP_METADATA,
 }.union(FastAgentLLM.BASE_EXCLUDE_FIELDS)
 

fast_agent/llm/provider/openai/llm_azure.py

@@ -23,7 +23,7 @@ DEFAULT_AZURE_API_VERSION = "2024-10-21"
 
 class AzureOpenAILLM(OpenAILLM):
     """
-    Azure OpenAI implementation extending OpenAIAugmentedLLM.
+    Azure OpenAI implementation extending OpenAILLM.
     Handles both API Key and DefaultAzureCredential authentication.
     """