livekit-plugins-aws 1.0.0rc6__tar.gz → 1.0.0rc7__tar.gz

{livekit_plugins_aws-1.0.0rc6 → livekit_plugins_aws-1.0.0rc7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: livekit-plugins-aws
-Version: 1.0.0rc6
+Version: 1.0.0rc7
 Summary: LiveKit Agents Plugin for services from AWS
 Project-URL: Documentation, https://docs.livekit.io
 Project-URL: Website, https://livekit.io/
@@ -18,10 +18,10 @@ Classifier: Topic :: Multimedia :: Sound/Audio
 Classifier: Topic :: Multimedia :: Video
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Requires-Python: >=3.9.0
-Requires-Dist: aiobotocore==2.19.0
-Requires-Dist: amazon-transcribe>=0.6.2
-Requires-Dist: boto3==1.36.3
-Requires-Dist: livekit-agents>=1.0.0.rc6
+Requires-Dist: aioboto3==14.1.0
+Requires-Dist: amazon-transcribe==0.6.2
+Requires-Dist: boto3==1.37.1
+Requires-Dist: livekit-agents>=1.0.0.rc7
 Description-Content-Type: text/markdown
 
 # LiveKit Plugins AWS

{livekit_plugins_aws-1.0.0rc6 → livekit_plugins_aws-1.0.0rc7}/livekit/plugins/aws/llm.py

@@ -14,12 +14,11 @@
 # limitations under the License.
 from __future__ import annotations
 
-import asyncio
 import os
 from dataclasses import dataclass
 from typing import Any, Literal
 
-import boto3
+import aioboto3
 
 from livekit.agents import APIConnectionError, APIStatusError, llm
 from livekit.agents.llm import ChatContext, FunctionTool, FunctionToolCall, ToolChoice
@@ -32,7 +31,7 @@ from livekit.agents.types import (
 from livekit.agents.utils import is_given
 
 from .log import logger
-from .utils import get_aws_credentials, to_chat_ctx, to_fnc_ctx
+from .utils import get_aws_async_session, to_chat_ctx, to_fnc_ctx
 
 TEXT_MODEL = Literal["anthropic.claude-3-5-sonnet-20241022-v2:0"]
 
@@ -60,6 +59,7 @@ class LLM(llm.LLM):
         top_p: NotGivenOr[float] = NOT_GIVEN,
         tool_choice: NotGivenOr[ToolChoice] = NOT_GIVEN,
         additional_request_fields: NotGivenOr[dict[str, Any]] = NOT_GIVEN,
+        session: aioboto3.Session | None = None,
     ) -> None:
         """
         Create a new instance of AWS Bedrock LLM.
@@ -79,10 +79,14 @@ class LLM(llm.LLM):
             top_p (float, optional): The nucleus sampling probability for response generation. Defaults to None.
             tool_choice (ToolChoice, optional): Specifies whether to use tools during response generation. Defaults to "auto".
             additional_request_fields (dict[str, Any], optional): Additional request fields to send to the AWS Bedrock Converse API. Defaults to None.
+            session (aioboto3.Session, optional): Optional aioboto3 session to use.
         """  # noqa: E501
         super().__init__()
-        self._api_key, self._api_secret, self._region = get_aws_credentials(
-            api_key, api_secret, region
+
+        self._session = session or get_aws_async_session(
+            api_key=api_key if is_given(api_key) else None,
+            api_secret=api_secret if is_given(api_secret) else None,
+            region=region if is_given(region) else None,
         )
 
         model = model if is_given(model) else os.environ.get("BEDROCK_INFERENCE_PROFILE_ARN")
@@ -156,11 +160,9 @@ class LLM(llm.LLM):
 
         return LLMStream(
             self,
-            aws_access_key_id=self._api_key,
-            aws_secret_access_key=self._api_secret,
-            region_name=self._region,
             chat_ctx=chat_ctx,
             tools=tools,
+            session=self._session,
             conn_options=conn_options,
             extra_kwargs=opts,
         )
@@ -171,24 +173,16 @@ class LLMStream(llm.LLMStream):
         self,
         llm: LLM,
         *,
-        aws_access_key_id: str,
-        aws_secret_access_key: str,
-        region_name: str,
         chat_ctx: ChatContext,
+        session: aioboto3.Session,
         conn_options: APIConnectOptions,
         tools: list[FunctionTool] | None,
         extra_kwargs: dict[str, Any],
     ) -> None:
         super().__init__(llm, chat_ctx=chat_ctx, tools=tools, conn_options=conn_options)
-        self._client = boto3.client(
-            "bedrock-runtime",
-            region_name=region_name,
-            aws_access_key_id=aws_access_key_id,
-            aws_secret_access_key=aws_secret_access_key,
-        )
         self._llm: LLM = llm
         self._opts = extra_kwargs
-
+        self._session = session
         self._tool_call_id: str | None = None
         self._fnc_name: str | None = None
         self._fnc_raw_arguments: str | None = None
@@ -197,23 +191,21 @@ class LLMStream(llm.LLMStream):
     async def _run(self) -> None:
         retryable = True
         try:
-            response = self._client.converse_stream(**self._opts)  # type: ignore
-            request_id = response["ResponseMetadata"]["RequestId"]
-            if response["ResponseMetadata"]["HTTPStatusCode"] != 200:
-                raise APIStatusError(
-                    f"aws bedrock llm: error generating content: {response}",
-                    retryable=False,
-                    request_id=request_id,
-                )
-
-            for chunk in response["stream"]:
-                chat_chunk = self._parse_chunk(request_id, chunk)
-                if chat_chunk is not None:
-                    retryable = False
-                    self._event_ch.send_nowait(chat_chunk)
-
-                # Let other coroutines run
-                await asyncio.sleep(0)
+            async with self._session.client("bedrock-runtime") as client:
+                response = await client.converse_stream(**self._opts)  # type: ignore
+                request_id = response["ResponseMetadata"]["RequestId"]
+                if response["ResponseMetadata"]["HTTPStatusCode"] != 200:
+                    raise APIStatusError(
+                        f"aws bedrock llm: error generating content: {response}",
+                        retryable=False,
+                        request_id=request_id,
+                    )
+
+                async for chunk in response["stream"]:
+                    chat_chunk = self._parse_chunk(request_id, chunk)
+                    if chat_chunk is not None:
+                        retryable = False
+                        self._event_ch.send_nowait(chat_chunk)
 
         except Exception as e:
             raise APIConnectionError(
@@ -233,12 +225,17 @@ class LLMStream(llm.LLMStream):
             if "toolUse" in delta:
                 self._fnc_raw_arguments += delta["toolUse"]["input"]
             elif "text" in delta:
-                self._text += delta["text"]
+                return llm.ChatChunk(
+                    id=request_id,
+                    delta=llm.ChoiceDelta(content=delta["text"], role="assistant"),
+                )
+            else:
+                logger.warning(f"aws bedrock llm: unknown chunk type: {chunk}")
 
         elif "metadata" in chunk:
             metadata = chunk["metadata"]
             return llm.ChatChunk(
-                request_id=request_id,
+                id=request_id,
                 usage=llm.CompletionUsage(
                     completion_tokens=metadata["usage"]["outputTokens"],
                     prompt_tokens=metadata["usage"]["inputTokens"],
@@ -246,14 +243,7 @@ class LLMStream(llm.LLMStream):
                 ),
             )
         elif "contentBlockStop" in chunk:
-            if self._text:
-                chat_chunk = llm.ChatChunk(
-                    id=request_id,
-                    delta=llm.ChoiceDelta(content=self._text, role="assistant"),
-                )
-                self._text = ""
-                return chat_chunk
-            elif self._tool_call_id:
+            if self._tool_call_id:
                 if self._tool_call_id is None:
                     logger.warning("aws bedrock llm: no tool call id in the response")
                     return None

{livekit_plugins_aws-1.0.0rc6 → livekit_plugins_aws-1.0.0rc7}/livekit/plugins/aws/stt.py

@@ -15,6 +15,8 @@ from __future__ import annotations
 import asyncio
 from dataclasses import dataclass
 
+import aioboto3
+from amazon_transcribe.auth import StaticCredentialResolver
 from amazon_transcribe.client import TranscribeStreamingClient
 from amazon_transcribe.model import Result, TranscriptEvent
 
@@ -24,12 +26,13 @@ from livekit.agents.types import NOT_GIVEN, NotGivenOr
 from livekit.agents.utils import is_given
 
 from .log import logger
-from .utils import get_aws_credentials
+from .utils import DEFAULT_REGION, get_aws_async_session
+
+REFRESH_INTERVAL = 1800
 
 
 @dataclass
 class STTOptions:
-    speech_region: str
     sample_rate: int
     language: str
     encoding: str
@@ -49,7 +52,7 @@ class STT(stt.STT):
     def __init__(
         self,
         *,
-        speech_region: str = "us-east-1",
+        region: NotGivenOr[str] = NOT_GIVEN,
         api_key: NotGivenOr[str] = NOT_GIVEN,
         api_secret: NotGivenOr[str] = NOT_GIVEN,
         sample_rate: int = 48000,
@@ -65,14 +68,18 @@ class STT(stt.STT):
         enable_partial_results_stabilization: NotGivenOr[bool] = NOT_GIVEN,
         partial_results_stability: NotGivenOr[str] = NOT_GIVEN,
         language_model_name: NotGivenOr[str] = NOT_GIVEN,
+        session: aioboto3.Session | None = None,
+        refresh_interval: NotGivenOr[int] = NOT_GIVEN,
     ):
         super().__init__(capabilities=stt.STTCapabilities(streaming=True, interim_results=True))
-
-        self._api_key, self._api_secret, self._speech_region = get_aws_credentials(
-            api_key, api_secret, speech_region
+        self._region = region if is_given(region) else DEFAULT_REGION
+        self._session = session or get_aws_async_session(
+            api_key=api_key if is_given(api_key) else None,
+            api_secret=api_secret if is_given(api_secret) else None,
+            region=self._region,
         )
+
         self._config = STTOptions(
-            speech_region=self._speech_region,
             language=language,
             sample_rate=sample_rate,
             encoding=encoding,
@@ -87,6 +94,28 @@ class STT(stt.STT):
             partial_results_stability=partial_results_stability,
             language_model_name=language_model_name,
         )
+        self._pool = utils.ConnectionPool[TranscribeStreamingClient](
+            connect_cb=self._create_client,
+            max_session_duration=refresh_interval
+            if is_given(refresh_interval)
+            else REFRESH_INTERVAL,
+        )
+
+    async def _create_client(self) -> TranscribeStreamingClient:
+        creds = await self._session.get_credentials()
+        frozen_credentials = await creds.get_frozen_credentials()
+        return TranscribeStreamingClient(
+            region=self._region,
+            credential_resolver=StaticCredentialResolver(
+                access_key_id=frozen_credentials.access_key,
+                secret_access_key=frozen_credentials.secret_key,
+                session_token=frozen_credentials.token,
+            ),
+        )
+
+    async def aclose(self) -> None:
+        await self._pool.aclose()
+        await super().aclose()
 
     async def _recognize_impl(
         self,
@@ -105,6 +134,7 @@ class STT(stt.STT):
     ) -> SpeechStream:
         return SpeechStream(
             stt=self,
+            pool=self._pool,
             conn_options=conn_options,
             opts=self._config,
         )
@@ -115,52 +145,54 @@ class SpeechStream(stt.SpeechStream):
         self,
         stt: STT,
         opts: STTOptions,
+        pool: utils.ConnectionPool[TranscribeStreamingClient],
         conn_options: APIConnectOptions = DEFAULT_API_CONNECT_OPTIONS,
     ) -> None:
         super().__init__(stt=stt, conn_options=conn_options, sample_rate=opts.sample_rate)
         self._opts = opts
-        self._client = TranscribeStreamingClient(region=self._opts.speech_region)
+        self._pool = pool
 
     async def _run(self) -> None:
-        live_config = {
-            "language_code": self._opts.language,
-            "media_sample_rate_hz": self._opts.sample_rate,
-            "media_encoding": self._opts.encoding,
-            "vocabulary_name": self._opts.vocabulary_name,
-            "session_id": self._opts.session_id,
-            "vocab_filter_method": self._opts.vocab_filter_method,
-            "vocab_filter_name": self._opts.vocab_filter_name,
-            "show_speaker_label": self._opts.show_speaker_label,
-            "enable_channel_identification": self._opts.enable_channel_identification,
-            "number_of_channels": self._opts.number_of_channels,
-            "enable_partial_results_stabilization": self._opts.enable_partial_results_stabilization,
-            "partial_results_stability": self._opts.partial_results_stability,
-            "language_model_name": self._opts.language_model_name,
-        }
-        filtered_config = {k: v for k, v in live_config.items() if is_given(v)}
-        stream = await self._client.start_stream_transcription(**filtered_config)
-
-        @utils.log_exceptions(logger=logger)
-        async def input_generator():
-            async for frame in self._input_ch:
-                if isinstance(frame, rtc.AudioFrame):
-                    await stream.input_stream.send_audio_event(audio_chunk=frame.data.tobytes())
-            await stream.input_stream.end_stream()
-
-        @utils.log_exceptions(logger=logger)
-        async def handle_transcript_events():
-            async for event in stream.output_stream:
-                if isinstance(event, TranscriptEvent):
-                    self._process_transcript_event(event)
-
-        tasks = [
-            asyncio.create_task(input_generator()),
-            asyncio.create_task(handle_transcript_events()),
-        ]
-        try:
-            await asyncio.gather(*tasks)
-        finally:
-            await utils.aio.gracefully_cancel(*tasks)
+        async with self._pool.connection() as client:
+            live_config = {
+                "language_code": self._opts.language,
+                "media_sample_rate_hz": self._opts.sample_rate,
+                "media_encoding": self._opts.encoding,
+                "vocabulary_name": self._opts.vocabulary_name,
+                "session_id": self._opts.session_id,
+                "vocab_filter_method": self._opts.vocab_filter_method,
+                "vocab_filter_name": self._opts.vocab_filter_name,
+                "show_speaker_label": self._opts.show_speaker_label,
+                "enable_channel_identification": self._opts.enable_channel_identification,
+                "number_of_channels": self._opts.number_of_channels,
+                "enable_partial_results_stabilization": self._opts.enable_partial_results_stabilization,  # noqa: E501
+                "partial_results_stability": self._opts.partial_results_stability,
+                "language_model_name": self._opts.language_model_name,
+            }
+            filtered_config = {k: v for k, v in live_config.items() if v and is_given(v)}
+            stream = await client.start_stream_transcription(**filtered_config)
+
+            @utils.log_exceptions(logger=logger)
+            async def input_generator():
+                async for frame in self._input_ch:
+                    if isinstance(frame, rtc.AudioFrame):
+                        await stream.input_stream.send_audio_event(audio_chunk=frame.data.tobytes())
+                await stream.input_stream.end_stream()
+
+            @utils.log_exceptions(logger=logger)
+            async def handle_transcript_events():
+                async for event in stream.output_stream:
+                    if isinstance(event, TranscriptEvent):
+                        self._process_transcript_event(event)
+
+            tasks = [
+                asyncio.create_task(input_generator()),
+                asyncio.create_task(handle_transcript_events()),
+            ]
+            try:
+                await asyncio.gather(*tasks)
+            finally:
+                await utils.aio.gracefully_cancel(*tasks)
 
     def _process_transcript_event(self, transcript_event: TranscriptEvent):
         stream = transcript_event.transcript.results
@@ -196,7 +228,6 @@ def _streaming_recognize_response_to_speech_data(resp: Result) -> stt.SpeechData
         language="en-US",
         start_time=resp.start_time if resp.start_time else 0.0,
         end_time=resp.end_time if resp.end_time else 0.0,
-        confidence=0.0,
         text=resp.alternatives[0].transcript if resp.alternatives else "",
     )
 

{livekit_plugins_aws-1.0.0rc6 → livekit_plugins_aws-1.0.0rc7}/livekit/plugins/aws/tts.py

@@ -14,10 +14,9 @@ from __future__ import annotations
 
 import asyncio
 from dataclasses import dataclass
-from typing import Any, Callable
 
+import aioboto3
 import aiohttp
-from aiobotocore.session import AioSession, get_session
 
 from livekit.agents import (
     APIConnectionError,
@@ -35,11 +34,10 @@ from livekit.agents.types import (
 from livekit.agents.utils import is_given
 
 from .models import TTS_LANGUAGE, TTS_SPEECH_ENGINE
-from .utils import _strip_nones, get_aws_credentials
+from .utils import _strip_nones, get_aws_async_session
 
 TTS_NUM_CHANNELS: int = 1
 DEFAULT_SPEECH_ENGINE: TTS_SPEECH_ENGINE = "generative"
-DEFAULT_SPEECH_REGION = "us-east-1"
 DEFAULT_VOICE = "Ruth"
 DEFAULT_SAMPLE_RATE = 16000
 
@@ -49,7 +47,7 @@ class _TTSOptions:
     # https://docs.aws.amazon.com/polly/latest/dg/API_SynthesizeSpeech.html
     voice: NotGivenOr[str]
     speech_engine: NotGivenOr[TTS_SPEECH_ENGINE]
-    speech_region: str
+    region: str
     sample_rate: int
     language: NotGivenOr[TTS_LANGUAGE | str]
 
@@ -62,10 +60,10 @@ class TTS(tts.TTS):
         language: NotGivenOr[TTS_LANGUAGE | str] = NOT_GIVEN,
         speech_engine: NotGivenOr[TTS_SPEECH_ENGINE] = NOT_GIVEN,
         sample_rate: int = DEFAULT_SAMPLE_RATE,
-        speech_region: NotGivenOr[str] = DEFAULT_SPEECH_REGION,
+        region: NotGivenOr[str] = NOT_GIVEN,
         api_key: NotGivenOr[str] = NOT_GIVEN,
         api_secret: NotGivenOr[str] = NOT_GIVEN,
-        session: AioSession | None = None,
+        session: aioboto3.Session | None = None,
     ) -> None:
         """
         Create a new instance of AWS Polly TTS.
@@ -80,9 +78,10 @@ class TTS(tts.TTS):
             language (TTS_LANGUAGE, optional): language code for the Synthesize Speech request. This is only necessary if using a bilingual voice, such as Aditi, which can be used for either Indian English (en-IN) or Hindi (hi-IN).
             sample_rate(int, optional): The audio frequency specified in Hz. Defaults to 16000.
             speech_engine(TTS_SPEECH_ENGINE, optional): The engine to use for the synthesis. Defaults to "generative".
-            speech_region(str, optional): The region to use for the synthesis. Defaults to "us-east-1".
+            region(str, optional): The region to use for the synthesis. Defaults to "us-east-1".
             api_key(str, optional): AWS access key id.
             api_secret(str, optional): AWS secret access key.
+            session(aioboto3.Session, optional): Optional aioboto3 session to use.
         """  # noqa: E501
         super().__init__(
             capabilities=tts.TTSCapabilities(
@@ -91,27 +90,18 @@ class TTS(tts.TTS):
             sample_rate=sample_rate,
             num_channels=TTS_NUM_CHANNELS,
         )
-
-        self._api_key, self._api_secret, self._speech_region = get_aws_credentials(
-            api_key, api_secret, speech_region
+        self._session = session or get_aws_async_session(
+            api_key=api_key if is_given(api_key) else None,
+            api_secret=api_secret if is_given(api_secret) else None,
+            region=region if is_given(region) else None,
         )
-
         self._opts = _TTSOptions(
             voice=voice,
             speech_engine=speech_engine,
-            speech_region=self._speech_region,
+            region=region,
             language=language,
             sample_rate=sample_rate,
         )
-        self._session = session or get_session()
-
-    def _get_client(self):
-        return self._session.create_client(
-            "polly",
-            region_name=self._opts.speech_region,
-            aws_access_key_id=self._api_key,
-            aws_secret_access_key=self._api_secret,
-        )
 
     def synthesize(
         self,
@@ -123,8 +113,8 @@ class TTS(tts.TTS):
             tts=self,
             text=text,
             conn_options=conn_options,
+            session=self._session,
             opts=self._opts,
-            get_client=self._get_client,
         )
 
 
@@ -134,20 +124,20 @@ class ChunkedStream(tts.ChunkedStream):
         *,
         tts: TTS,
         text: str,
+        session: aioboto3.Session,
         conn_options: APIConnectOptions = DEFAULT_API_CONNECT_OPTIONS,
         opts: _TTSOptions,
-        get_client: Callable[[], Any],
     ) -> None:
         super().__init__(tts=tts, input_text=text, conn_options=conn_options)
         self._opts = opts
-        self._get_client = get_client
         self._segment_id = utils.shortuuid()
+        self._session = session
 
     async def _run(self):
         request_id = utils.shortuuid()
 
         try:
-            async with self._get_client() as client:
+            async with self._session.client("polly") as client:
                 params = {
                     "Text": self._input_text,
                     "OutputFormat": "mp3",

{livekit_plugins_aws-1.0.0rc6 → livekit_plugins_aws-1.0.0rc7}/livekit/plugins/aws/utils.py

@@ -1,43 +1,44 @@
 from __future__ import annotations
 
 import json
-import os
-from typing import Any, cast
+from typing import Any
 
+import aioboto3
 import boto3
+from botocore.exceptions import NoCredentialsError
 
 from livekit.agents import llm
 from livekit.agents.llm import ChatContext, FunctionTool, ImageContent, utils
-from livekit.agents.types import NotGivenOr
-from livekit.agents.utils import is_given
-
-__all__ = ["to_fnc_ctx", "to_chat_ctx", "get_aws_credentials"]
 
+__all__ = ["to_fnc_ctx", "to_chat_ctx", "get_aws_async_session"]
 DEFAULT_REGION = "us-east-1"
 
 
-def get_aws_credentials(
-    api_key: NotGivenOr[str],
-    api_secret: NotGivenOr[str],
-    region: NotGivenOr[str],
-):
-    aws_region = region if is_given(region) else os.environ.get("AWS_DEFAULT_REGION")
-    if not aws_region:
-        aws_region = DEFAULT_REGION
-
-    if is_given(api_key) and is_given(api_secret):
-        session = boto3.Session(
-            aws_access_key_id=api_key,
-            aws_secret_access_key=api_secret,
-            region_name=aws_region,
-        )
-    else:
-        session = boto3.Session(region_name=aws_region)
-
-    credentials = session.get_credentials()
-    if not credentials or not credentials.access_key or not credentials.secret_key:
-        raise ValueError("No valid AWS credentials found.")
-    return cast(tuple[str, str, str], (credentials.access_key, credentials.secret_key, region))
+def get_aws_async_session(
+    region: str | None = None,
+    api_key: str | None = None,
+    api_secret: str | None = None,
+) -> aioboto3.Session:
+    _validate_aws_credentials(api_key, api_secret)
+    session = aioboto3.Session(
+        aws_access_key_id=api_key,
+        aws_secret_access_key=api_secret,
+        region_name=region or DEFAULT_REGION,
+    )
+    return session
+
+
+def _validate_aws_credentials(
+    api_key: str | None = None,
+    api_secret: str | None = None,
+) -> None:
+    try:
+        session = boto3.Session(aws_access_key_id=api_key, aws_secret_access_key=api_secret)
+        creds = session.get_credentials()
+        if not creds:
+            raise ValueError("No credentials found")
+    except (NoCredentialsError, Exception) as e:
+        raise ValueError(f"Unable to locate valid AWS credentials: {str(e)}") from e
 
 
 def to_fnc_ctx(fncs: list[FunctionTool]) -> list[dict]:

{livekit_plugins_aws-1.0.0rc6 → livekit_plugins_aws-1.0.0rc7}/livekit/plugins/aws/version.py

@@ -12,4 +12,4 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-__version__ = '1.0.0.rc6'
+__version__ = '1.0.0.rc7'

{livekit_plugins_aws-1.0.0rc6 → livekit_plugins_aws-1.0.0rc7}/pyproject.toml

@@ -23,10 +23,10 @@ classifiers = [
     "Programming Language :: Python :: 3 :: Only",
 ]
 dependencies = [
-    "livekit-agents>=1.0.0.rc6",
-    "aiobotocore==2.19.0",
-    "boto3==1.36.3",
-    "amazon-transcribe>=0.6.2",
+    "livekit-agents>=1.0.0.rc7",
+    "aioboto3==14.1.0",
+    "amazon-transcribe==0.6.2",
+    "boto3==1.37.1",
 ]
 
 [project.urls]