fast-agent-mcp 0.2.56__py3-none-any.whl → 0.2.58__py3-none-any.whl

mcp_agent/llm/providers/augmented_llm_google_native.py

@@ -160,6 +160,7 @@ class GoogleNativeAugmentedLLM(AugmentedLLM[types.Content, types.Content]):
         AugmentedLLM.PARAM_USE_HISTORY,  # Handled by AugmentedLLM base / this class's logic
         AugmentedLLM.PARAM_MAX_ITERATIONS,  # Handled by this class's loop
         # Add any other OpenAI-specific params not applicable to google.genai
+        AugmentedLLM.PARAM_MCP_METADATA,
     }.union(AugmentedLLM.BASE_EXCLUDE_FIELDS)
 
     def __init__(self, *args, **kwargs) -> None:

mcp_agent/llm/providers/augmented_llm_openai.py

@@ -59,6 +59,7 @@ class OpenAIAugmentedLLM(AugmentedLLM[ChatCompletionMessageParam, ChatCompletion
         AugmentedLLM.PARAM_USE_HISTORY,
         AugmentedLLM.PARAM_MAX_ITERATIONS,
         AugmentedLLM.PARAM_TEMPLATE_VARS,
+        AugmentedLLM.PARAM_MCP_METADATA,
     }
 
     def __init__(self, provider: Provider = Provider.OPENAI, *args, **kwargs) -> None:

mcp_agent/llm/providers/bedrock_utils.py

@@ -0,0 +1,216 @@
+from __future__ import annotations
+
+from typing import Collection, Dict, List, Literal, Optional, Set, TypedDict, cast
+
+# Lightweight, runtime-only loader for AWS Bedrock models.
+# - Fetches once per process via boto3 (region from session; env override supported)
+# - Memory cache only; no disk persistence
+# - Provides filtering and optional prefixing (default 'bedrock.') for model IDs
+
+try:
+    import boto3
+except Exception:  # pragma: no cover - import error path
+    boto3 = None  # type: ignore[assignment]
+
+
+Modality = Literal["TEXT", "IMAGE", "VIDEO", "SPEECH", "EMBEDDING"]
+Lifecycle = Literal["ACTIVE", "LEGACY"]
+InferenceType = Literal["ON_DEMAND", "PROVISIONED", "INFERENCE_PROFILE"]
+
+
+class ModelSummary(TypedDict, total=False):
+    modelId: str
+    modelName: str
+    providerName: str
+    inputModalities: List[Modality]
+    outputModalities: List[Modality]
+    responseStreamingSupported: bool
+    customizationsSupported: List[str]
+    inferenceTypesSupported: List[InferenceType]
+    modelLifecycle: Dict[str, Lifecycle]
+
+
+_MODELS_CACHE_BY_REGION: Dict[str, Dict[str, ModelSummary]] = {}
+
+
+def _resolve_region(region: Optional[str]) -> str:
+    if region:
+        return region
+    import os
+
+    env_region = os.getenv("BEDROCK_REGION")
+    if env_region:
+        return env_region
+    if boto3 is None:
+        raise RuntimeError(
+            "boto3 is required to load Bedrock models. Install boto3 or provide a static list."
+        )
+    session = boto3.Session()
+    if not session.region_name:
+        raise RuntimeError(
+            "AWS region could not be resolved. Configure your AWS SSO/profile or set BEDROCK_REGION."
+        )
+    return session.region_name
+
+
+def _strip_prefix(model_id: str, prefix: str) -> str:
+    return model_id[len(prefix) :] if prefix and model_id.startswith(prefix) else model_id
+
+
+def _ensure_loaded(region: Optional[str] = None) -> Dict[str, ModelSummary]:
+    resolved_region = _resolve_region(region)
+    cache = _MODELS_CACHE_BY_REGION.get(resolved_region)
+    if cache is not None:
+        return cache
+
+    if boto3 is None:
+        raise RuntimeError("boto3 is required to load Bedrock models. Install boto3.")
+
+    try:
+        client = boto3.client("bedrock", region_name=resolved_region)
+        resp = client.list_foundation_models()
+        summaries: List[ModelSummary] = resp.get("modelSummaries", [])  # type: ignore[assignment]
+    except Exception as exc:  # keep error simple and actionable
+        raise RuntimeError(
+            f"Failed to list Bedrock foundation models in region '{resolved_region}'. "
+            f"Ensure AWS credentials (SSO) and permissions (bedrock:ListFoundationModels) are configured. "
+            f"Original error: {exc}"
+        )
+
+    cache = {s.get("modelId", ""): s for s in summaries if s.get("modelId")}
+    _MODELS_CACHE_BY_REGION[resolved_region] = cache
+    return cache
+
+
+def refresh_bedrock_models(region: Optional[str] = None) -> None:
+    resolved_region = _resolve_region(region)
+    # drop and reload on next access
+    _MODELS_CACHE_BY_REGION.pop(resolved_region, None)
+    _ensure_loaded(resolved_region)
+
+
+def _matches_modalities(model_modalities: List[Modality], requested: Collection[Modality]) -> bool:
+    # include if all requested are present in the model's modalities
+    return set(requested).issubset(set(model_modalities))
+
+
+def all_model_summaries(
+    input_modalities: Optional[Collection[Modality]] = None,
+    output_modalities: Optional[Collection[Modality]] = None,
+    include_legacy: bool = False,
+    providers: Optional[Collection[str]] = None,
+    inference_types: Optional[Collection[InferenceType]] = None,
+    direct_invocation_only: bool = True,
+    region: Optional[str] = None,
+) -> List[ModelSummary]:
+    """Return filtered Bedrock model summaries.
+
+    Defaults: input_modalities={"TEXT"}, output_modalities={"TEXT"}, include_legacy=False,
+    inference_types={"ON_DEMAND"}, direct_invocation_only=True.
+    """
+
+    cache = _ensure_loaded(region)
+    results: List[ModelSummary] = []
+
+    effective_output: Set[Modality] = (
+        set(output_modalities) if output_modalities is not None else {cast("Modality", "TEXT")}
+    )
+    effective_input: Optional[Set[Modality]] = (
+        set(input_modalities) if input_modalities is not None else {cast("Modality", "TEXT")}
+    )
+    provider_filter: Optional[Set[str]] = set(providers) if providers is not None else None
+    effective_inference: Set[InferenceType] = (
+        set(inference_types) if inference_types is not None else {cast("InferenceType", "ON_DEMAND")}
+    )
+
+    for summary in cache.values():
+        lifecycle = (summary.get("modelLifecycle") or {}).get("status")
+        if not include_legacy and lifecycle == "LEGACY":
+            continue
+
+        if provider_filter is not None and summary.get("providerName") not in provider_filter:
+            continue
+
+        # direct invocation only: exclude profile variants like :0:24k or :mm
+        if direct_invocation_only:
+            mid = summary.get("modelId") or ""
+            if mid.count(":") > 1:
+                continue
+
+        # modalities
+        model_inputs: List[Modality] = summary.get("inputModalities", [])  # type: ignore[assignment]
+        model_outputs: List[Modality] = summary.get("outputModalities", [])  # type: ignore[assignment]
+
+        if effective_input is not None and not _matches_modalities(model_inputs, effective_input):
+            continue
+        if effective_output and not _matches_modalities(model_outputs, effective_output):
+            continue
+
+        # inference types
+        model_inference: List[InferenceType] = summary.get("inferenceTypesSupported", [])  # type: ignore[assignment]
+        if effective_inference and not set(effective_inference).issubset(set(model_inference)):
+            continue
+
+        results.append(summary)
+
+    return results
+
+
+def all_bedrock_models(
+    input_modalities: Optional[Collection[Modality]] = None,
+    output_modalities: Optional[Collection[Modality]] = None,
+    include_legacy: bool = False,
+    providers: Optional[Collection[str]] = None,
+    prefix: str = "bedrock.",
+    inference_types: Optional[Collection[InferenceType]] = None,
+    direct_invocation_only: bool = True,
+    region: Optional[str] = None,
+) -> List[str]:
+    """Return model IDs (optionally prefixed) filtered by the given criteria.
+
+    Defaults: output_modalities={"TEXT"}, exclude LEGACY,
+    inference_types={"ON_DEMAND"}, direct_invocation_only=True.
+    """
+
+    summaries = all_model_summaries(
+        input_modalities=input_modalities,
+        output_modalities=output_modalities,
+        include_legacy=include_legacy,
+        providers=providers,
+        inference_types=inference_types,
+        direct_invocation_only=direct_invocation_only,
+        region=region,
+    )
+    ids: List[str] = []
+    for s in summaries:
+        mid = s.get("modelId")
+        if mid:
+            ids.append(mid)
+    if prefix:
+        return [f"{prefix}{mid}" for mid in ids]
+    return ids
+
+
+def get_model_metadata(model_id: str, region: Optional[str] = None) -> Optional[ModelSummary]:
+    cache = _ensure_loaded(region)
+    # Accept either prefixed or plain model IDs
+    plain_id = _strip_prefix(model_id, "bedrock.")
+    return cache.get(plain_id)
+
+
+def list_providers(region: Optional[str] = None) -> List[str]:
+    cache = _ensure_loaded(region)
+    providers = {s.get("providerName") for s in cache.values() if s.get("providerName")}
+    return sorted(providers)  # type: ignore[arg-type]
+
+
+__all__ = [
+    "Modality",
+    "Lifecycle",
+    "ModelSummary",
+    "all_bedrock_models",
+    "all_model_summaries",
+    "get_model_metadata",
+    "list_providers",
+    "refresh_bedrock_models",
+]

mcp_agent/mcp/mcp_agent_client_session.py

@@ -14,8 +14,17 @@ from mcp.shared.session import (
     SendRequestT,
 )
 from mcp.types import (
+    CallToolRequest,
+    CallToolRequestParams,
+    CallToolResult,
+    GetPromptRequest,
+    GetPromptRequestParams,
+    GetPromptResult,
     Implementation,
     ListRootsResult,
+    ReadResourceRequest,
+    ReadResourceRequestParams,
+    ReadResourceResult,
     Root,
     ToolListChangedNotification,
 )
@@ -180,8 +189,17 @@ class MCPAgentClientSession(ClientSession, ContextDependent):
             )
             return result
         except Exception as e:
-            logger.error(f"send_request failed: {str(e)}")
-            raise
+            # Handle connection errors cleanly
+            from anyio import ClosedResourceError
+            
+            if isinstance(e, ClosedResourceError):
+                # Show clean offline message and convert to ConnectionError
+                from mcp_agent import console
+                console.console.print(f"[dim red]MCP server {self.session_server_name} offline[/dim red]")
+                raise ConnectionError(f"MCP server {self.session_server_name} offline") from e
+            else:
+                logger.error(f"send_request failed: {str(e)}")
+                raise
 
     async def _received_notification(self, notification: ServerNotification) -> None:
         """
@@ -226,3 +244,88 @@ class MCPAgentClientSession(ClientSession, ContextDependent):
             await self._tool_list_changed_callback(server_name)
         except Exception as e:
             logger.error(f"Error in tool list changed callback: {e}")
+
+    async def call_tool(
+        self, 
+        name: str, 
+        arguments: dict | None = None, 
+        _meta: dict | None = None,
+        **kwargs
+    ) -> CallToolResult:
+        """Call a tool with optional metadata support."""
+        if _meta:
+            from mcp.types import RequestParams
+            
+            # Safe merge - preserve existing meta fields like progressToken
+            existing_meta = kwargs.get('meta')
+            if existing_meta:
+                meta_dict = existing_meta.model_dump() if hasattr(existing_meta, 'model_dump') else {}
+                meta_dict.update(_meta)
+                meta_obj = RequestParams.Meta(**meta_dict)
+            else:
+                meta_obj = RequestParams.Meta(**_meta)
+                
+            # Create CallToolRequestParams without meta, then add _meta via model_dump
+            params = CallToolRequestParams(name=name, arguments=arguments)
+            params_dict = params.model_dump(by_alias=True)
+            params_dict["_meta"] = meta_obj.model_dump()
+            
+            # Create request with proper types
+            request = CallToolRequest(
+                method="tools/call",
+                params=CallToolRequestParams.model_validate(params_dict)
+            )
+            
+            return await self.send_request(request, CallToolResult)
+        else:
+            return await super().call_tool(name, arguments, **kwargs)
+
+    async def read_resource(self, uri: str, _meta: dict | None = None, **kwargs) -> ReadResourceResult:
+        """Read a resource with optional metadata support."""
+        if _meta:
+            from mcp.types import RequestParams
+            
+            # Safe merge - preserve existing meta fields like progressToken
+            existing_meta = kwargs.get('meta')
+            if existing_meta:
+                meta_dict = existing_meta.model_dump() if hasattr(existing_meta, 'model_dump') else {}
+                meta_dict.update(_meta)
+                meta_obj = RequestParams.Meta(**meta_dict)
+            else:
+                meta_obj = RequestParams.Meta(**_meta)
+                
+            request = ReadResourceRequest(
+                method="resources/read",
+                params=ReadResourceRequestParams(uri=uri, meta=meta_obj)
+            )
+            return await self.send_request(request, ReadResourceResult)
+        else:
+            return await super().read_resource(uri, **kwargs)
+
+    async def get_prompt(
+        self, 
+        name: str, 
+        arguments: dict | None = None, 
+        _meta: dict | None = None,
+        **kwargs
+    ) -> GetPromptResult:
+        """Get a prompt with optional metadata support."""
+        if _meta:
+            from mcp.types import RequestParams
+            
+            # Safe merge - preserve existing meta fields like progressToken
+            existing_meta = kwargs.get('meta')
+            if existing_meta:
+                meta_dict = existing_meta.model_dump() if hasattr(existing_meta, 'model_dump') else {}
+                meta_dict.update(_meta)
+                meta_obj = RequestParams.Meta(**meta_dict)
+            else:
+                meta_obj = RequestParams.Meta(**_meta)
+                
+            request = GetPromptRequest(
+                method="prompts/get",
+                params=GetPromptRequestParams(name=name, arguments=arguments, meta=meta_obj)
+            )
+            return await self.send_request(request, GetPromptResult)
+        else:
+            return await super().get_prompt(name, arguments, **kwargs)

mcp_agent/mcp/mcp_aggregator.py

@@ -139,7 +139,10 @@ class MCPAggregator(ContextDependent):
 
     def _create_progress_callback(self, server_name: str, tool_name: str) -> "ProgressFnT":
         """Create a progress callback function for tool execution."""
-        async def progress_callback(progress: float, total: float | None, message: str | None) -> None:
+
+        async def progress_callback(
+            progress: float, total: float | None, message: str | None
+        ) -> None:
             """Handle progress notifications from MCP tool execution."""
             logger.info(
                 "Tool progress update",
@@ -153,6 +156,7 @@ class MCPAggregator(ContextDependent):
                     "details": message or "",  # Put the message in details column
                 },
             )
+
         return progress_callback
 
     async def close(self) -> None:
@@ -508,12 +512,28 @@ class MCPAggregator(ContextDependent):
         async def try_execute(client: ClientSession):
             try:
                 method = getattr(client, method_name)
+
+                # Get metadata from context for tool, resource, and prompt calls
+                metadata = None
+                if method_name in ["call_tool", "read_resource", "get_prompt"]:
+                    from mcp_agent.llm.augmented_llm import _mcp_metadata_var
+
+                    metadata = _mcp_metadata_var.get()
+
+                # Prepare kwargs
+                kwargs = method_args or {}
+                if metadata:
+                    kwargs["_meta"] = metadata
+
                 # For call_tool method, check if we need to add progress_callback
                 if method_name == "call_tool" and progress_callback:
                     # The call_tool method signature includes progress_callback parameter
-                    return await method(**method_args, progress_callback=progress_callback)
+                    return await method(progress_callback=progress_callback, **kwargs)
                 else:
-                    return await method(**method_args)
+                    return await method(**(kwargs or {}))
+            except ConnectionError:
+                # Let ConnectionError pass through for reconnection logic
+                raise
             except Exception as e:
                 error_msg = (
                     f"Failed to {method_name} '{operation_name}' on server '{server_name}': {e}"
@@ -525,34 +545,77 @@ class MCPAggregator(ContextDependent):
                     # Re-raise the original exception to propagate it
                     raise e
 
-        if self.connection_persistence:
-            server_connection = await self._persistent_connection_manager.get_server(
-                server_name, client_session_factory=MCPAgentClientSession
-            )
-            return await try_execute(server_connection.session)
-        else:
-            logger.debug(
-                f"Creating temporary connection to server: {server_name}",
-                data={
-                    "progress_action": ProgressAction.STARTING,
-                    "server_name": server_name,
-                    "agent_name": self.agent_name,
-                },
-            )
-            async with gen_client(
-                server_name, server_registry=self.context.server_registry
-            ) as client:
-                result = await try_execute(client)
+        # Try initial execution
+        try:
+            if self.connection_persistence:
+                server_connection = await self._persistent_connection_manager.get_server(
+                    server_name, client_session_factory=MCPAgentClientSession
+                )
+                return await try_execute(server_connection.session)
+            else:
                 logger.debug(
-                    f"Closing temporary connection to server: {server_name}",
+                    f"Creating temporary connection to server: {server_name}",
                     data={
-                        "progress_action": ProgressAction.SHUTDOWN,
+                        "progress_action": ProgressAction.STARTING,
                         "server_name": server_name,
                         "agent_name": self.agent_name,
                     },
                 )
+                async with gen_client(
+                    server_name, server_registry=self.context.server_registry
+                ) as client:
+                    result = await try_execute(client)
+                    logger.debug(
+                        f"Closing temporary connection to server: {server_name}",
+                        data={
+                            "progress_action": ProgressAction.SHUTDOWN,
+                            "server_name": server_name,
+                            "agent_name": self.agent_name,
+                        },
+                    )
+                    return result
+        except ConnectionError:
+            # Server offline - attempt reconnection
+            from mcp_agent import console
+
+            console.console.print(
+                f"[dim yellow]MCP server {server_name} reconnecting...[/dim yellow]"
+            )
+
+            try:
+                if self.connection_persistence:
+                    # Force disconnect and create fresh connection
+                    await self._persistent_connection_manager.disconnect_server(server_name)
+                    import asyncio
+
+                    await asyncio.sleep(0.1)
+
+                    server_connection = await self._persistent_connection_manager.get_server(
+                        server_name, client_session_factory=MCPAgentClientSession
+                    )
+                    result = await try_execute(server_connection.session)
+                else:
+                    # For non-persistent connections, just try again
+                    async with gen_client(
+                        server_name, server_registry=self.context.server_registry
+                    ) as client:
+                        result = await try_execute(client)
+
+                # Success!
+                console.console.print(f"[dim green]MCP server {server_name} online[/dim green]")
                 return result
 
+            except Exception:
+                # Reconnection failed
+                console.console.print(
+                    f"[dim red]MCP server {server_name} offline - failed to reconnect[/dim red]"
+                )
+                error_msg = f"MCP server {server_name} offline - failed to reconnect"
+                if error_factory:
+                    return error_factory(error_msg)
+                else:
+                    raise Exception(error_msg)
+
     async def _parse_resource_name(self, name: str, resource_type: str) -> tuple[str, str]:
         """
         Parse a possibly namespaced resource name into server name and local resource name.
@@ -575,7 +638,7 @@ class MCPAggregator(ContextDependent):
             # Try to match against known server names, handling server names with hyphens
             for server_name in self.server_names:
                 if name.startswith(f"{server_name}{SEP}"):
-                    local_name = name[len(server_name) + len(SEP):]
+                    local_name = name[len(server_name) + len(SEP) :]
                     return server_name, local_name
 
             # If no server name matched, it might be a tool with a hyphen in its name
@@ -622,10 +685,10 @@ class MCPAggregator(ContextDependent):
         with tracer.start_as_current_span(f"MCP Tool: {server_name}/{local_tool_name}"):
             trace.get_current_span().set_attribute("tool_name", local_tool_name)
             trace.get_current_span().set_attribute("server_name", server_name)
-            
+
             # Create progress callback for this tool execution
             progress_callback = self._create_progress_callback(server_name, local_tool_name)
-            
+
             return await self._execute_on_server(
                 server_name=server_name,
                 operation_type="tool",
@@ -1235,11 +1298,11 @@ class MCPAggregator(ContextDependent):
     async def list_mcp_tools(self, server_name: str | None = None) -> Dict[str, List[Tool]]:
         """
         List available tools from one or all servers, grouped by server name.
-        
+
         Args:
             server_name: Optional server name to list tools from. If not provided,
                         lists tools from all servers.
-        
+
         Returns:
             Dictionary mapping server names to lists of Tool objects (with original names, not namespaced)
         """
@@ -1248,7 +1311,7 @@ class MCPAggregator(ContextDependent):
 
         results: Dict[str, List[Tool]] = {}
 
-        # Get the list of servers to check  
+        # Get the list of servers to check
         servers_to_check = [server_name] if server_name else self.server_names
 
         # For each server, try to list its tools

mcp_agent/mcp/mcp_connection_manager.py

@@ -272,6 +272,7 @@ class MCPConnectionManager(ContextDependent):
         # Manage our own task group - independent of task context
         self._task_group = None
         self._task_group_active = False
+        self._mcp_sse_filter_added = False
 
     async def __aenter__(self):
         # Create a task group that isn't tied to a specific task
@@ -300,6 +301,21 @@ class MCPConnectionManager(ContextDependent):
         except Exception as e:
             logger.error(f"Error during connection manager shutdown: {e}")
 
+    def _suppress_mcp_sse_errors(self) -> None:
+        """Suppress MCP library's 'Error in sse_reader' messages."""
+        if self._mcp_sse_filter_added:
+            return
+            
+        import logging
+        
+        class MCPSSEErrorFilter(logging.Filter):
+            def filter(self, record):
+                return not (record.name == "mcp.client.sse" and "Error in sse_reader" in record.getMessage())
+        
+        mcp_sse_logger = logging.getLogger("mcp.client.sse")
+        mcp_sse_logger.addFilter(MCPSSEErrorFilter())
+        self._mcp_sse_filter_added = True
+
     async def launch_server(
         self,
         server_name: str,
@@ -341,6 +357,9 @@ class MCPConnectionManager(ContextDependent):
                 logger.debug(f"{server_name}: Creating stdio client with custom error handler")
                 return _add_none_to_context(stdio_client(server_params, errlog=error_handler))
             elif config.transport == "sse":
+                # Suppress MCP library error spam
+                self._suppress_mcp_sse_errors()
+                
                 return _add_none_to_context(
                     sse_client(
                         config.url,

mcp_agent/resources/examples/mcp/elicitations/elicitation_forms_server.py

@@ -100,11 +100,25 @@ async def product_review() -> ReadResourceResult:
             },
         )
         review_text: str = Field(
-            description="Tell us about your experience", min_length=10, max_length=1000
+            description="Tell us about your experience",
+            default="""Great product!
+Here's what I loved:
+
+- Excellent build quality
+- Fast shipping
+- Works as advertised
+
+One minor issue:
+- Instructions could be clearer
+
+Overall, highly recommended!""",
+            min_length=10,
+            max_length=1000
         )
 
     result = await mcp.get_context().elicit(
-        "Share your product review - Help others make informed decisions!", schema=ProductReview
+        "Share your product review - Help others make informed decisions!",
+        schema=ProductReview,
     )
 
     match result:
@@ -140,6 +154,7 @@ async def account_settings() -> ReadResourceResult:
         email_notifications: bool = Field(True, description="Receive email notifications?")
         marketing_emails: bool = Field(False, description="Subscribe to marketing emails?")
         theme: str = Field(
+            "dark",
             description="Choose your preferred theme",
             json_schema_extra={
                 "enum": ["light", "dark", "auto"],
@@ -147,7 +162,9 @@ async def account_settings() -> ReadResourceResult:
             },
         )
         privacy_public: bool = Field(False, description="Make your profile public?")
-        items_per_page: int = Field(description="Items to show per page (10-100)", ge=10, le=100)
+        items_per_page: int = Field(
+            25, description="Items to show per page (10-100)", ge=10, le=100
+        )
 
     result = await mcp.get_context().elicit("Update your account settings", schema=AccountSettings)
 
@@ -182,7 +199,11 @@ async def service_appointment() -> ReadResourceResult:
 
     class ServiceAppointment(BaseModel):
         customer_name: str = Field(description="Your full name", min_length=2, max_length=50)
+        phone_number: str = Field(
+            "555-", description="Contact phone number", min_length=10, max_length=20
+        )
         vehicle_type: str = Field(
+            default="sedan",
             description="What type of vehicle do you have?",
             json_schema_extra={
                 "enum": ["sedan", "suv", "truck", "motorcycle", "other"],
@@ -205,6 +226,7 @@ async def service_appointment() -> ReadResourceResult:
             lines = [
                 "🔧 Service Appointment Scheduled!",
                 f"👤 Customer: {data.customer_name}",
+                f"📞 Phone: {data.phone_number}",
                 f"🚗 Vehicle: {data.vehicle_type.title()}",
                 f"🚙 Loaner needed: {'Yes' if data.needs_loaner else 'No'}",
                 f"📅 Appointment: {data.appointment_time}",