Issue: Display metadata after streaming a response with FastAPI

### Issue you'd like to raise.

I have sucessfully set up streaming in HTTP call with FastApi and OpenAI + ConversationalRetrievalChain

If I don't use streaming and just return the whole response, like I was doing previously, I also get metadata displayed with the answer.
If I enable streaming, i get displayed only the answer and the '%' at the end of response.

Like: ......dummytext.%

Code, which is responsible for streaming:

```
from langchain.callbacks.streaming_stdout import StreamingStdOutCallbackHandler
import queue

class ThreadedGenerator:
    def __init__(self):
        self.queue = queue.Queue()

    def __iter__(self):
        return self

    def __next__(self):
        item = self.queue.get()
        if item is StopIteration: raise item
        return item

    def send(self, data):
        self.queue.put(data)

    def close(self):
        self.queue.put(StopIteration)

class ChainStreamHandler(StreamingStdOutCallbackHandler):
    def __init__(self, gen):
        super().__init__()
        self.gen = gen

    def on_llm_new_token(self, token: str, **kwargs):
        self.gen.send(token)

    def on_llm_new_token(self, token: str, **kwargs):
        self.gen.send(token)
```

Ask question function:

```
def askQuestion(self, generator, collection_id, question):
        try:
            collection_name = "collection-" + str(collection_id)
            self.llm = ChatOpenAI(model_name=self.model_name, temperature=self.temperature, openai_api_key=settings.OPENAI_API_KEY, streaming=True, verbose=VERBOSE, callback_manager=CallbackManager([ChainStreamHandler(generator)]))
            self.memory = ConversationBufferMemory(memory_key="chat_history", return_messages=True,  output_key='answer')
            
            self.chain = ConversationalRetrievalChain.from_llm(self.llm, chroma_Vectorstore.as_retriever(similarity_search_with_score=True),
                                                                return_source_documents=True,verbose=VERBOSE, 
                                                                memory=self.memory)
            
            result = self.chain({"question": question})

            res_dict = {
                "answer": result["answer"],
            }

            res_dict["source_documents"] = []

            for source in result["source_documents"]:
                res_dict["source_documents"].append({
                    "page_content": source.page_content,
                    "metadata":  source.metadata
                })

            return res_dict

        finally:
            generator.close()
```

And the API route itself
```
def stream(question, collection_id):
    generator = ThreadedGenerator()
    threading.Thread(target=thread_handler.askQuestion, args=(generator, collection_id, question)).start()
    return generator

@router.post("/collection/{collection_id}/ask_question")
async def ask_question(collection_id: str, request: Request):
    form_data = await request.form()
    question = form_data["question"]
    return StreamingResponse(stream(question, collection_id), media_type='text/event-stream')
```

In askQuestion function I am creating the res_dict object, which has answer and also source from metadata stored.

How can I also display the source after the answer is stopped being streamable? (I have source already in metadata)


Is for this a better way to make separate API call, or are there some other practices or,..?

Thanks for everyone for advice!