livekit-plugins-google 1.0.22__py3-none-any.whl → 1.1.0__py3-none-any.whl

livekit/plugins/google/tts.py

@@ -16,26 +16,15 @@ from __future__ import annotations
 
 import asyncio
 import weakref
-from dataclasses import dataclass
+from collections.abc import AsyncGenerator
+from dataclasses import dataclass, replace
 
 from google.api_core.client_options import ClientOptions
 from google.api_core.exceptions import DeadlineExceeded, GoogleAPICallError
 from google.cloud import texttospeech
 from google.cloud.texttospeech_v1.types import SsmlVoiceGender, SynthesizeSpeechResponse
-from livekit.agents import (
-    APIConnectionError,
-    APIConnectOptions,
-    APIStatusError,
-    APITimeoutError,
-    tokenize,
-    tts,
-    utils,
-)
-from livekit.agents.types import (
-    DEFAULT_API_CONNECT_OPTIONS,
-    NOT_GIVEN,
-    NotGivenOr,
-)
+from livekit.agents import APIConnectOptions, APIStatusError, APITimeoutError, tokenize, tts, utils
+from livekit.agents.types import DEFAULT_API_CONNECT_OPTIONS, NOT_GIVEN, NotGivenOr
 from livekit.agents.utils import is_given
 
 from .log import logger
@@ -51,7 +40,11 @@ DEFAULT_GENDER = "neutral"
 @dataclass
 class _TTSOptions:
     voice: texttospeech.VoiceSelectionParams
-    audio_config: texttospeech.AudioConfig
+    encoding: texttospeech.AudioEncoding
+    sample_rate: int
+    pitch: float
+    effects_profile_id: str
+    speaking_rate: float
     tokenizer: tokenize.SentenceTokenizer
 
 
@@ -67,11 +60,11 @@ class TTS(tts.TTS):
         effects_profile_id: str = "",
         speaking_rate: float = 1.0,
         location: str = "global",
-        audio_encoding: texttospeech.AudioEncoding = texttospeech.AudioEncoding.PCM,
+        audio_encoding: texttospeech.AudioEncoding = texttospeech.AudioEncoding.OGG_OPUS,  # type: ignore
         credentials_info: NotGivenOr[dict] = NOT_GIVEN,
         credentials_file: NotGivenOr[str] = NOT_GIVEN,
         tokenizer: NotGivenOr[tokenize.SentenceTokenizer] = NOT_GIVEN,
-        use_streaming: NotGivenOr[bool] = NOT_GIVEN,
+        use_streaming: bool = True,
     ) -> None:
         """
         Create a new instance of Google TTS.
@@ -94,9 +87,6 @@ class TTS(tts.TTS):
             tokenizer (tokenize.SentenceTokenizer, optional): Tokenizer for the TTS. Default is a basic sentence tokenizer.
             use_streaming (bool, optional): Whether to use streaming synthesis. Default is True.
         """  # noqa: E501
-        if not is_given(use_streaming):
-            use_streaming = True
-
         super().__init__(
             capabilities=tts.TTSCapabilities(streaming=use_streaming),
             sample_rate=sample_rate,
@@ -122,13 +112,11 @@ class TTS(tts.TTS):
 
         self._opts = _TTSOptions(
             voice=voice_params,
-            audio_config=texttospeech.AudioConfig(
-                audio_encoding=audio_encoding,
-                sample_rate_hertz=sample_rate,
-                pitch=pitch,
-                effects_profile_id=effects_profile_id,
-                speaking_rate=speaking_rate,
-            ),
+            encoding=audio_encoding,
+            sample_rate=sample_rate,
+            pitch=pitch,
+            effects_profile_id=effects_profile_id,
+            speaking_rate=speaking_rate,
             tokenizer=tokenizer,
         )
         self._streams = weakref.WeakSet[SynthesizeStream]()
@@ -149,7 +137,7 @@ class TTS(tts.TTS):
             gender (Gender | str, optional): Voice gender ("male", "female", "neutral").
             voice_name (str, optional): Specific voice name.
             speaking_rate (float, optional): Speed of speech.
-        """  # noqa: E501
+        """
         params = {}
         if is_given(language):
             params["language_code"] = str(language)
@@ -162,7 +150,7 @@ class TTS(tts.TTS):
             self._opts.voice = texttospeech.VoiceSelectionParams(**params)
 
         if is_given(speaking_rate):
-            self._opts.audio_config.speaking_rate = speaking_rate
+            self._opts.speaking_rate = speaking_rate
 
     def _ensure_client(self) -> texttospeech.TextToSpeechAsyncClient:
         api_endpoint = "texttospeech.googleapis.com"
@@ -190,107 +178,89 @@ class TTS(tts.TTS):
     def stream(
         self, *, conn_options: APIConnectOptions = DEFAULT_API_CONNECT_OPTIONS
     ) -> SynthesizeStream:
-        stream = SynthesizeStream(
-            tts=self,
-            opts=self._opts,
-            client=self._ensure_client(),
-            conn_options=conn_options,
-        )
+        stream = SynthesizeStream(tts=self, conn_options=conn_options)
         self._streams.add(stream)
         return stream
 
     def synthesize(
-        self,
-        text: str,
-        *,
-        conn_options: APIConnectOptions = DEFAULT_API_CONNECT_OPTIONS,
+        self, text: str, *, conn_options: APIConnectOptions = DEFAULT_API_CONNECT_OPTIONS
     ) -> ChunkedStream:
-        return ChunkedStream(
-            tts=self,
-            input_text=text,
-            conn_options=conn_options,
-            opts=self._opts,
-            client=self._ensure_client(),
-        )
+        return ChunkedStream(tts=self, input_text=text, conn_options=conn_options)
 
     async def aclose(self) -> None:
         for stream in list(self._streams):
             await stream.aclose()
         self._streams.clear()
-        await super().aclose()
 
 
 class ChunkedStream(tts.ChunkedStream):
-    def __init__(
-        self,
-        *,
-        tts: TTS,
-        input_text: str,
-        opts: _TTSOptions,
-        client: texttospeech.TextToSpeechAsyncClient,
-        conn_options: APIConnectOptions,
-    ) -> None:
+    def __init__(self, *, tts: TTS, input_text: str, conn_options: APIConnectOptions) -> None:
         super().__init__(tts=tts, input_text=input_text, conn_options=conn_options)
-        self._opts, self._client = opts, client
-
-    async def _run(self) -> None:
-        request_id = utils.shortuuid()
+        self._tts: TTS = tts
+        self._opts = replace(tts._opts)
 
+    async def _run(self, output_emitter: tts.AudioEmitter) -> None:
         try:
-            response: SynthesizeSpeechResponse = await self._client.synthesize_speech(
+            response: SynthesizeSpeechResponse = await self._tts._ensure_client().synthesize_speech(
                 input=texttospeech.SynthesisInput(text=self._input_text),
                 voice=self._opts.voice,
-                audio_config=self._opts.audio_config,
+                audio_config=texttospeech.AudioConfig(
+                    audio_encoding=self._opts.encoding,
+                    sample_rate_hertz=self._opts.sample_rate,
+                    pitch=self._opts.pitch,
+                    effects_profile_id=self._opts.effects_profile_id,
+                    speaking_rate=self._opts.speaking_rate,
+                ),
                 timeout=self._conn_options.timeout,
             )
 
-            # Create AudioStreamDecoder for OGG format
-            decoder = utils.codecs.AudioStreamDecoder(
-                sample_rate=self._opts.audio_config.sample_rate_hertz,
+            output_emitter.initialize(
+                request_id=utils.shortuuid(),
+                sample_rate=self._opts.sample_rate,
                 num_channels=1,
+                mime_type=_encoding_to_mimetype(self._opts.encoding),
             )
 
-            try:
-                decoder.push(response.audio_content)
-                decoder.end_input()
-                emitter = tts.SynthesizedAudioEmitter(
-                    event_ch=self._event_ch,
-                    request_id=request_id,
-                )
-                async for frame in decoder:
-                    emitter.push(frame)
-                emitter.flush()
-            finally:
-                await decoder.aclose()
-
+            output_emitter.push(response.audio_content)
         except DeadlineExceeded:
             raise APITimeoutError() from None
         except GoogleAPICallError as e:
-            raise APIStatusError(
-                f"{e.message} {e.details}", status_code=e.code or -1, request_id=None, body=None
-            ) from e
-        except Exception as e:
-            raise APIConnectionError() from e
+            raise APIStatusError(e.message, status_code=e.code or -1) from e
 
 
 class SynthesizeStream(tts.SynthesizeStream):
-    def __init__(
-        self,
-        *,
-        tts: TTS,
-        opts: _TTSOptions,
-        client: texttospeech.TextToSpeechAsyncClient,
-        conn_options: APIConnectOptions,
-    ):
+    def __init__(self, *, tts: TTS, conn_options: APIConnectOptions):
         super().__init__(tts=tts, conn_options=conn_options)
-        self._opts, self._client = opts, client
+        self._tts: TTS = tts
+        self._opts = replace(tts._opts)
         self._segments_ch = utils.aio.Chan[tokenize.SentenceStream]()
 
-    async def _run(self) -> None:
-        request_id = utils.shortuuid()
+    async def _run(self, output_emitter: tts.AudioEmitter) -> None:
+        encoding = self._opts.encoding
+        if encoding not in (texttospeech.AudioEncoding.OGG_OPUS, texttospeech.AudioEncoding.PCM):
+            enc_name = texttospeech.AudioEncoding._member_names_[encoding]
+            logger.warning(
+                f"encoding {enc_name} isn't supported by the streaming_synthesize, "
+                "fallbacking to PCM"
+            )
+            encoding = texttospeech.AudioEncoding.PCM  # type: ignore
 
-        @utils.log_exceptions(logger=logger)
-        async def _tokenize_input():
+        output_emitter.initialize(
+            request_id=utils.shortuuid(),
+            sample_rate=self._opts.sample_rate,
+            num_channels=1,
+            mime_type=_encoding_to_mimetype(encoding),
+            stream=True,
+        )
+
+        streaming_config = texttospeech.StreamingSynthesizeConfig(
+            voice=self._opts.voice,
+            streaming_audio_config=texttospeech.StreamingAudioConfig(
+                audio_encoding=encoding, sample_rate_hertz=self._opts.sample_rate
+            ),
+        )
+
+        async def _tokenize_input() -> None:
             input_stream = None
             async for input in self._input_ch:
                 if isinstance(input, str):
@@ -302,12 +272,12 @@ class SynthesizeStream(tts.SynthesizeStream):
                     if input_stream:
                         input_stream.end_input()
                     input_stream = None
+
             self._segments_ch.close()
 
-        @utils.log_exceptions(logger=logger)
-        async def _run_segments():
+        async def _run_segments() -> None:
             async for input_stream in self._segments_ch:
-                await self._run_stream(input_stream, request_id)
+                await self._run_stream(input_stream, output_emitter, streaming_config)
 
         tasks = [
             asyncio.create_task(_tokenize_input()),
@@ -315,26 +285,22 @@ class SynthesizeStream(tts.SynthesizeStream):
         ]
         try:
             await asyncio.gather(*tasks)
-        except Exception as e:
-            raise APIConnectionError() from e
-
-    async def _run_stream(self, input_stream, request_id):
-        streaming_config = texttospeech.StreamingSynthesizeConfig(
-            voice=self._opts.voice,
-            streaming_audio_config=texttospeech.StreamingAudioConfig(
-                audio_encoding=texttospeech.AudioEncoding.PCM
-            ),
-        )
-        emitter = tts.SynthesizedAudioEmitter(event_ch=self._event_ch, request_id=request_id)
-        audio_bstream = utils.audio.AudioByteStream(
-            sample_rate=self._opts.audio_config.sample_rate_hertz,
-            num_channels=NUM_CHANNELS,
-        )
+        finally:
+            await utils.aio.cancel_and_wait(*tasks)
 
+    async def _run_stream(
+        self,
+        input_stream: tokenize.SentenceStream,
+        output_emitter: tts.AudioEmitter,
+        streaming_config: texttospeech.StreamingSynthesizeConfig,
+    ) -> None:
         @utils.log_exceptions(logger=logger)
-        async def input_generator():
+        async def input_generator() -> AsyncGenerator[
+            texttospeech.StreamingSynthesizeRequest, None
+        ]:
             try:
                 yield texttospeech.StreamingSynthesizeRequest(streaming_config=streaming_config)
+
                 async for input in input_stream:
                     self._mark_started()
                     yield texttospeech.StreamingSynthesizeRequest(
@@ -344,30 +310,24 @@ class SynthesizeStream(tts.SynthesizeStream):
             except Exception:
                 logger.exception("an error occurred while streaming input to google TTS")
 
+        input_gen = input_generator()
         try:
-            stream = await self._client.streaming_synthesize(
-                input_generator(),
-                timeout=self._conn_options.timeout,
+            stream = await self._tts._ensure_client().streaming_synthesize(
+                input_gen, timeout=self._conn_options.timeout
             )
+            output_emitter.start_segment(segment_id=utils.shortuuid())
+
             async for resp in stream:
-                for frame in audio_bstream.write(resp.audio_content):
-                    emitter.push(frame)
-
-            for frame in audio_bstream.flush():
-                emitter.push(frame)
-            emitter.flush()
-        except DeadlineExceeded as e:
-            logger.debug(f"google tts deadline exceeded: {e}")
-            pass
+                output_emitter.push(resp.audio_content)
+
+            output_emitter.end_segment()
+
+        except DeadlineExceeded:
+            raise APITimeoutError() from None
         except GoogleAPICallError as e:
-            raise APIStatusError(
-                f"{e.message} {e.details}",
-                status_code=e.code or -1,
-                request_id=request_id,
-                body=None,
-            ) from e
-        except Exception as e:
-            raise APIConnectionError() from e
+            raise APIStatusError(e.message, status_code=e.code or -1) from e
+        finally:
+            await input_gen.aclose()
 
 
 def _gender_from_str(gender: str) -> SsmlVoiceGender:
@@ -378,3 +338,16 @@ def _gender_from_str(gender: str) -> SsmlVoiceGender:
         ssml_gender = SsmlVoiceGender.FEMALE
 
     return ssml_gender  # type: ignore
+
+
+def _encoding_to_mimetype(encoding: texttospeech.AudioEncoding) -> str:
+    if encoding == texttospeech.AudioEncoding.PCM:
+        return "audio/pcm"
+    elif encoding == texttospeech.AudioEncoding.LINEAR16:
+        return "audio/wav"
+    elif encoding == texttospeech.AudioEncoding.MP3:
+        return "audio/mp3"
+    elif encoding == texttospeech.AudioEncoding.OGG_OPUS:
+        return "audio/opus"
+    else:
+        raise RuntimeError(f"encoding {encoding} isn't supported")

livekit/plugins/google/utils.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import json
 import re
 from copy import deepcopy
 from typing import Any
@@ -19,8 +18,9 @@ from livekit.agents.llm.tool_context import (
 )
 
 from .log import logger
+from .tools import _LLMTool
 
-__all__ = ["to_chat_ctx", "to_fnc_ctx"]
+__all__ = ["to_fnc_ctx"]
 
 
 def to_fnc_ctx(fncs: list[FunctionTool | RawFunctionTool]) -> list[types.FunctionDeclaration]:
@@ -36,6 +36,42 @@ def to_fnc_ctx(fncs: list[FunctionTool | RawFunctionTool]) -> list[types.Functio
     return tools
 
 
+def create_tools_config(
+    *,
+    function_tools: list[types.FunctionDeclaration] | None = None,
+    gemini_tools: list[_LLMTool] | None = None,
+) -> list[types.Tool]:
+    tools: list[types.Tool] = []
+
+    if function_tools:
+        tools.append(types.Tool(function_declarations=function_tools))
+
+    if gemini_tools:
+        for tool in gemini_tools:
+            if isinstance(tool, types.GoogleSearchRetrieval):
+                tools.append(types.Tool(google_search_retrieval=tool))
+            elif isinstance(tool, types.ToolCodeExecution):
+                tools.append(types.Tool(code_execution=tool))
+            elif isinstance(tool, types.GoogleSearch):
+                tools.append(types.Tool(google_search=tool))
+            elif isinstance(tool, types.UrlContext):
+                tools.append(types.Tool(url_context=tool))
+            elif isinstance(tool, types.GoogleMaps):
+                tools.append(types.Tool(google_maps=tool))
+            else:
+                logger.warning(f"Warning: Received unhandled tool type: {type(tool)}")
+                continue
+
+    if len(tools) > 1:
+        # https://github.com/google/adk-python/issues/53#issuecomment-2799538041
+        logger.warning(
+            "Multiple kinds of tools are not supported in Gemini. Only the first tool will be used."
+        )
+        tools = tools[:1]
+
+    return tools
+
+
 def get_tool_results_for_realtime(
     chat_ctx: llm.ChatContext, *, vertexai: bool = False
 ) -> types.LiveClientToolResponse | None:
@@ -58,98 +94,13 @@ def get_tool_results_for_realtime(
     )
 
 
-def to_chat_ctx(
-    chat_ctx: llm.ChatContext,
-    cache_key: Any,
-    ignore_functions: bool = False,
-    generate: bool = False,
-) -> tuple[list[types.Content], types.Content | None]:
-    turns: list[types.Content] = []
-    system_instruction: types.Content | None = None
-    current_role: str | None = None
-    parts: list[types.Part] = []
-
-    for msg in chat_ctx.items:
-        if msg.type == "message" and msg.role == "system":
-            sys_parts = []
-            for content in msg.content:
-                if content and isinstance(content, str):
-                    sys_parts.append(types.Part(text=content))
-            system_instruction = types.Content(parts=sys_parts)
-            continue
-
-        if msg.type == "message":
-            role = "model" if msg.role == "assistant" else "user"
-        elif msg.type == "function_call":
-            role = "model"
-        elif msg.type == "function_call_output":
-            role = "user"
-
-        # if the effective role changed, finalize the previous turn.
-        if role != current_role:
-            if current_role is not None and parts:
-                turns.append(types.Content(role=current_role, parts=parts))
-            parts = []
-            current_role = role
-
-        if msg.type == "message":
-            for content in msg.content:
-                if content and isinstance(content, str):
-                    parts.append(types.Part(text=content))
-                elif content and isinstance(content, dict):
-                    parts.append(types.Part(text=json.dumps(content)))
-                elif isinstance(content, llm.ImageContent):
-                    parts.append(_to_image_part(content, cache_key))
-        elif msg.type == "function_call" and not ignore_functions:
-            parts.append(
-                types.Part(
-                    function_call=types.FunctionCall(
-                        name=msg.name,
-                        args=json.loads(msg.arguments),
-                    )
-                )
-            )
-        elif msg.type == "function_call_output" and not ignore_functions:
-            parts.append(
-                types.Part(
-                    function_response=types.FunctionResponse(
-                        name=msg.name,
-                        response={"text": msg.output},
-                    )
-                )
-            )
-
-    if current_role is not None and parts:
-        turns.append(types.Content(role=current_role, parts=parts))
-
-    # Gemini requires the last message to end with user's turn before they can generate
-    if generate and current_role != "user":
-        turns.append(types.Content(role="user", parts=[types.Part(text=".")]))
-
-    return turns, system_instruction
-
-
-def _to_image_part(image: llm.ImageContent, cache_key: Any) -> types.Part:
-    img = llm.utils.serialize_image(image)
-    if img.external_url:
-        if img.mime_type:
-            mime_type = img.mime_type
-        else:
-            logger.debug("No media type provided for image, defaulting to image/jpeg.")
-            mime_type = "image/jpeg"
-        return types.Part.from_uri(file_uri=img.external_url, mime_type=mime_type)
-    if cache_key not in image._cache:
-        image._cache[cache_key] = img.data_bytes
-    return types.Part.from_bytes(data=image._cache[cache_key], mime_type=img.mime_type)
-
-
 def _build_gemini_fnc(function_tool: FunctionTool) -> types.FunctionDeclaration:
     fnc = llm.utils.build_legacy_openai_schema(function_tool, internally_tagged=True)
     json_schema = _GeminiJsonSchema(fnc["parameters"]).simplify()
     return types.FunctionDeclaration(
         name=fnc["name"],
         description=fnc["description"],
-        parameters=json_schema,
+        parameters=types.Schema.model_validate(json_schema) if json_schema else None,
     )
 
 

livekit/plugins/google/version.py

@@ -12,4 +12,4 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-__version__ = "1.0.22"
+__version__ = "1.1.0"

{livekit_plugins_google-1.0.22.dist-info → livekit_plugins_google-1.1.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: livekit-plugins-google
-Version: 1.0.22
+Version: 1.1.0
 Summary: Agent Framework plugin for services from Google Cloud
 Project-URL: Documentation, https://docs.livekit.io
 Project-URL: Website, https://livekit.io/
@@ -21,8 +21,8 @@ Requires-Python: >=3.9.0
 Requires-Dist: google-auth<3,>=2
 Requires-Dist: google-cloud-speech<3,>=2
 Requires-Dist: google-cloud-texttospeech<3,>=2.24
-Requires-Dist: google-genai>=1.14.0
-Requires-Dist: livekit-agents>=1.0.22
+Requires-Dist: google-genai>=v1.16.1
+Requires-Dist: livekit-agents>=1.1.0
 Description-Content-Type: text/markdown
 
 # Google AI plugin for LiveKit Agents

livekit_plugins_google-1.1.0.dist-info/RECORD

@@ -0,0 +1,17 @@
+livekit/plugins/google/__init__.py,sha256=XIyZ-iFnRBpaLtOJgVwojlB-a8GjdDugVFcjBpMEww8,1412
+livekit/plugins/google/llm.py,sha256=MIi-6kk8AZQxcf5y4zB3HwwEQHAJSCIdX79yf9QMAvI,17835
+livekit/plugins/google/log.py,sha256=GI3YWN5YzrafnUccljzPRS_ZALkMNk1i21IRnTl2vNA,69
+livekit/plugins/google/models.py,sha256=hOpfbN_qdQ1ZTpCN9m9dvG2eb6WgQ3KE3WRpIeeM_T0,1569
+livekit/plugins/google/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+livekit/plugins/google/stt.py,sha256=SddM50w6g2rNkjaF5OtrPwEH-qqq36sa-v_6ogKoBYg,24077
+livekit/plugins/google/tools.py,sha256=tD5HVDHO5JfUF029Cx3axHMJec0Gxalkl7s1FDgxLzI,259
+livekit/plugins/google/tts.py,sha256=PzDfEfvQfj-uSHYOUelFnwYK0Wu2-5Mp8PID0b4I5kc,14293
+livekit/plugins/google/utils.py,sha256=-4z6wrjVaZPtFRowkpwaA2acBRfqtzTk4r2xrPDUdCk,8609
+livekit/plugins/google/version.py,sha256=7SjyflIFTjH0djSotKGIRoRykPCqMpVYetIlvHMFuh0,600
+livekit/plugins/google/beta/__init__.py,sha256=5PnoG3Ux24bjzMSzmTeSVljE9EINivGcbWUEV6egGnM,216
+livekit/plugins/google/beta/realtime/__init__.py,sha256=_fW2NMN22F-hnQ4xAJ_g5lPbR7CvM_xXzSWlUQY-E-U,188
+livekit/plugins/google/beta/realtime/api_proto.py,sha256=NfE7xr2N3JOu7gVfWbAmDcEhs8vuZgMRu5vpScPJzsg,776
+livekit/plugins/google/beta/realtime/realtime_api.py,sha256=Mt-f7mkwVd7Aq84HPh_AdIOaB4ye8d6TTllcEjKO5TY,45918
+livekit_plugins_google-1.1.0.dist-info/METADATA,sha256=HeQoxgYu0-hOIOawXsvtwHeESXj1U2Oo5GpwEUEx-W8,1907
+livekit_plugins_google-1.1.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+livekit_plugins_google-1.1.0.dist-info/RECORD,,

livekit_plugins_google-1.0.22.dist-info/RECORD

@@ -1,16 +0,0 @@
-livekit/plugins/google/__init__.py,sha256=xain2qUzU-YWhYWsLBkW8Q-szV-htpnzHTqymMPo-j0,1364
-livekit/plugins/google/llm.py,sha256=Kr9qeBZ5Dd0WCCBR_-gM3WWsVRZPCSteK8NpBsg2C5Y,16304
-livekit/plugins/google/log.py,sha256=GI3YWN5YzrafnUccljzPRS_ZALkMNk1i21IRnTl2vNA,69
-livekit/plugins/google/models.py,sha256=maGlEM3hK4-5hMnH9UQMJewA7BZMrnStsFLBNoNVySg,1531
-livekit/plugins/google/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-livekit/plugins/google/stt.py,sha256=2jk-1fHiBT8UW_n3CZsIEdMp2iBnUAlTnmefdUd8rAM,23620
-livekit/plugins/google/tts.py,sha256=FfhNfGtW8drmYDDfLLZDjaIp2GvNiIdoovgtZq4t_l8,14211
-livekit/plugins/google/utils.py,sha256=UBAbddYk7G8Nojg6bSC7_xN2pdl9qhs86HGhKYFuf9M,10509
-livekit/plugins/google/version.py,sha256=-8dkOE2vDSF9WN8VoBrSwU2sb5YBGFuwPnSQXQ-uaYM,601
-livekit/plugins/google/beta/__init__.py,sha256=5PnoG3Ux24bjzMSzmTeSVljE9EINivGcbWUEV6egGnM,216
-livekit/plugins/google/beta/realtime/__init__.py,sha256=_fW2NMN22F-hnQ4xAJ_g5lPbR7CvM_xXzSWlUQY-E-U,188
-livekit/plugins/google/beta/realtime/api_proto.py,sha256=Fyrejs3SG0EjOPCCFLEnWXKEUxCff47PMWk2VsKJm5E,594
-livekit/plugins/google/beta/realtime/realtime_api.py,sha256=yYB5fKXl_aaMH_ZSpfUlfOTUg4eRqqRENLTZhZMfBMc,36253
-livekit_plugins_google-1.0.22.dist-info/METADATA,sha256=S4bQZr4NhWrAI6vyJi299sh5lsD5eVMNfxvN9__xAMY,1908
-livekit_plugins_google-1.0.22.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-livekit_plugins_google-1.0.22.dist-info/RECORD,,