Function gen_sse_from_playwright

api_utils/response_generators.py:500–613

Playwright response -> OpenAI compatible SSE generator.

(
    page: AsyncPage,
    logger: logging.Logger,
    req_id: str,
    model_name_for_stream: str,
    request: ChatCompletionRequest,
    check_client_disconnected: Callable[[str], bool],
    completion_event: Event,
    prompt_length: int,
    timeout: float,
)

async def gen_sse_from_playwright(
    page: AsyncPage,
    logger: logging.Logger,
    req_id: str,
    model_name_for_stream: str,
    request: ChatCompletionRequest,
    check_client_disconnected: Callable[[str], bool],
    completion_event: Event,
    prompt_length: int,
    timeout: float,
) -> AsyncGenerator[str, None]:
    """Playwright response -> OpenAI compatible SSE generator."""
    from browser_utils.page_controller import PageController
    from models import ClientDisconnectedError

    set_request_id(req_id)
    data_receiving = False
    try:
        page_controller = PageController(page, logger, req_id)
        # Use get_response_with_function_calls which handles both content and functions
        response_data = await page_controller.get_response_with_function_calls(
            check_client_disconnected, prompt_length=prompt_length, timeout=timeout
        )
        final_content = response_data.get("content", "")
        function_calls = response_data.get("function_calls", [])

        data_receiving = True
        lines = final_content.split("\n")
        for line_idx, line in enumerate(lines):
            try:
                check_client_disconnected(
                    f"Playwright stream generator loop ({req_id}): "
                )
            except ClientDisconnectedError:
                if data_receiving and not completion_event.is_set():
                    completion_event.set()
                break
            if line:
                chunk_size = 5
                for i in range(0, len(line), chunk_size):
                    yield generate_sse_chunk(
                        line[i : i + chunk_size], req_id, model_name_for_stream
                    )
                    await asyncio.sleep(0.03)
            if line_idx < len(lines) - 1:
                yield generate_sse_chunk("\n", req_id, model_name_for_stream)
                await asyncio.sleep(0.01)

        usage_stats = calculate_usage_stats(
            [msg.model_dump() for msg in request.messages], final_content, ""
        )
        total_tokens = usage_stats.get("total_tokens", 0)
        GlobalState.increment_token_count(total_tokens)
        from api_utils.server_state import state

        if (
            hasattr(state, "current_auth_profile_path")
            and state.current_auth_profile_path