async def _run(self) -> None:
    retryable = True
    request_id = utils.shortuuid()
    max_retries = 3  # Feel free to tweak this based on what works best for you
    retry_count = 0

    try:
        while retry_count < max_retries:
            try:
                # Generate content stream
                stream = await self._client.aio.models.generate_content_stream(
                    model=self._model,
                    contents=cast(types.ContentListUnion, turns),
                    config=config,
                )

                async for response in stream:
                    if response.prompt_feedback:
                        raise APIStatusError(
                            response.prompt_feedback.json(),
                            retryable=False,
                            request_id=request_id,
                        )

                    if (
                        not response.candidates
                        or not response.candidates[0].content
                        or not response.candidates[0].content.parts
                    ):
                        logger.warning(f"no candidates in the response: {response}")
                        # Let’s pause a bit before retrying
                        await asyncio.sleep(1)
                        retry_count += 1
                        continue

                    # When we get valid responses
                    if len(response.candidates) > 1:
                        logger.warning("Multiple candidates, using the first one.")
                    
                    for part in response.candidates[0].content.parts:
                        chat_chunk = self._parse_part(request_id, part)
                        if chat_chunk is not None:
                            retryable = False
                            self._event_ch.send_nowait(chat_chunk)
                    
                    break  # Success! Exit the retry loop

            except APIStatusError as e:
                if not e.retryable:
                    raise
                retry_count += 1
                if retry_count >= max_retries:
                    raise
                await asyncio.sleep(1)

        # If usage metadata is available, process it here
        if response.usage_metadata is not None:
            usage = response.usage_metadata
            self._event_ch.send_nowait(
                llm.ChatChunk(
                    id=request_id,
                    usage=llm.CompletionUsage(
                        completion_tokens=usage.candidates_token_count or 0,
                        prompt_tokens=usage.prompt_token_count or 0,
                        prompt_cached_tokens=usage.cached_content_token_count or 0,
                        total_tokens=usage.total_token_count or 0,
                    ),
                )
            )

    except ClientError as e:
        # Handling client errors gracefully
        raise APIStatusError(
            "gemini llm: client error",
            status_code=e.code,
            body=f"{e.message} {e.status}",
            retryable=False if e.code != 429 else True,
        ) from e
    except ServerError as e:
        # Handling server errors
        raise APIStatusError(
            "gemini llm: server error",
            status_code=e.code,
            body=f"{e.message} {e.status}",
        ) from e

max_retries

asyncio.sleep(1)

max_retries