Function _process_request_refactored

api_utils/request_processor.py:727–975

Core Request Processing Function - Refactored Version

(
    req_id: str,
    request: ChatCompletionRequest,
    http_request: Request,
    result_future: Future,
)

async def _process_request_refactored(
    req_id: str,
    request: ChatCompletionRequest,
    http_request: Request,
    result_future: Future,
) -> Optional[Tuple[Event, Locator, Callable[[str], bool]]]:
    """Core Request Processing Function - Refactored Version"""
    from api_utils.server_state import state

    logger = state.logger

    # 0. Check Auth Rotation Lock
    if not GlobalState.AUTH_ROTATION_LOCK.is_set():
        logger.info(f"[{req_id}] Request held: Waiting for auth rotation...")
        await GlobalState.AUTH_ROTATION_LOCK.wait()
        logger.info(f"[{req_id}] ▶️ Resuming after Auth Rotation.")

    # [GR-03] Pre-Flight Graceful Rotation Check
    if GlobalState.NEEDS_ROTATION:
        logger.info(f"[{req_id}] 🔄 Graceful Rotation Pending. Initiating rotation...")
        from api_utils.server_state import state

        current_model_id = state.current_ai_studio_model_id
        from browser_utils.auth_rotation import perform_auth_rotation

        if await perform_auth_rotation(target_model_id=current_model_id):
            GlobalState.NEEDS_ROTATION = False
            logger.info(f"[{req_id}] ✅ Pre-flight rotation complete.")

    is_connected = await _test_client_connection(req_id, http_request)
    if not is_connected:
        logger.info(f"[{req_id}] Client disconnected before processing.")
        if not result_future.done():
            result_future.set_exception(
                HTTPException(status_code=499, detail="Client disconnected")
            )
        return None

    stream_port = get_environment_variable("STREAM_PORT")
    use_stream = stream_port != "0"
    if use_stream:
        try:
            from api_utils import clear_stream_queue

            await clear_stream_queue()
        except asyncio.CancelledError:
            raise
        except Exception as clear_err:
            logger.warning(f"[Stream] Error clearing queue: {clear_err}")

    context = await _initialize_request_context(req_id, request)
    context = await _analyze_model_requirements(req_id, context, request)

    (
        _,
        disconnect_check_task,
        check_client_disconnected,
    ) = await _setup_disconnect_monitoring(req_id, http_request, result_future)