Method stream_chunks

src/mcp_cli/chat/streaming_handler.py:388–455

Inner streaming function.

()

        )

        async def stream_chunks():
            """Inner streaming function."""
            stream = client.create_completion(
                messages=messages,
                tools=tools,
                stream=True,
                **kwargs,
            )

            stream_iter = stream.__aiter__()
            first_chunk_received = False

            while True:
                try:
                    # Use longer timeout for first chunk
                    effective_timeout = (
                        chunk_timeout if first_chunk_received else first_chunk_timeout
                    )

                    # Wait for next chunk with timeout
                    chunk = await asyncio.wait_for(
                        stream_iter.__anext__(),
                        timeout=effective_timeout,
                    )
                    first_chunk_received = True

                    # Check for interrupt
                    if self._interrupted:
                        logger.debug("Stream interrupted by user")
                        try:
                            await stream_iter.aclose()
                        except Exception as e:
                            logger.debug(f"Error closing stream: {e}")
                        break

                    # Process chunk
                    await self._process_chunk(chunk)

                    # Small yield for smooth UI
                    await asyncio.sleep(0.0005)

                except StopAsyncIteration:
                    logger.debug("Stream completed normally")
                    break
                except asyncio.TimeoutError:
                    effective_timeout = (
                        chunk_timeout if first_chunk_received else first_chunk_timeout
                    )
                    logger.warning(
                        f"Chunk timeout after {effective_timeout}s "
                        f"(first_chunk={not first_chunk_received}, "
                        f"after_tools={after_tool_calls})"
                    )
                    if not first_chunk_received and after_tool_calls:
                        logger.warning(
                            "Streaming timeout after %.0fs waiting for first response after tool calls. "
                            "Increase with MCP_STREAMING_FIRST_CHUNK_TIMEOUT=%.0f",
                            effective_timeout,