livekit-plugins-google 0.4.dev0__py3-none-any.whl → 0.5.0__py3-none-any.whl

livekit/plugins/google/__init__.py

@@ -13,9 +13,10 @@
 # limitations under the License.
 
 from .stt import STT, SpeechStream
+from .tts import TTS
 from .version import __version__
 
-__all__ = ["STT", "SpeechStream", "__version__"]
+__all__ = ["STT", "TTS", "SpeechStream", "__version__"]
 
 from livekit.agents import Plugin
 

livekit/plugins/google/models.py

@@ -83,3 +83,7 @@ SpeechLanguages = Literal[
     "vi-VN",
     "da-DK",
 ]
+
+Gender = Literal["male", "female", "neutral"]
+
+AudioEncoding = Literal["wav", "mp3", "ogg", "mulaw", "alaw", "linear16"]

livekit/plugins/google/stt.py

@@ -17,22 +17,22 @@ from __future__ import annotations
 import asyncio
 import contextlib
 import dataclasses
+import os
 from dataclasses import dataclass
-from typing import Any, AsyncIterable, Dict, List
+from typing import AsyncIterable, List, Optional, Union
 
 from livekit import agents, rtc
 from livekit.agents import stt
 from livekit.agents.utils import AudioBuffer
 
-from google.auth import credentials  # type: ignore
 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 = SpeechLanguages | str
-LanguageCode = LgType | List[LgType]
+LgType = Union[SpeechLanguages, str]
+LanguageCode = Union[LgType, List[LgType]]
 
 
 # This class is only be used internally to encapsulate the options
@@ -56,21 +56,25 @@ class STT(stt.STT):
         punctuate: bool = True,
         spoken_punctuation: bool = True,
         model: SpeechModels = "long",
-        credentials_info: Dict[str, Any] | None = None,
+        credentials_info: dict | None = None,
         credentials_file: str | None = None,
     ):
         """
         if no credentials is provided, it will use the credentials on the environment
-        GOOGLE_APPLICATION_CREDENTIALS (Default behavior of Google SpeechAsyncClient)
+        GOOGLE_APPLICATION_CREDENTIALS (default behavior of Google SpeechAsyncClient)
         """
         super().__init__(streaming_supported=True)
 
-        if credentials_info:
-            self._client = SpeechAsyncClient.from_service_account_info(credentials_info)
-        elif credentials_file:
-            self._client = SpeechAsyncClient.from_service_account_file(credentials_file)
-        else:
-            self._client = SpeechAsyncClient()
+        self._client: SpeechAsyncClient | None = None
+        self._credentials_info = credentials_info
+        self._credentials_file = credentials_file
+
+        if credentials_file is None and credentials_info is None:
+            creds = os.environ.get("GOOGLE_APPLICATION_CREDENTIALS")
+            if not creds:
+                raise ValueError(
+                    "GOOGLE_APPLICATION_CREDENTIALS must be set if no credentials is provided"
+                )
 
         if isinstance(languages, str):
             languages = [languages]
@@ -83,13 +87,30 @@ class STT(stt.STT):
             spoken_punctuation=spoken_punctuation,
             model=model,
         )
-        self._creds = self._client.transport._credentials
+
+    def _ensure_client(self) -> SpeechAsyncClient:
+        if self._credentials_info:
+            self._client = SpeechAsyncClient.from_service_account_info(
+                self._credentials_info
+            )
+        elif self._credentials_file:
+            self._client = SpeechAsyncClient.from_service_account_file(
+                self._credentials_file
+            )
+        else:
+            self._client = SpeechAsyncClient()
+
+        assert self._client is not None
+        return self._client
 
     @property
     def _recognizer(self) -> str:
         # TODO(theomonnom): should we use recognizers?
-        # Recognizers may improve latency https://cloud.google.com/speech-to-text/v2/docs/recognizers#understand_recognizers
-        return f"projects/{self._creds.project_id}/locations/global/recognizers/_"  # type: ignore
+        # recognizers may improve latency https://cloud.google.com/speech-to-text/v2/docs/recognizers#understand_recognizers
+
+        # TODO(theomonnom): find a better way to access the project_id
+        project_id = self._ensure_client().transport._credentials.project_id  # type: ignore
+        return f"projects/{project_id}/locations/global/recognizers/_"
 
     def _sanitize_options(
         self,
@@ -119,31 +140,31 @@ class STT(stt.STT):
         language: SpeechLanguages | str | None = None,
     ) -> stt.SpeechEvent:
         config = self._sanitize_options(language=language)
-        buffer = agents.utils.merge_frames(buffer)
+        frame = agents.utils.merge_frames(buffer)
 
         config = cloud_speech.RecognitionConfig(
             explicit_decoding_config=cloud_speech.ExplicitDecodingConfig(
                 encoding=cloud_speech.ExplicitDecodingConfig.AudioEncoding.LINEAR16,
-                sample_rate_hertz=buffer.sample_rate,
-                audio_channel_count=buffer.num_channels,
+                sample_rate_hertz=frame.sample_rate,
+                audio_channel_count=frame.num_channels,
             ),
             features=cloud_speech.RecognitionFeatures(
                 enable_automatic_punctuation=config.punctuate,
                 enable_spoken_punctuation=config.spoken_punctuation,
+                enable_word_time_offsets=True,
             ),
             model=config.model,
             language_codes=config.languages,
         )
 
-        return recognize_response_to_speech_event(
-            await self._client.recognize(
-                cloud_speech.RecognizeRequest(
-                    recognizer=self._recognizer,
-                    config=config,
-                    content=buffer.data.tobytes(),
-                )
+        raw = await self._ensure_client().recognize(
+            cloud_speech.RecognizeRequest(
+                recognizer=self._recognizer,
+                config=config,
+                content=frame.data.tobytes(),
             )
         )
+        return _recognize_response_to_speech_event(raw)
 
     def stream(
         self,
@@ -152,8 +173,7 @@ class STT(stt.STT):
     ) -> "SpeechStream":
         config = self._sanitize_options(language=language)
         return SpeechStream(
-            self._client,
-            self._creds,
+            self._ensure_client(),
             self._recognizer,
             config,
         )
@@ -163,29 +183,28 @@ class SpeechStream(stt.SpeechStream):
     def __init__(
         self,
         client: SpeechAsyncClient,
-        creds: credentials.Credentials,
         recognizer: str,
         config: STTOptions,
-        sample_rate: int = 24000,
+        sample_rate: int = 48000,
         num_channels: int = 1,
         max_retry: int = 32,
     ) -> None:
         super().__init__()
 
         self._client = client
-        self._creds = creds
         self._recognizer = recognizer
         self._config = config
         self._sample_rate = sample_rate
         self._num_channels = num_channels
 
-        self._queue = asyncio.Queue[rtc.AudioFrame | None]()
-        self._event_queue = asyncio.Queue[stt.SpeechEvent | None]()
+        self._queue = asyncio.Queue[Optional[rtc.AudioFrame]]()
+        self._event_queue = asyncio.Queue[Optional[stt.SpeechEvent]]()
         self._closed = False
         self._main_task = asyncio.create_task(self._run(max_retry=max_retry))
 
         self._final_events: List[stt.SpeechEvent] = []
-        self._speaking = False
+        self._need_bos = True
+        self._need_eos = False
 
         self._streaming_config = cloud_speech.StreamingRecognitionConfig(
             config=cloud_speech.RecognitionConfig(
@@ -198,6 +217,7 @@ class SpeechStream(stt.SpeechStream):
                 model=self._config.model,
                 features=cloud_speech.RecognitionFeatures(
                     enable_automatic_punctuation=self._config.punctuate,
+                    enable_word_time_offsets=True,
                 ),
             ),
             streaming_features=cloud_speech.StreamingRecognitionFeatures(
@@ -218,7 +238,7 @@ class SpeechStream(stt.SpeechStream):
 
         self._queue.put_nowait(frame)
 
-    async def aclose(self, wait: bool = True) -> None:
+    async def aclose(self, *, wait: bool = True) -> None:
         self._closed = True
         if not wait:
             self._main_task.cancel()
@@ -229,61 +249,55 @@ class SpeechStream(stt.SpeechStream):
 
     async def _run(self, max_retry: int) -> None:
         retry_count = 0
-        try:
-            while not self._closed:
-                try:
-                    # google requires a async generator when calling streaming_recognize
-                    # this function basically convert the queue into a async generator
-                    async def input_generator():
-                        try:
-                            # first request should contain the config
-                            yield cloud_speech.StreamingRecognizeRequest(
-                                recognizer=self._recognizer,
-                                streaming_config=self._streaming_config,
+        while not self._closed:
+            try:
+                # google requires a async generator when calling streaming_recognize
+                # this function basically convert the queue into a async generator
+                async def input_generator():
+                    try:
+                        # first request should contain the config
+                        yield cloud_speech.StreamingRecognizeRequest(
+                            recognizer=self._recognizer,
+                            streaming_config=self._streaming_config,
+                        )
+                        while True:
+                            frame = await self._queue.get()
+                            if frame is None:
+                                break
+
+                            frame = frame.remix_and_resample(
+                                self._sample_rate, self._num_channels
                             )
-                            while True:
-                                frame = (
-                                    await self._queue.get()
-                                )  # wait for a new rtc.AudioFrame
-                                if frame is None:
-                                    break  # None is sent inside aclose
-
-                                self._queue.task_done()
-                                frame = frame.remix_and_resample(
-                                    self._sample_rate, self._num_channels
-                                )
-                                yield cloud_speech.StreamingRecognizeRequest(
-                                    audio=frame.data.tobytes(),
-                                )
-                        except Exception as e:
-                            logger.error(
-                                f"an error occurred while streaming inputs: {e}"
+                            yield cloud_speech.StreamingRecognizeRequest(
+                                audio=frame.data.tobytes(),
                             )
+                    except Exception as e:
+                        logger.error(f"an error occurred while streaming inputs: {e}")
 
-                    # try to connect
-                    stream = await self._client.streaming_recognize(
-                        requests=input_generator()
-                    )
-                    retry_count = 0  # connection successful, reset retry count
-
-                    await self._run_stream(stream)
-                except Exception as e:
-                    if retry_count >= max_retry:
-                        logger.error(
-                            f"failed to connect to google stt after {max_retry} tries",
-                            exc_info=e,
-                        )
-                        break
+                # try to connect
+                stream = await self._client.streaming_recognize(
+                    requests=input_generator()
+                )
+                retry_count = 0  # connection successful, reset retry count
 
-                    retry_delay = min(retry_count * 2, 10)  # max 10s
-                    retry_count += 1
-                    logger.warning(
-                        f"google stt connection failed, retrying in {retry_delay}s",
+                await self._run_stream(stream)
+            except Exception as e:
+                if retry_count >= max_retry:
+                    logger.error(
+                        f"failed to connect to google stt after {max_retry} tries",
                         exc_info=e,
                     )
-                    await asyncio.sleep(retry_delay)
-        finally:
-            self._event_queue.put_nowait(None)
+                    break
+
+                retry_delay = min(retry_count * 2, 5)  # max 5s
+                retry_count += 1
+                logger.warning(
+                    f"google stt connection failed, retrying in {retry_delay}s",
+                    exc_info=e,
+                )
+                await asyncio.sleep(retry_delay)
+
+        self._event_queue.put_nowait(None)
 
     async def _run_stream(
         self, stream: AsyncIterable[cloud_speech.StreamingRecognizeResponse]
@@ -293,11 +307,11 @@ class SpeechStream(stt.SpeechStream):
                 resp.speech_event_type
                 == cloud_speech.StreamingRecognizeResponse.SpeechEventType.SPEECH_ACTIVITY_BEGIN
             ):
-                self._speaking = True
-                start_event = stt.SpeechEvent(
-                    type=stt.SpeechEventType.START_OF_SPEECH,
-                )
-                self._event_queue.put_nowait(start_event)
+                if self._need_eos:
+                    self._send_eos()
+
+            if self._need_bos:
+                self._send_bos()
 
             if (
                 resp.speech_event_type
@@ -305,57 +319,89 @@ class SpeechStream(stt.SpeechStream):
             ):
                 result = resp.results[0]
                 if not result.is_final:
-                    # interim results
                     iterim_event = stt.SpeechEvent(
                         type=stt.SpeechEventType.INTERIM_TRANSCRIPT,
-                        alternatives=streaming_recognize_response_to_speech_data(resp),
+                        alternatives=[
+                            _streaming_recognize_response_to_speech_data(resp)
+                        ],
                     )
                     self._event_queue.put_nowait(iterim_event)
 
                 else:
                     final_event = stt.SpeechEvent(
                         type=stt.SpeechEventType.FINAL_TRANSCRIPT,
-                        alternatives=streaming_recognize_response_to_speech_data(resp),
+                        alternatives=[
+                            _streaming_recognize_response_to_speech_data(resp)
+                        ],
                     )
                     self._final_events.append(final_event)
                     self._event_queue.put_nowait(final_event)
 
-                    if not self._speaking:
-                        # With Google STT, we receive the final event after the END_OF_SPEECH event
-                        sentence = ""
-                        confidence = 0.0
-                        for alt in self._final_events:
-                            sentence += f"{alt.alternatives[0].text.strip()} "
-                            confidence += alt.alternatives[0].confidence
-
-                        sentence = sentence.rstrip()
-                        confidence /= len(self._final_events)  # avg. of confidence
-
-                        end_event = stt.SpeechEvent(
-                            type=stt.SpeechEventType.END_OF_SPEECH,
-                            alternatives=[
-                                stt.SpeechData(
-                                    language=result.language_code,
-                                    start_time=self._final_events[0]
-                                    .alternatives[0]
-                                    .start_time,
-                                    end_time=self._final_events[-1]
-                                    .alternatives[0]
-                                    .end_time,
-                                    confidence=confidence,
-                                    text=sentence,
-                                )
-                            ],
-                        )
-
-                        self._final_events = []
-                        self._event_queue.put_nowait(end_event)
+            if self._need_eos:
+                self._send_eos()
 
             if (
                 resp.speech_event_type
                 == cloud_speech.StreamingRecognizeResponse.SpeechEventType.SPEECH_ACTIVITY_END
             ):
-                self._speaking = False
+                self._need_eos = True
+
+        if not self._need_bos:
+            self._send_eos()
+
+    def _send_bos(self) -> None:
+        self._need_bos = False
+        start_event = stt.SpeechEvent(
+            type=stt.SpeechEventType.START_OF_SPEECH,
+        )
+        self._event_queue.put_nowait(start_event)
+
+    def _send_eos(self) -> None:
+        self._need_eos = False
+        self._need_bos = True
+
+        if self._final_events:
+            lg = self._final_events[0].alternatives[0].language
+
+            sentence = ""
+            confidence = 0.0
+            for alt in self._final_events:
+                sentence += f"{alt.alternatives[0].text.strip()} "
+                confidence += alt.alternatives[0].confidence
+
+            sentence = sentence.rstrip()
+            confidence /= len(self._final_events)  # avg. of confidence
+
+            end_event = stt.SpeechEvent(
+                type=stt.SpeechEventType.END_OF_SPEECH,
+                alternatives=[
+                    stt.SpeechData(
+                        language=lg,
+                        start_time=self._final_events[0].alternatives[0].start_time,
+                        end_time=self._final_events[-1].alternatives[0].end_time,
+                        confidence=confidence,
+                        text=sentence,
+                    )
+                ],
+            )
+
+            self._final_events = []
+            self._event_queue.put_nowait(end_event)
+        else:
+            end_event = stt.SpeechEvent(
+                type=stt.SpeechEventType.END_OF_SPEECH,
+                alternatives=[
+                    stt.SpeechData(
+                        language="",
+                        start_time=0,
+                        end_time=0,
+                        confidence=0,
+                        text="",
+                    )
+                ],
+            )
+
+            self._event_queue.put_nowait(end_event)
 
     async def __anext__(self) -> stt.SpeechEvent:
         evt = await self._event_queue.get()
@@ -365,38 +411,53 @@ class SpeechStream(stt.SpeechStream):
         return evt
 
 
-def recognize_response_to_speech_event(
+def _recognize_response_to_speech_event(
     resp: cloud_speech.RecognizeResponse,
 ) -> stt.SpeechEvent:
-    result = resp.results[0]
-    gg_alts = result.alternatives
+    text = ""
+    confidence = 0.0
+    for result in resp.results:
+        text += result.alternatives[0].transcript
+        confidence += result.alternatives[0].confidence
+
+    # not sure why start_offset and end_offset returns a timedelta
+    start_offset = resp.results[0].alternatives[0].words[0].start_offset
+    end_offset = resp.results[-1].alternatives[0].words[-1].end_offset
+
+    confidence /= len(resp.results)
+    lg = resp.results[0].language_code
     return stt.SpeechEvent(
         type=stt.SpeechEventType.FINAL_TRANSCRIPT,
         alternatives=[
             stt.SpeechData(
-                language=result.language_code,
-                start_time=alt.words[0].start_offset.seconds if alt.words else 0,
-                end_time=alt.words[-1].end_offset.seconds if alt.words else 0,
-                confidence=alt.confidence,
-                text=alt.transcript,
+                language=lg,
+                start_time=start_offset.total_seconds(),  # type: ignore
+                end_time=end_offset.total_seconds(),  # type: ignore
+                confidence=confidence,
+                text=text,
             )
-            for alt in gg_alts
         ],
     )
 
 
-def streaming_recognize_response_to_speech_data(
+def _streaming_recognize_response_to_speech_data(
     resp: cloud_speech.StreamingRecognizeResponse,
-) -> List[stt.SpeechData]:
-    result = resp.results[0]
-    gg_alts = result.alternatives
-    return [
-        stt.SpeechData(
-            language=result.language_code,
-            start_time=alt.words[0].start_offset.seconds if alt.words else 0,
-            end_time=alt.words[-1].end_offset.seconds if alt.words else 0,
-            confidence=alt.confidence,
-            text=alt.transcript,
-        )
-        for alt in gg_alts
-    ]
+) -> stt.SpeechData:
+    text = ""
+    confidence = 0.0
+    for result in resp.results:
+        text += result.alternatives[0].transcript
+        confidence += result.alternatives[0].confidence
+
+    confidence /= len(resp.results)
+    lg = resp.results[0].language_code
+
+    data = stt.SpeechData(
+        language=lg,
+        start_time=0,
+        end_time=0,
+        confidence=confidence,
+        text=text,
+    )
+
+    return data

livekit/plugins/google/tts.py

@@ -0,0 +1,186 @@
+# Copyright 2023 LiveKit, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+import asyncio
+import contextlib
+from dataclasses import dataclass
+from typing import Optional, Union
+
+from livekit import rtc
+from livekit.agents import codecs, tts
+
+from google.cloud import texttospeech
+from google.cloud.texttospeech_v1.types import (
+    SsmlVoiceGender,
+    SynthesizeSpeechResponse,
+)
+
+from .log import logger
+from .models import AudioEncoding, Gender, SpeechLanguages
+
+LgType = Union[SpeechLanguages, str]
+GenderType = Union[Gender, str]
+AudioEncodingType = Union[AudioEncoding, str]
+
+
+@dataclass
+class _TTSOptions:
+    voice: texttospeech.VoiceSelectionParams
+    audio_config: texttospeech.AudioConfig
+
+
+class TTS(tts.TTS):
+    def __init__(
+        self,
+        *,
+        language: LgType = "en-US",
+        gender: GenderType = "neutral",
+        voice_name: str = "",  # Not required
+        encoding: AudioEncodingType = "linear16",
+        sample_rate: int = 24000,
+        speaking_rate: float = 1.0,
+        credentials_info: dict | None = None,
+        credentials_file: str | None = None,
+    ) -> None:
+        """
+        if no credentials is provided, it will use the credentials on the environment
+        GOOGLE_APPLICATION_CREDENTIALS (default behavior of Google TextToSpeechAsyncClient)
+        """
+        super().__init__(
+            streaming_supported=False, sample_rate=sample_rate, num_channels=1
+        )
+
+        self._client: texttospeech.TextToSpeechAsyncClient | None = None
+        self._credentials_info = credentials_info
+        self._credentials_file = credentials_file
+
+        ssml_gender = SsmlVoiceGender.NEUTRAL
+        if gender == "male":
+            ssml_gender = SsmlVoiceGender.MALE
+        elif gender == "female":
+            ssml_gender = SsmlVoiceGender.FEMALE
+
+        voice = texttospeech.VoiceSelectionParams(
+            name=voice_name,
+            language_code=language,
+            ssml_gender=ssml_gender,
+        )
+
+        if encoding == "linear16" or encoding == "wav":
+            _audio_encoding = texttospeech.AudioEncoding.LINEAR16
+        elif encoding == "mp3":
+            _audio_encoding = texttospeech.AudioEncoding.MP3
+        else:
+            raise NotImplementedError(f"audio encoding {encoding} is not supported")
+
+        self._opts = _TTSOptions(
+            voice=voice,
+            audio_config=texttospeech.AudioConfig(
+                audio_encoding=_audio_encoding,
+                sample_rate_hertz=sample_rate,
+                speaking_rate=speaking_rate,
+            ),
+        )
+
+    def _ensure_client(self) -> texttospeech.TextToSpeechAsyncClient:
+        if not self._client:
+            if self._credentials_info:
+                self._client = (
+                    texttospeech.TextToSpeechAsyncClient.from_service_account_info(
+                        self._credentials_info
+                    )
+                )
+
+            elif self._credentials_file:
+                self._client = (
+                    texttospeech.TextToSpeechAsyncClient.from_service_account_file(
+                        self._credentials_file
+                    )
+                )
+            else:
+                self._client = texttospeech.TextToSpeechAsyncClient()
+
+        assert self._client is not None
+        return self._client
+
+    def synthesize(
+        self,
+        text: str,
+    ) -> "ChunkedStream":
+        return ChunkedStream(text, self._opts, self._ensure_client())
+
+
+class ChunkedStream(tts.ChunkedStream):
+    def __init__(
+        self, text: str, opts: _TTSOptions, client: texttospeech.TextToSpeechAsyncClient
+    ) -> None:
+        self._text = text
+        self._opts = opts
+        self._client = client
+        self._main_task: asyncio.Task | None = None
+        self._queue = asyncio.Queue[Optional[tts.SynthesizedAudio]]()
+
+    async def _run(self) -> None:
+        try:
+            response: SynthesizeSpeechResponse = await self._client.synthesize_speech(
+                input=texttospeech.SynthesisInput(text=self._text),
+                voice=self._opts.voice,
+                audio_config=self._opts.audio_config,
+            )
+
+            data = response.audio_content
+            if self._opts.audio_config.audio_encoding == "mp3":
+                decoder = codecs.Mp3StreamDecoder()
+                frames = decoder.decode_chunk(data)
+                for frame in frames:
+                    self._queue.put_nowait(
+                        tts.SynthesizedAudio(text=self._text, data=frame)
+                    )
+            else:
+                self._queue.put_nowait(
+                    tts.SynthesizedAudio(
+                        text="",
+                        data=rtc.AudioFrame(
+                            data=data,
+                            sample_rate=self._opts.audio_config.sample_rate_hertz,
+                            num_channels=1,
+                            samples_per_channel=len(data) // 2,  # 16-bit
+                        ),
+                    )
+                )
+
+        except Exception:
+            logger.exception("failed to synthesize")
+        finally:
+            self._queue.put_nowait(None)
+
+    async def __anext__(self) -> tts.SynthesizedAudio:
+        if not self._main_task:
+            self._main_task = asyncio.create_task(self._run())
+
+        frame = await self._queue.get()
+        if frame is None:
+            raise StopAsyncIteration
+
+        return frame
+
+    async def aclose(self) -> None:
+        if not self._main_task:
+            return
+
+        self._main_task.cancel()
+        with contextlib.suppress(asyncio.CancelledError):
+            await self._main_task

livekit/plugins/google/version.py

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

{livekit_plugins_google-0.4.dev0.dist-info → livekit_plugins_google-0.5.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: livekit-plugins-google
-Version: 0.4.dev0
+Version: 0.5.0
 Summary: Agent Framework plugin for services from Google Cloud
 Home-page: https://github.com/livekit/agents
 License: Apache-2.0
@@ -30,7 +30,7 @@ Requires-Dist: google-cloud-texttospeech <3,>=2
 Requires-Dist: google-cloud-translate <4,>=3
 Requires-Dist: googleapis-common-protos <2,>=1
 Requires-Dist: livekit ~=0.11
-Requires-Dist: livekit-agents ~=0.6.dev0
+Requires-Dist: livekit-agents ~=0.7.0
 
 # LiveKit Plugins Google
 

livekit_plugins_google-0.5.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+livekit/plugins/google/__init__.py,sha256=DlQC5cosMFyQlM8_vFvJGoZiziFkd0Sa4mutnsxXyZM,959
+livekit/plugins/google/log.py,sha256=GI3YWN5YzrafnUccljzPRS_ZALkMNk1i21IRnTl2vNA,69
+livekit/plugins/google/models.py,sha256=n8pgTJ7xyJpPCZJ_y0GzaQq6LqYknL6K6trpi07-AxM,1307
+livekit/plugins/google/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+livekit/plugins/google/stt.py,sha256=GfWita3mgLZG2KpS9WYMCL8jwCNN5qukicpI58zPCcY,16058
+livekit/plugins/google/tts.py,sha256=J3V5aDUz0V2_Dfs16pobDVx7XwQqU1AEM8TWXdaDn9w,6182
+livekit/plugins/google/version.py,sha256=pZ7bgeWLjw4VCWymU1ntHaHorKRusUkm56y6tZe5gmQ,600
+livekit_plugins_google-0.5.0.dist-info/METADATA,sha256=Hf7P77h8fLEnGsNj4rUdSA_mSL4sCv5pMktzPoTsCbk,1941
+livekit_plugins_google-0.5.0.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+livekit_plugins_google-0.5.0.dist-info/top_level.txt,sha256=OoDok3xUmXbZRvOrfvvXB-Juu4DX79dlq188E19YHoo,8
+livekit_plugins_google-0.5.0.dist-info/RECORD,,

livekit_plugins_google-0.4.dev0.dist-info/RECORD

@@ -1,10 +0,0 @@
-livekit/plugins/google/__init__.py,sha256=snPMHNLrurYbLWQOkV_o6qG1CEWsOCZ8ZfPMvmh5ejY,931
-livekit/plugins/google/log.py,sha256=GI3YWN5YzrafnUccljzPRS_ZALkMNk1i21IRnTl2vNA,69
-livekit/plugins/google/models.py,sha256=DgiXOvGDO8D9rfCKHJL28lbyQR8mXXB2kpku-szXLRs,1185
-livekit/plugins/google/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-livekit/plugins/google/stt.py,sha256=sPV4ByAxfeGBNvAGIuwZvheEA0k7NYjXR_UiYWjd39Y,15029
-livekit/plugins/google/version.py,sha256=OwSbVTqWUJKy9w2Jbh1MIrp5cHPvEYsLXDhRGwdZKso,603
-livekit_plugins_google-0.4.dev0.dist-info/METADATA,sha256=i4l7y8p0Y57kK5oPQqF-8lp9SFvPL0nDVsuDkktHJN4,1947
-livekit_plugins_google-0.4.dev0.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-livekit_plugins_google-0.4.dev0.dist-info/top_level.txt,sha256=OoDok3xUmXbZRvOrfvvXB-Juu4DX79dlq188E19YHoo,8
-livekit_plugins_google-0.4.dev0.dist-info/RECORD,,