Class StreamingResponseHandler

src/mcp_cli/chat/streaming_handler.py:222–538

Clean, async-native streaming handler. Uses unified display system - no fallbacks, no dual paths.

class StreamingResponseHandler:
    """Clean, async-native streaming handler.

    Uses unified display system - no fallbacks, no dual paths.
    """

    def __init__(
        self,
        display: StreamingDisplayManager,
        runtime_config: RuntimeConfig | None = None,
        dashboard_bridge: "DashboardBridge | None" = None,
    ):
        """Initialize handler.

        Args:
            display: The unified display manager (required, no fallback)
            runtime_config: Runtime configuration (optional, will load defaults if not provided)
            dashboard_bridge: Optional DashboardBridge for live token streaming to browser.
        """
        self.display = display
        self.tool_accumulator = ToolCallAccumulator()
        self._interrupted = False
        self._usage: dict[str, int] | None = None
        self.runtime_config = runtime_config or load_runtime_config()
        self._dashboard_bridge = dashboard_bridge

    async def stream_response(
        self,
        client,
        messages: list[dict[str, Any]],
        tools: list[dict[str, Any]] | None = None,
        after_tool_calls: bool = False,
        **kwargs,
    ) -> dict[str, Any]:
        """Stream response from LLM client.

        Args:
            client: LLM client with streaming support
            messages: Conversation messages
            tools: Available tools for function calling
            after_tool_calls: True when this is a follow-up after tool execution
                (thinking models need extra time to process tool results)
            **kwargs: Additional arguments for client

        Returns:
            Response dictionary (for backwards compatibility)
        """
        # Reset state
        self._interrupted = False
        self._usage = None
        self.tool_accumulator = ToolCallAccumulator()

        # Start display
        await self.display.start_streaming()
        start_time = time.time()

        try:
            # Check client capabilities