livekit-plugins-google 0.11.1__py3-none-any.whl → 1.0.0.dev4__py3-none-any.whl

livekit/plugins/google/llm.py

@@ -15,45 +15,43 @@
 
 from __future__ import annotations
 
-import asyncio
 import json
 import os
 from dataclasses import dataclass
-from typing import Any, Literal, MutableSet, Union, cast
-
-from livekit.agents import (
-    APIConnectionError,
-    APIStatusError,
-    llm,
-    utils,
-)
-from livekit.agents.llm import LLMCapabilities, ToolChoice, _create_ai_function_info
-from livekit.agents.types import DEFAULT_API_CONNECT_OPTIONS, APIConnectOptions
+from typing import Any, Literal, cast
 
 from google import genai
 from google.auth._default_async import default_async
 from google.genai import types
 from google.genai.errors import APIError, ClientError, ServerError
+from livekit.agents import APIConnectionError, APIStatusError, llm, utils
+from livekit.agents.llm import FunctionTool, ToolChoice
+from livekit.agents.types import (
+    DEFAULT_API_CONNECT_OPTIONS,
+    NOT_GIVEN,
+    APIConnectOptions,
+    NotGivenOr,
+)
+from livekit.agents.utils import is_given
 
-from ._utils import _build_gemini_ctx, _build_tools
 from .log import logger
 from .models import ChatModels
+from .utils import to_chat_ctx, to_fnc_ctx
 
 
 @dataclass
-class LLMOptions:
+class _LLMOptions:
     model: ChatModels | str
-    temperature: float | None
-    tool_choice: Union[ToolChoice, Literal["auto", "required", "none"]] = "auto"
-    vertexai: bool = False
-    project: str | None = None
-    location: str | None = None
-    candidate_count: int = 1
-    max_output_tokens: int | None = None
-    top_p: float | None = None
-    top_k: float | None = None
-    presence_penalty: float | None = None
-    frequency_penalty: float | None = None
+    temperature: NotGivenOr[float]
+    tool_choice: NotGivenOr[ToolChoice | Literal["auto", "required", "none"]]
+    vertexai: NotGivenOr[bool]
+    project: NotGivenOr[str]
+    location: NotGivenOr[str]
+    max_output_tokens: NotGivenOr[int]
+    top_p: NotGivenOr[float]
+    top_k: NotGivenOr[float]
+    presence_penalty: NotGivenOr[float]
+    frequency_penalty: NotGivenOr[float]
 
 
 class LLM(llm.LLM):
@@ -61,18 +59,17 @@ class LLM(llm.LLM):
         self,
         *,
         model: ChatModels | str = "gemini-2.0-flash-001",
-        api_key: str | None = None,
-        vertexai: bool = False,
-        project: str | None = None,
-        location: str | None = None,
-        candidate_count: int = 1,
-        temperature: float = 0.8,
-        max_output_tokens: int | None = None,
-        top_p: float | None = None,
-        top_k: float | None = None,
-        presence_penalty: float | None = None,
-        frequency_penalty: float | None = None,
-        tool_choice: Union[ToolChoice, Literal["auto", "required", "none"]] = "auto",
+        api_key: NotGivenOr[str] = NOT_GIVEN,
+        vertexai: NotGivenOr[bool] = False,
+        project: NotGivenOr[str] = NOT_GIVEN,
+        location: NotGivenOr[str] = NOT_GIVEN,
+        temperature: NotGivenOr[float] = NOT_GIVEN,
+        max_output_tokens: NotGivenOr[int] = NOT_GIVEN,
+        top_p: NotGivenOr[float] = NOT_GIVEN,
+        top_k: NotGivenOr[float] = NOT_GIVEN,
+        presence_penalty: NotGivenOr[float] = NOT_GIVEN,
+        frequency_penalty: NotGivenOr[float] = NOT_GIVEN,
+        tool_choice: NotGivenOr[ToolChoice | Literal["auto", "required", "none"]] = NOT_GIVEN,
     ) -> None:
         """
         Create a new instance of Google GenAI LLM.
@@ -90,7 +87,6 @@ class LLM(llm.LLM):
             vertexai (bool, optional): Whether to use VertexAI. Defaults to False.
             project (str, optional): The Google Cloud project to use (only for VertexAI). Defaults to None.
             location (str, optional): The location to use for VertexAI API requests. Defaults value is "us-central1".
-            candidate_count (int, optional): Number of candidate responses to generate. Defaults to 1.
             temperature (float, optional): Sampling temperature for response generation. Defaults to 0.8.
             max_output_tokens (int, optional): Maximum number of tokens to generate in the output. Defaults to None.
             top_p (float, optional): The nucleus sampling probability for response generation. Defaults to None.
@@ -99,16 +95,9 @@ class LLM(llm.LLM):
             frequency_penalty (float, optional): Penalizes the model for repeating words. Defaults to None.
             tool_choice (ToolChoice or Literal["auto", "required", "none"], optional): Specifies whether to use tools during response generation. Defaults to "auto".
         """
-        super().__init__(
-            capabilities=LLMCapabilities(
-                supports_choices_on_int=False,
-                requires_persistent_functions=False,
-            )
-        )
+        super().__init__()
         self._project_id = project or os.environ.get("GOOGLE_CLOUD_PROJECT", None)
-        self._location = location or os.environ.get(
-            "GOOGLE_CLOUD_LOCATION", "us-central1"
-        )
+        self._location = location or os.environ.get("GOOGLE_CLOUD_LOCATION", "us-central1")
         self._api_key = api_key or os.environ.get("GOOGLE_API_KEY", None)
         _gac = os.environ.get("GOOGLE_APPLICATION_CREDENTIALS")
         if _gac is None:
@@ -131,14 +120,13 @@ class LLM(llm.LLM):
                     "API key is required for Google API either via api_key or GOOGLE_API_KEY environment variable"
                 )
 
-        self._opts = LLMOptions(
+        self._opts = _LLMOptions(
             model=model,
             temperature=temperature,
             tool_choice=tool_choice,
             vertexai=vertexai,
             project=project,
             location=location,
-            candidate_count=candidate_count,
             max_output_tokens=max_output_tokens,
             top_p=top_p,
             top_k=top_k,
@@ -151,41 +139,77 @@ class LLM(llm.LLM):
             project=self._project_id,
             location=self._location,
         )
-        self._running_fncs: MutableSet[asyncio.Task[Any]] = set()
 
     def chat(
         self,
         *,
         chat_ctx: llm.ChatContext,
+        tools: list[FunctionTool] | None = None,
         conn_options: APIConnectOptions = DEFAULT_API_CONNECT_OPTIONS,
-        fnc_ctx: llm.FunctionContext | None = None,
-        temperature: float | None = None,
-        n: int | None = 1,
-        parallel_tool_calls: bool | None = None,
-        tool_choice: Union[ToolChoice, Literal["auto", "required", "none"]]
-        | None = None,
-    ) -> "LLMStream":
-        if tool_choice is None:
-            tool_choice = self._opts.tool_choice
-
-        if temperature is None:
-            temperature = self._opts.temperature
+        parallel_tool_calls: NotGivenOr[bool] = NOT_GIVEN,
+        tool_choice: NotGivenOr[ToolChoice | Literal["auto", "required", "none"]] = NOT_GIVEN,
+        extra_kwargs: NotGivenOr[dict[str, Any]] = NOT_GIVEN,
+    ) -> LLMStream:
+        extra = {}
+
+        if is_given(extra_kwargs):
+            extra.update(extra_kwargs)
+
+        tool_choice = tool_choice if is_given(tool_choice) else self._opts.tool_choice
+        if is_given(tool_choice):
+            gemini_tool_choice: types.ToolConfig
+            if isinstance(tool_choice, ToolChoice):
+                gemini_tool_choice = types.ToolConfig(
+                    function_calling_config=types.FunctionCallingConfig(
+                        mode="ANY",
+                        allowed_function_names=[tool_choice["function"]["name"]],
+                    )
+                )
+                extra["tool_config"] = gemini_tool_choice
+            elif tool_choice == "required":
+                gemini_tool_choice = types.ToolConfig(
+                    function_calling_config=types.FunctionCallingConfig(
+                        mode="ANY",
+                        allowed_function_names=[fnc.name for fnc in tools],
+                    )
+                )
+                extra["tool_config"] = gemini_tool_choice
+            elif tool_choice == "auto":
+                gemini_tool_choice = types.ToolConfig(
+                    function_calling_config=types.FunctionCallingConfig(
+                        mode="AUTO",
+                    )
+                )
+                extra["tool_config"] = gemini_tool_choice
+            elif tool_choice == "none":
+                gemini_tool_choice = types.ToolConfig(
+                    function_calling_config=types.FunctionCallingConfig(
+                        mode="NONE",
+                    )
+                )
+                extra["tool_config"] = gemini_tool_choice
+
+        if is_given(self._opts.temperature):
+            extra["temperature"] = self._opts.temperature
+        if is_given(self._opts.max_output_tokens):
+            extra["max_output_tokens"] = self._opts.max_output_tokens
+        if is_given(self._opts.top_p):
+            extra["top_p"] = self._opts.top_p
+        if is_given(self._opts.top_k):
+            extra["top_k"] = self._opts.top_k
+        if is_given(self._opts.presence_penalty):
+            extra["presence_penalty"] = self._opts.presence_penalty
+        if is_given(self._opts.frequency_penalty):
+            extra["frequency_penalty"] = self._opts.frequency_penalty
 
         return LLMStream(
             self,
             client=self._client,
             model=self._opts.model,
-            max_output_tokens=self._opts.max_output_tokens,
-            top_p=self._opts.top_p,
-            top_k=self._opts.top_k,
-            presence_penalty=self._opts.presence_penalty,
-            frequency_penalty=self._opts.frequency_penalty,
             chat_ctx=chat_ctx,
-            fnc_ctx=fnc_ctx,
+            tools=tools,
             conn_options=conn_options,
-            n=n,
-            temperature=temperature,
-            tool_choice=tool_choice,
+            extra_kwargs=extra,
         )
 
 
@@ -198,96 +222,37 @@ class LLMStream(llm.LLMStream):
         model: str | ChatModels,
         chat_ctx: llm.ChatContext,
         conn_options: APIConnectOptions,
-        fnc_ctx: llm.FunctionContext | None,
-        temperature: float | None,
-        n: int | None,
-        max_output_tokens: int | None,
-        top_p: float | None,
-        top_k: float | None,
-        presence_penalty: float | None,
-        frequency_penalty: float | None,
-        tool_choice: Union[ToolChoice, Literal["auto", "required", "none"]],
+        tools: list[FunctionTool] | None,
+        extra_kwargs: dict[str, Any],
     ) -> None:
-        super().__init__(
-            llm, chat_ctx=chat_ctx, fnc_ctx=fnc_ctx, conn_options=conn_options
-        )
+        super().__init__(llm, chat_ctx=chat_ctx, tools=tools, conn_options=conn_options)
         self._client = client
         self._model = model
         self._llm: LLM = llm
-        self._max_output_tokens = max_output_tokens
-        self._top_p = top_p
-        self._top_k = top_k
-        self._presence_penalty = presence_penalty
-        self._frequency_penalty = frequency_penalty
-        self._temperature = temperature
-        self._n = n
-        self._tool_choice = tool_choice
+        self._extra_kwargs = extra_kwargs
 
     async def _run(self) -> None:
         retryable = True
         request_id = utils.shortuuid()
 
         try:
-            opts: dict[str, Any] = dict()
-            turns, system_instruction = _build_gemini_ctx(self._chat_ctx, id(self))
-
-            if self._fnc_ctx and len(self._fnc_ctx.ai_functions) > 0:
-                functions = _build_tools(self._fnc_ctx)
-                opts["tools"] = [types.Tool(function_declarations=functions)]
-
-                if self._tool_choice is not None:
-                    if isinstance(self._tool_choice, ToolChoice):
-                        # specific function
-                        tool_config = types.ToolConfig(
-                            function_calling_config=types.FunctionCallingConfig(
-                                mode=types.FunctionCallingConfigMode.ANY,
-                                allowed_function_names=[self._tool_choice.name],
-                            )
-                        )
-                    elif self._tool_choice == "required":
-                        # model must call any function
-                        tool_config = types.ToolConfig(
-                            function_calling_config=types.FunctionCallingConfig(
-                                mode=types.FunctionCallingConfigMode.ANY,
-                                allowed_function_names=[
-                                    fnc.name
-                                    for fnc in self._fnc_ctx.ai_functions.values()
-                                ],
-                            )
-                        )
-                    elif self._tool_choice == "auto":
-                        # model can call any function
-                        tool_config = types.ToolConfig(
-                            function_calling_config=types.FunctionCallingConfig(
-                                mode=types.FunctionCallingConfigMode.AUTO
-                            )
-                        )
-                    elif self._tool_choice == "none":
-                        # model cannot call any function
-                        tool_config = types.ToolConfig(
-                            function_calling_config=types.FunctionCallingConfig(
-                                mode=types.FunctionCallingConfigMode.NONE,
-                            )
-                        )
-                    opts["tool_config"] = tool_config
+            turns, system_instruction = to_chat_ctx(self._chat_ctx, id(self._llm))
 
+            self._extra_kwargs["tools"] = [
+                types.Tool(function_declarations=to_fnc_ctx(self._tools))
+            ]
             config = types.GenerateContentConfig(
-                candidate_count=self._n,
-                temperature=self._temperature,
-                max_output_tokens=self._max_output_tokens,
-                top_p=self._top_p,
-                top_k=self._top_k,
-                presence_penalty=self._presence_penalty,
-                frequency_penalty=self._frequency_penalty,
                 system_instruction=system_instruction,
-                **opts,
+                **self._extra_kwargs,
             )
+
             stream = await self._client.aio.models.generate_content_stream(
                 model=self._model,
                 contents=cast(types.ContentListUnion, turns),
                 config=config,
             )
-            async for response in stream:  # type: ignore
+
+            async for response in stream:
                 if response.prompt_feedback:
                     raise APIStatusError(
                         response.prompt_feedback.json(),
@@ -311,8 +276,8 @@ class LLMStream(llm.LLMStream):
                         "gemini llm: there are multiple candidates in the response, returning response from the first one."
                     )
 
-                for index, part in enumerate(response.candidates[0].content.parts):
-                    chat_chunk = self._parse_part(request_id, index, part)
+                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)
@@ -321,7 +286,7 @@ class LLMStream(llm.LLMStream):
                     usage = response.usage_metadata
                     self._event_ch.send_nowait(
                         llm.ChatChunk(
-                            request_id=request_id,
+                            id=request_id,
                             usage=llm.CompletionUsage(
                                 completion_tokens=usage.candidates_token_count or 0,
                                 prompt_tokens=usage.prompt_token_count or 0,
@@ -329,6 +294,7 @@ class LLMStream(llm.LLMStream):
                             ),
                         )
                     )
+
         except ClientError as e:
             raise APIStatusError(
                 "gemini llm: client error",
@@ -359,61 +325,25 @@ class LLMStream(llm.LLMStream):
                 retryable=retryable,
             ) from e
 
-    def _parse_part(
-        self, id: str, index: int, part: types.Part
-    ) -> llm.ChatChunk | None:
+    def _parse_part(self, id: str, part: types.Part) -> llm.ChatChunk | None:
         if part.function_call:
-            return self._try_build_function(id, index, part)
-
-        return llm.ChatChunk(
-            request_id=id,
-            choices=[
-                llm.Choice(
-                    delta=llm.ChoiceDelta(content=part.text, role="assistant"),
-                    index=index,
-                )
-            ],
-        )
-
-    def _try_build_function(
-        self, id: str, index: int, part: types.Part
-    ) -> llm.ChatChunk | None:
-        if part.function_call is None:
-            logger.warning("gemini llm: no function call in the response")
-            return None
-
-        if part.function_call.name is None:
-            logger.warning("gemini llm: no function name in the response")
-            return None
-
-        if part.function_call.id is None:
-            part.function_call.id = utils.shortuuid()
-
-        if self._fnc_ctx is None:
-            logger.warning(
-                "google stream tried to run function without function context"
+            chat_chunk = llm.ChatChunk(
+                id=id,
+                delta=llm.ChoiceDelta(
+                    role="assistant",
+                    tool_calls=[
+                        llm.FunctionToolCall(
+                            arguments=json.dumps(part.function_call.args),
+                            name=part.function_call.name,
+                            call_id=part.function_call.id or utils.shortuuid("function_call_"),
+                        )
+                    ],
+                    content=part.text,
+                ),
             )
-            return None
-
-        fnc_info = _create_ai_function_info(
-            self._fnc_ctx,
-            part.function_call.id,
-            part.function_call.name,
-            json.dumps(part.function_call.args),
-        )
-
-        self._function_calls_info.append(fnc_info)
+            return chat_chunk
 
         return llm.ChatChunk(
-            request_id=id,
-            choices=[
-                llm.Choice(
-                    delta=llm.ChoiceDelta(
-                        role="assistant",
-                        tool_calls=[fnc_info],
-                        content=part.text,
-                    ),
-                    index=index,
-                )
-            ],
+            id=id,
+            delta=llm.ChoiceDelta(content=part.text, role="assistant"),
         )

livekit/plugins/google/stt.py

@@ -19,8 +19,14 @@ import dataclasses
 import time
 import weakref
 from dataclasses import dataclass
-from typing import Callable, List, Union
+from typing import Callable, Union
 
+from google.api_core.client_options import ClientOptions
+from google.api_core.exceptions import DeadlineExceeded, GoogleAPICallError
+from google.auth import default as gauth_default
+from google.auth.exceptions import DefaultCredentialsError
+from google.cloud.speech_v2 import SpeechAsyncClient
+from google.cloud.speech_v2.types import cloud_speech
 from livekit import rtc
 from livekit.agents import (
     DEFAULT_API_CONNECT_OPTIONS,
@@ -32,18 +38,11 @@ from livekit.agents import (
     utils,
 )
 
-from google.api_core.client_options import ClientOptions
-from google.api_core.exceptions import DeadlineExceeded, GoogleAPICallError
-from google.auth import default as gauth_default
-from google.auth.exceptions import DefaultCredentialsError
-from google.cloud.speech_v2 import SpeechAsyncClient
-from google.cloud.speech_v2.types import cloud_speech
-
 from .log import logger
 from .models import SpeechLanguages, SpeechModels
 
 LgType = Union[SpeechLanguages, str]
-LanguageCode = Union[LgType, List[LgType]]
+LanguageCode = Union[LgType, list[LgType]]
 
 # Google STT has a timeout of 5 mins, we'll attempt to restart the session
 # before that timeout is reached
@@ -56,14 +55,14 @@ _min_confidence = 0.65
 # This class is only be used internally to encapsulate the options
 @dataclass
 class STTOptions:
-    languages: List[LgType]
+    languages: list[LgType]
     detect_language: bool
     interim_results: bool
     punctuate: bool
     spoken_punctuation: bool
     model: SpeechModels | str
     sample_rate: int
-    keywords: List[tuple[str, float]] | None
+    keywords: list[tuple[str, float]] | None
 
     def build_adaptation(self) -> cloud_speech.SpeechAdaptation | None:
         if self.keywords:
@@ -72,9 +71,7 @@ class STTOptions:
                     cloud_speech.SpeechAdaptation.AdaptationPhraseSet(
                         inline_phrase_set=cloud_speech.PhraseSet(
                             phrases=[
-                                cloud_speech.PhraseSet.Phrase(
-                                    value=keyword, boost=boost
-                                )
+                                cloud_speech.PhraseSet.Phrase(value=keyword, boost=boost)
                                 for keyword, boost in self.keywords
                             ]
                         )
@@ -98,7 +95,7 @@ class STT(stt.STT):
         sample_rate: int = 16000,
         credentials_info: dict | None = None,
         credentials_file: str | None = None,
-        keywords: List[tuple[str, float]] | None = None,
+        keywords: list[tuple[str, float]] | None = None,
     ):
         """
         Create a new instance of Google STT.
@@ -120,9 +117,7 @@ class STT(stt.STT):
             credentials_file(str): the credentials file to use for recognition (default: None)
             keywords(List[tuple[str, float]]): list of keywords to recognize (default: None)
         """
-        super().__init__(
-            capabilities=stt.STTCapabilities(streaming=True, interim_results=True)
-        )
+        super().__init__(capabilities=stt.STTCapabilities(streaming=True, interim_results=True))
 
         self._location = location
         self._credentials_info = credentials_info
@@ -163,9 +158,7 @@ class STT(stt.STT):
         client_options = None
         client: SpeechAsyncClient | None = None
         if self._location != "global":
-            client_options = ClientOptions(
-                api_endpoint=f"{self._location}-speech.googleapis.com"
-            )
+            client_options = ClientOptions(api_endpoint=f"{self._location}-speech.googleapis.com")
         if self._credentials_info:
             client = SpeechAsyncClient.from_service_account_info(
                 self._credentials_info,
@@ -206,9 +199,7 @@ class STT(stt.STT):
             config.languages = [config.languages]
         elif not config.detect_language:
             if len(config.languages) > 1:
-                logger.warning(
-                    "multiple languages provided, but language detection is disabled"
-                )
+                logger.warning("multiple languages provided, but language detection is disabled")
             config.languages = [config.languages[0]]
 
         return config
@@ -266,7 +257,7 @@ class STT(stt.STT):
         *,
         language: SpeechLanguages | str | None = None,
         conn_options: APIConnectOptions = DEFAULT_API_CONNECT_OPTIONS,
-    ) -> "SpeechStream":
+    ) -> SpeechStream:
         config = self._sanitize_options(language=language)
         stream = SpeechStream(
             stt=self,
@@ -288,7 +279,7 @@ class STT(stt.STT):
         spoken_punctuation: bool | None = None,
         model: SpeechModels | None = None,
         location: str | None = None,
-        keywords: List[tuple[str, float]] | None = None,
+        keywords: list[tuple[str, float]] | None = None,
     ):
         if languages is not None:
             if isinstance(languages, str):
@@ -337,9 +328,7 @@ class SpeechStream(stt.SpeechStream):
         recognizer_cb: Callable[[SpeechAsyncClient], str],
         config: STTOptions,
     ) -> None:
-        super().__init__(
-            stt=stt, conn_options=conn_options, sample_rate=config.sample_rate
-        )
+        super().__init__(stt=stt, conn_options=conn_options, sample_rate=config.sample_rate)
 
         self._pool = pool
         self._recognizer_cb = recognizer_cb
@@ -356,7 +345,7 @@ class SpeechStream(stt.SpeechStream):
         punctuate: bool | None = None,
         spoken_punctuation: bool | None = None,
         model: SpeechModels | None = None,
-        keywords: List[tuple[str, float]] | None = None,
+        keywords: list[tuple[str, float]] | None = None,
     ):
         if languages is not None:
             if isinstance(languages, str):
@@ -380,9 +369,7 @@ class SpeechStream(stt.SpeechStream):
     async def _run(self) -> None:
         # google requires a async generator when calling streaming_recognize
         # this function basically convert the queue into a async generator
-        async def input_generator(
-            client: SpeechAsyncClient, should_stop: asyncio.Event
-        ):
+        async def input_generator(client: SpeechAsyncClient, should_stop: asyncio.Event):
             try:
                 # first request should contain the config
                 yield cloud_speech.StreamingRecognizeRequest(
@@ -398,14 +385,10 @@ class SpeechStream(stt.SpeechStream):
                         return
 
                     if isinstance(frame, rtc.AudioFrame):
-                        yield cloud_speech.StreamingRecognizeRequest(
-                            audio=frame.data.tobytes()
-                        )
+                        yield cloud_speech.StreamingRecognizeRequest(audio=frame.data.tobytes())
 
             except Exception:
-                logger.exception(
-                    "an error occurred while streaming input to google STT"
-                )
+                logger.exception("an error occurred while streaming input to google STT")
 
         async def process_stream(client: SpeechAsyncClient, stream):
             has_started = False
@@ -442,19 +425,14 @@ class SpeechStream(stt.SpeechStream):
                                 alternatives=[speech_data],
                             )
                         )
-                        if (
-                            time.time() - self._session_connected_at
-                            > _max_session_duration
-                        ):
+                        if time.time() - self._session_connected_at > _max_session_duration:
                             logger.debug(
                                 "Google STT maximum connection time reached. Reconnecting..."
                             )
                             self._pool.remove(client)
                             if has_started:
                                 self._event_ch.send_nowait(
-                                    stt.SpeechEvent(
-                                        type=stt.SpeechEventType.END_OF_SPEECH
-                                    )
+                                    stt.SpeechEvent(type=stt.SpeechEventType.END_OF_SPEECH)
                                 )
                                 has_started = False
                             self._reconnect_event.set()
@@ -499,12 +477,8 @@ class SpeechStream(stt.SpeechStream):
                     )
                     self._session_connected_at = time.time()
 
-                    process_stream_task = asyncio.create_task(
-                        process_stream(client, stream)
-                    )
-                    wait_reconnect_task = asyncio.create_task(
-                        self._reconnect_event.wait()
-                    )
+                    process_stream_task = asyncio.create_task(process_stream(client, stream))
+                    wait_reconnect_task = asyncio.create_task(self._reconnect_event.wait())
 
                     try:
                         done, _ = await asyncio.wait(
@@ -518,9 +492,7 @@ class SpeechStream(stt.SpeechStream):
                             break
                         self._reconnect_event.clear()
                     finally:
-                        await utils.aio.gracefully_cancel(
-                            process_stream_task, wait_reconnect_task
-                        )
+                        await utils.aio.gracefully_cancel(process_stream_task, wait_reconnect_task)
                         should_stop.set()
             except DeadlineExceeded:
                 raise APITimeoutError()
@@ -581,8 +553,6 @@ def _streaming_recognize_response_to_speech_data(
     if text == "":
         return None
 
-    data = stt.SpeechData(
-        language=lg, start_time=0, end_time=0, confidence=confidence, text=text
-    )
+    data = stt.SpeechData(language=lg, start_time=0, end_time=0, confidence=confidence, text=text)
 
     return data