fast-agent-mcp 0.3.8__py3-none-any.whl → 0.3.10__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
@@ -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(

fast_agent/agents/mcp_agent.py

@@ -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,
@@ -163,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/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/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/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/openai/llm_openai.py

@@ -344,12 +344,12 @@ class OpenAILLM(FastAgentLLM[ChatCompletionMessageParam, ChatCompletionMessage])
         model_name = self.default_request_params.model or DEFAULT_OPENAI_MODEL
 
         # Use basic streaming API
-        stream = await self._openai_client().chat.completions.create(**arguments)
-        # Process the stream
         try:
+            stream = await self._openai_client().chat.completions.create(**arguments)
+            # Process the stream
             response = await self._process_stream(stream, model_name)
         except APIError as error:
-            self.logger.error("Streaming APIError during OpenAI completion", exc_info=error)
+            self.logger.error("APIError during OpenAI completion", exc_info=error)
             return self._stream_failure_response(error, model_name)
         # Track usage if response is valid and has usage data
         if (

fast_agent/mcp/mcp_agent_client_session.py

@@ -37,6 +37,7 @@ from fast_agent.mcp.sampling import sample
 
 if TYPE_CHECKING:
     from fast_agent.config import MCPServerSettings
+    from fast_agent.mcp.transport_tracking import TransportChannelMetrics
 
 logger = get_logger(__name__)
 
@@ -90,6 +91,13 @@ class MCPAgentClientSession(ClientSession, ContextDependent):
         custom_elicitation_handler = kwargs.pop("elicitation_handler", None)
         # Extract optional context for ContextDependent mixin without passing it to ClientSession
         self._context = kwargs.pop("context", None)
+        # Extract transport metrics tracker if provided
+        self._transport_metrics: TransportChannelMetrics | None = kwargs.pop(
+            "transport_metrics", None
+        )
+
+        # Track the effective elicitation mode for diagnostics
+        self.effective_elicitation_mode: str | None = "none"
 
         version = version("fast-agent-mcp") or "dev"
         fast_agent: Implementation = Implementation(name="fast-agent-mcp", version=version)
@@ -131,7 +139,7 @@ class MCPAgentClientSession(ClientSession, ContextDependent):
                     agent_config = AgentConfig(
                         name=self.agent_name or "unknown",
                         model=self.agent_model or "unknown",
-                        elicitation_handler=None,  # No decorator-level handler since we're in the else block
+                        elicitation_handler=None,
                     )
                     elicitation_handler = resolve_elicitation_handler(
                         agent_config, context.config, self.server_config
@@ -141,12 +149,33 @@ class MCPAgentClientSession(ClientSession, ContextDependent):
                 pass
 
             # Fallback to forms handler only if factory resolution wasn't attempted
-            # If factory was attempted and returned None, respect that (means no elicitation capability)
             if elicitation_handler is None and not self.server_config:
                 from fast_agent.mcp.elicitation_handlers import forms_elicitation_handler
 
                 elicitation_handler = forms_elicitation_handler
 
+        # Determine effective elicitation mode for diagnostics
+        if self.server_config and getattr(self.server_config, "elicitation", None):
+            self.effective_elicitation_mode = self.server_config.elicitation.mode or "forms"
+        elif elicitation_handler is not None:
+            # Use global config if available to distinguish auto-cancel
+            try:
+                from fast_agent.context import get_current_context
+
+                context = get_current_context()
+                mode = None
+                if context and getattr(context, "config", None):
+                    elicitation_cfg = getattr(context.config, "elicitation", None)
+                    if isinstance(elicitation_cfg, dict):
+                        mode = elicitation_cfg.get("mode")
+                    else:
+                        mode = getattr(elicitation_cfg, "mode", None)
+                self.effective_elicitation_mode = (mode or "forms").lower()
+            except Exception:
+                self.effective_elicitation_mode = "forms"
+        else:
+            self.effective_elicitation_mode = "none"
+
         super().__init__(
             *args,
             **kwargs,
@@ -177,6 +206,7 @@ class MCPAgentClientSession(ClientSession, ContextDependent):
         progress_callback: ProgressFnT | None = None,
     ) -> ReceiveResultT:
         logger.debug("send_request: request=", data=request.model_dump())
+        request_id = getattr(self, "_request_id", None)
         try:
             result = await super().send_request(
                 request=request,
@@ -189,6 +219,7 @@ class MCPAgentClientSession(ClientSession, ContextDependent):
                 "send_request: response=",
                 data=result.model_dump() if result is not None else "no response returned",
             )
+            self._attach_transport_channel(request_id, result)
             return result
         except Exception as e:
             # Handle connection errors cleanly
@@ -207,6 +238,18 @@ class MCPAgentClientSession(ClientSession, ContextDependent):
                 logger.error(f"send_request failed: {str(e)}")
                 raise
 
+    def _attach_transport_channel(self, request_id, result) -> None:
+        if self._transport_metrics is None or request_id is None or result is None:
+            return
+        channel = self._transport_metrics.consume_response_channel(request_id)
+        if not channel:
+            return
+        try:
+            setattr(result, "transport_channel", channel)
+        except Exception:
+            # If result cannot be mutated, ignore silently
+            pass
+
     async def _received_notification(self, notification: ServerNotification) -> None:
         """
         Can be overridden by subclasses to handle a notification without needing