fast-agent-mcp 0.3.13__py3-none-any.whl → 0.3.15__py3-none-any.whl

fast_agent/ui/mcp_display.py

@@ -39,6 +39,7 @@ class Colours:
     # Capability token states
     TOKEN_ERROR = "bright_red"
     TOKEN_WARNING = "bright_cyan"
+    TOKEN_CAUTION = "bright_yellow"
     TOKEN_DISABLED = "dim"
     TOKEN_HIGHLIGHTED = "bright_yellow"
     TOKEN_ENABLED = "bright_green"
@@ -104,6 +105,38 @@ def _format_compact_duration(seconds: float | None) -> str | None:
     return f"{days}d{hours:02d}h"
 
 
+def _format_timeline_label(total_seconds: int) -> str:
+    total = max(0, int(total_seconds))
+    if total == 0:
+        return "0s"
+
+    days, remainder = divmod(total, 86400)
+    if days:
+        if remainder == 0:
+            return f"{days}d"
+        hours = remainder // 3600
+        if hours == 0:
+            return f"{days}d"
+        return f"{days}d{hours}h"
+
+    hours, remainder = divmod(total, 3600)
+    if hours:
+        if remainder == 0:
+            return f"{hours}h"
+        minutes = remainder // 60
+        if minutes == 0:
+            return f"{hours}h"
+        return f"{hours}h{minutes:02d}m"
+
+    minutes, seconds = divmod(total, 60)
+    if minutes:
+        if seconds == 0:
+            return f"{minutes}m"
+        return f"{minutes}m{seconds:02d}s"
+
+    return f"{seconds}s"
+
+
 def _summarise_call_counts(call_counts: dict[str, int]) -> str | None:
     if not call_counts:
         return None
@@ -192,7 +225,7 @@ def _format_capability_shorthand(
     elif instructions_enabled is False:
         entries.append(("In", "red", False))
     elif instructions_enabled is None and not template_expected:
-        entries.append(("In", "blue", False))
+        entries.append(("In", "warn", False))
     elif instructions_enabled is None:
         entries.append(("In", True, False))
     elif template_expected:
@@ -200,6 +233,18 @@ def _format_capability_shorthand(
     else:
         entries.append(("In", "blue", False))
 
+    skybridge_config = getattr(status, "skybridge", None)
+    if not skybridge_config:
+        entries.append(("Sk", False, False))
+    else:
+        has_warnings = bool(getattr(skybridge_config, "warnings", None))
+        if has_warnings:
+            entries.append(("Sk", "warn", False))
+        elif getattr(skybridge_config, "enabled", False):
+            entries.append(("Sk", True, False))
+        else:
+            entries.append(("Sk", False, False))
+
     if status.roots_configured:
         entries.append(("Ro", True, False))
     else:
@@ -228,6 +273,8 @@ def _format_capability_shorthand(
             return Colours.TOKEN_ERROR
         if supported == "blue":
             return Colours.TOKEN_WARNING
+        if supported == "warn":
+            return Colours.TOKEN_CAUTION
         if not supported:
             return Colours.TOKEN_DISABLED
         if highlighted:
@@ -268,10 +315,28 @@ def _format_label(label: str, width: int = 10) -> str:
     return f"{label:<{width}}" if len(label) < width else label
 
 
-def _build_inline_timeline(buckets: Iterable[str]) -> str:
+def _build_inline_timeline(
+    buckets: Iterable[str],
+    *,
+    bucket_seconds: int | None = None,
+    bucket_count: int | None = None,
+) -> str:
     """Build a compact timeline string for inline display."""
-    timeline = "  [dim]10m[/dim] "
-    for state in buckets:
+    bucket_list = list(buckets)
+    count = bucket_count or len(bucket_list)
+    if count <= 0:
+        count = len(bucket_list) or 1
+
+    seconds = bucket_seconds or 30
+    total_window = seconds * count
+    timeline = f"  [dim]{_format_timeline_label(total_window)}[/dim] "
+
+    if len(bucket_list) < count:
+        bucket_list.extend(["none"] * (count - len(bucket_list)))
+    elif len(bucket_list) > count:
+        bucket_list = bucket_list[-count:]
+
+    for state in bucket_list:
         color = TIMELINE_COLORS.get(state, Colours.NONE)
         if state in {"idle", "none"}:
             symbol = SYMBOL_IDLE
@@ -297,6 +362,10 @@ def _render_channel_summary(status: ServerStatus, indent: str, total_width: int)
     if snapshot is None:
         return
 
+    transport_value = getattr(status, "transport", None)
+    transport_lower = (transport_value or "").lower()
+    is_sse_transport = transport_lower == "sse"
+
     # Show channel types based on what's available
     entries: list[tuple[str, str, ChannelSnapshot | None]] = []
 
@@ -311,12 +380,13 @@ def _render_channel_summary(status: ServerStatus, indent: str, total_width: int)
     stdio_channel = getattr(snapshot, "stdio", None)
 
     if any(channel is not None for channel in http_channels):
-        # HTTP transport - show the original three channels
+        # HTTP or SSE transport - show available channels
         entries = [
             ("GET (SSE)", "◀", getattr(snapshot, "get", None)),
             ("POST (SSE)", "▶", getattr(snapshot, "post_sse", None)),
-            ("POST (JSON)", "▶", getattr(snapshot, "post_json", None)),
         ]
+        if not is_sse_transport:
+            entries.append(("POST (JSON)", "▶", getattr(snapshot, "post_json", None)))
     elif stdio_channel is not None:
         # STDIO transport - show single bidirectional channel
         entries = [
@@ -332,36 +402,31 @@ def _render_channel_summary(status: ServerStatus, indent: str, total_width: int)
     # Determine if we're showing stdio or HTTP channels
     is_stdio = stdio_channel is not None
 
+    default_bucket_seconds = getattr(snapshot, "activity_bucket_seconds", None) or 30
+    default_bucket_count = getattr(snapshot, "activity_bucket_count", None) or 20
+    timeline_header_label = _format_timeline_label(default_bucket_seconds * default_bucket_count)
+
+    # Total characters before the metrics section in each row (excluding indent)
+    # Structure: "│ " + arrow + " " + label(13) + timeline_label + " " + buckets + " now"
+    metrics_prefix_width = 22 + len(timeline_header_label) + default_bucket_count
+
     # Get transport type for display
-    transport = getattr(status, "transport", None) or "unknown"
+    transport = transport_value or "unknown"
     transport_display = transport.upper() if transport != "unknown" else "Channels"
 
     # Header with column labels
     header = Text(indent)
-    header.append(f"┌ {transport_display} ", style="dim")
+    header_intro = f"┌ {transport_display} "
+    header.append(header_intro, style="dim")
 
     # Calculate padding needed based on transport display length
-    # Base structure: "┌ " (2) + transport_display + " " (1) + "─" padding to align with columns
-    header_prefix_len = 3 + len(transport_display)
+    header_prefix_len = len(header_intro)
 
+    dash_count = max(1, metrics_prefix_width - header_prefix_len + 2)
     if is_stdio:
-        # Simplified header for stdio: just activity column
-        # Need to align with "│ ⇄ STDIO        10m ●●●●●●●●●●●●●●●●●●●● now        29"
-        # That's: "│ " + arrow + " " + label(13) + "10m " + dots(20) + " now" = 47 chars
-        # Then: "  " + activity(8) = 10 chars
-        # Total content width = 47 + 10 = 57 chars
-        # So we need 47 - header_prefix_len dashes before "activity"
-        dash_count = max(1, 47 - header_prefix_len)
         header.append("─" * dash_count, style="dim")
         header.append("  activity", style="dim")
     else:
-        # Original header for HTTP channels
-        # Need to align with the req/resp/notif/ping columns
-        # Structure: "│ " + arrow + " " + label(13) + "10m " + dots(20) + " now" = 47 chars
-        # Then: "  " + req(5) + " " + resp(5) + " " + notif(5) + " " + ping(5) = 25 chars
-        # Total content width = 47 + 25 = 72 chars
-        # So we need 47 - header_prefix_len dashes before the column headers
-        dash_count = max(1, 47 - header_prefix_len)
         header.append("─" * dash_count, style="dim")
         header.append("  req  resp notif  ping", style="dim")
 
@@ -449,10 +514,24 @@ def _render_channel_summary(status: ServerStatus, indent: str, total_width: int)
         line.append(f" {label:<13}", style=label_style)
 
         # Always show timeline (dim black dots if no data)
-        line.append("10m ", style="dim")
-        if channel and channel.activity_buckets:
+        channel_bucket_seconds = (
+            getattr(channel, "activity_bucket_seconds", None) or default_bucket_seconds
+        )
+        bucket_count = (
+            len(channel.activity_buckets)
+            if channel and channel.activity_buckets
+            else getattr(channel, "activity_bucket_count", None)
+        )
+        if not bucket_count or bucket_count <= 0:
+            bucket_count = default_bucket_count
+        total_window_seconds = channel_bucket_seconds * bucket_count
+        timeline_label = _format_timeline_label(total_window_seconds)
+
+        line.append(f"{timeline_label} ", style="dim")
+        bucket_states = channel.activity_buckets if channel and channel.activity_buckets else None
+        if bucket_states:
             # Show actual activity
-            for bucket_state in channel.activity_buckets:
+            for bucket_state in bucket_states:
                 color = timeline_color_map.get(bucket_state, "dim")
                 if bucket_state in {"idle", "none"}:
                     symbol = SYMBOL_IDLE
@@ -473,7 +552,7 @@ def _render_channel_summary(status: ServerStatus, indent: str, total_width: int)
                 line.append(symbol, style=f"bold {color}")
         else:
             # Show dim dots for no activity
-            for _ in range(20):
+            for _ in range(bucket_count):
                 line.append(SYMBOL_IDLE, style="black dim")
         line.append(" now", style="dim")
 
@@ -588,6 +667,8 @@ def _render_channel_summary(status: ServerStatus, indent: str, total_width: int)
                 symbol = SYMBOL_ERROR
             elif name == "ping":
                 symbol = SYMBOL_PING
+            elif is_stdio and name == "activity":
+                symbol = SYMBOL_STDIO_ACTIVITY
             else:
                 symbol = SYMBOL_RESPONSE
             footer.append(symbol, style=f"{color}")
@@ -712,7 +793,7 @@ async def render_mcp_status(agent, indent: str = "") -> None:
         if instr_available and status.instructions_enabled is False:
             state_segments.append(Text("instructions disabled", style=Colours.TEXT_ERROR))
         elif instr_available and not template_expected:
-            state_segments.append(Text("template missing", style=Colours.TEXT_WARNING))
+            state_segments.append(Text("instr. not in sysprompt", style=Colours.TEXT_WARNING))
 
         if status.spoofing_enabled:
             state_segments.append(Text("client spoof", style=Colours.TEXT_WARNING))

fast_agent/ui/plain_text_truncator.py

@@ -0,0 +1,68 @@
+"""High performance truncation for plain text streaming displays."""
+
+from __future__ import annotations
+
+import math
+
+
+class PlainTextTruncator:
+    """Trim plain text content to fit within a target terminal window."""
+
+    def __init__(self, target_height_ratio: float = 0.7) -> None:
+        if not 0 < target_height_ratio <= 1:
+            raise ValueError("target_height_ratio must be between 0 and 1")
+        self.target_height_ratio = target_height_ratio
+
+    def truncate(self, text: str, *, terminal_height: int, terminal_width: int) -> str:
+        """Return the most recent portion of text that fits the terminal window.
+
+        Args:
+            text: Full text buffer accumulated during streaming.
+            terminal_height: Terminal height in rows.
+            terminal_width: Terminal width in columns.
+
+        Returns:
+            Tail portion of the text that fits within the target height ratio.
+        """
+        if not text:
+            return text
+
+        if terminal_height <= 0 or terminal_width <= 0:
+            return text
+
+        target_rows = max(1, int(terminal_height * self.target_height_ratio))
+        width = max(1, terminal_width)
+
+        idx = len(text)
+        rows_used = 0
+        start_idx = 0
+
+        while idx > 0 and rows_used < target_rows:
+            prev_newline = text.rfind("\n", 0, idx)
+            line_start = prev_newline + 1 if prev_newline != -1 else 0
+            line = text[line_start:idx]
+            expanded = line.expandtabs()
+            line_len = len(expanded)
+            line_rows = max(1, math.ceil(line_len / width)) if line_len else 1
+
+            if rows_used + line_rows >= target_rows:
+                rows_remaining = target_rows - rows_used
+                if rows_remaining <= 0:
+                    start_idx = idx
+                    break
+
+                if line_rows <= rows_remaining:
+                    start_idx = line_start
+                else:
+                    approx_chars = width * rows_remaining
+                    keep_chars = min(len(line), approx_chars)
+                    start_idx = idx - keep_chars
+                break
+
+            rows_used += line_rows
+            start_idx = line_start
+            if prev_newline == -1:
+                break
+            idx = prev_newline
+
+        return text[start_idx:]

fast_agent/ui/rich_progress.py

@@ -78,6 +78,7 @@ class RichProgressDisplay:
             ProgressAction.INITIALIZED: "dim green",
             ProgressAction.CHATTING: "bold blue",
             ProgressAction.STREAMING: "bold green",  # Assistant Colour
+            ProgressAction.THINKING: "bold yellow",  # Assistant Colour
             ProgressAction.ROUTING: "bold blue",
             ProgressAction.PLANNING: "bold blue",
             ProgressAction.READY: "dim green",
@@ -108,7 +109,9 @@ class RichProgressDisplay:
 
         # Ensure no None values in the update
         # For streaming, use custom description immediately to avoid flashing
-        if event.action == ProgressAction.STREAMING and event.streaming_tokens:
+        if (
+            event.action == ProgressAction.STREAMING or event.action == ProgressAction.THINKING
+        ) and event.streaming_tokens:
             # Account for [dim][/dim] tags (11 characters) in padding calculation
             formatted_tokens = f"▎[dim]◀[/dim] {event.streaming_tokens.strip()}".ljust(17 + 11)
             description = f"[{self._get_action_style(event.action)}]{formatted_tokens}"