Method stream_response

src/mcp_cli/chat/streaming_handler.py:248–340

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 (

(
        self,
        client,
        messages: list[dict[str, Any]],
        tools: list[dict[str, Any]] | None = None,
        after_tool_calls: bool = False,
        **kwargs,
    )

        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
            if not hasattr(client, "create_completion"):
                logger.warning("Client doesn't support create_completion")
                return await self._handle_non_streaming(
                    client, messages, tools, **kwargs
                )

            # Stream with chunk timeout protection
            await self._stream_with_timeout(
                client, messages, tools, after_tool_calls=after_tool_calls, **kwargs
            )

            # Finalize tool calls
            tool_calls = self.tool_accumulator.finalize()

            # Capture state values BEFORE stop_streaming clears them
            chunks_received = (
                self.display.streaming_state.chunks_received
                if self.display.streaming_state
                else 0
            )
            reasoning_content = (
                self.display.streaming_state.reasoning_content
                if self.display.streaming_state
                else None
            )