livekit-plugins-aws 1.0.23__py3-none-any.whl → 1.1.0__py3-none-any.whl

livekit/plugins/aws/llm.py

@@ -16,12 +16,18 @@ from __future__ import annotations
 
 import os
 from dataclasses import dataclass
-from typing import Any, Literal
+from typing import Any, cast
 
-import aioboto3
+import aioboto3  # type: ignore
 
 from livekit.agents import APIConnectionError, APIStatusError, llm
-from livekit.agents.llm import ChatContext, FunctionTool, FunctionToolCall, ToolChoice
+from livekit.agents.llm import (
+    ChatContext,
+    FunctionTool,
+    FunctionToolCall,
+    RawFunctionTool,
+    ToolChoice,
+)
 from livekit.agents.types import (
     DEFAULT_API_CONNECT_OPTIONS,
     NOT_GIVEN,
@@ -31,14 +37,14 @@ from livekit.agents.types import (
 from livekit.agents.utils import is_given
 
 from .log import logger
-from .utils import to_chat_ctx, to_fnc_ctx
+from .utils import to_fnc_ctx
 
-TEXT_MODEL = Literal["anthropic.claude-3-5-sonnet-20241022-v2:0"]
+DEFAULT_TEXT_MODEL = "anthropic.claude-3-5-sonnet-20240620-v1:0"
 
 
 @dataclass
 class _LLMOptions:
-    model: str | TEXT_MODEL
+    model: str
     temperature: NotGivenOr[float]
     tool_choice: NotGivenOr[ToolChoice]
     max_output_tokens: NotGivenOr[int]
@@ -50,10 +56,10 @@ class LLM(llm.LLM):
     def __init__(
         self,
         *,
-        model: NotGivenOr[str | TEXT_MODEL] = NOT_GIVEN,
+        model: NotGivenOr[str] = DEFAULT_TEXT_MODEL,
         api_key: NotGivenOr[str] = NOT_GIVEN,
         api_secret: NotGivenOr[str] = NOT_GIVEN,
-        region: NotGivenOr[str] = NOT_GIVEN,
+        region: NotGivenOr[str] = "us-east-1",
         temperature: NotGivenOr[float] = NOT_GIVEN,
         max_output_tokens: NotGivenOr[int] = NOT_GIVEN,
         top_p: NotGivenOr[float] = NOT_GIVEN,
@@ -70,7 +76,8 @@ class LLM(llm.LLM):
         See https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/bedrock-runtime/client/converse_stream.html for more details on the AWS Bedrock Runtime API.
 
         Args:
-            model (TEXT_MODEL, optional): model or inference profile arn to use(https://docs.aws.amazon.com/bedrock/latest/userguide/inference-profiles-use.html). Defaults to 'anthropic.claude-3-5-sonnet-20240620-v1:0'.
+            model (str, optional): model or inference profile arn to use(https://docs.aws.amazon.com/bedrock/latest/userguide/inference-profiles-use.html).
+                Defaults to 'anthropic.claude-3-5-sonnet-20240620-v1:0'.
             api_key(str, optional): AWS access key id.
             api_secret(str, optional): AWS secret access key
             region (str, optional): The region to use for AWS API requests. Defaults value is "us-east-1".
@@ -89,13 +96,15 @@ class LLM(llm.LLM):
             region_name=region if is_given(region) else None,
         )
 
-        model = model if is_given(model) else os.environ.get("BEDROCK_INFERENCE_PROFILE_ARN")
-        if not model:
+        bedrock_model = (
+            model if is_given(model) else os.environ.get("BEDROCK_INFERENCE_PROFILE_ARN")
+        )
+        if not bedrock_model:
             raise ValueError(
                 "model or inference profile arn must be set using the argument or by setting the BEDROCK_INFERENCE_PROFILE_ARN environment variable."  # noqa: E501
             )
         self._opts = _LLMOptions(
-            model=model,
+            model=bedrock_model,
             temperature=temperature,
             tool_choice=tool_choice,
             max_output_tokens=max_output_tokens,
@@ -107,12 +116,15 @@ class LLM(llm.LLM):
         self,
         *,
         chat_ctx: ChatContext,
-        tools: list[FunctionTool] | None = None,
+        tools: list[FunctionTool | RawFunctionTool] | None = None,
+        parallel_tool_calls: NotGivenOr[bool] = NOT_GIVEN,
         conn_options: APIConnectOptions = DEFAULT_API_CONNECT_OPTIONS,
-        temperature: NotGivenOr[float] = NOT_GIVEN,
         tool_choice: NotGivenOr[ToolChoice] = NOT_GIVEN,
+        temperature: NotGivenOr[float] = NOT_GIVEN,
+        extra_kwargs: NotGivenOr[dict[str, Any]] = NOT_GIVEN,
     ) -> LLMStream:
-        opts = {}
+        opts: dict[str, Any] = {}
+        extra_kwargs = extra_kwargs if is_given(extra_kwargs) else {}
 
         if is_given(self._opts.model):
             opts["modelId"] = self._opts.model
@@ -124,7 +136,9 @@ class LLM(llm.LLM):
                 return None
 
             tool_config: dict[str, Any] = {"tools": to_fnc_ctx(tools)}
-            tool_choice = tool_choice if is_given(tool_choice) else self._opts.tool_choice
+            tool_choice = (
+                cast(ToolChoice, tool_choice) if is_given(tool_choice) else self._opts.tool_choice
+            )
             if is_given(tool_choice):
                 if isinstance(tool_choice, dict) and tool_choice.get("type") == "function":
                     tool_config["toolChoice"] = {"tool": {"name": tool_choice["function"]["name"]}}
@@ -140,12 +154,12 @@ class LLM(llm.LLM):
         tool_config = _get_tool_config()
         if tool_config:
             opts["toolConfig"] = tool_config
-        messages, system_message = to_chat_ctx(chat_ctx, id(self))
+        messages, extra_data = chat_ctx.to_provider_format(format="aws")
         opts["messages"] = messages
-        if system_message:
-            opts["system"] = [system_message]
+        if extra_data.system_messages:
+            opts["system"] = [{"text": content} for content in extra_data.system_messages]
 
-        inference_config = {}
+        inference_config: dict[str, Any] = {}
         if is_given(self._opts.max_output_tokens):
             inference_config["maxTokens"] = self._opts.max_output_tokens
         temperature = temperature if is_given(temperature) else self._opts.temperature
@@ -176,7 +190,7 @@ class LLMStream(llm.LLMStream):
         chat_ctx: ChatContext,
         session: aioboto3.Session,
         conn_options: APIConnectOptions,
-        tools: list[FunctionTool],
+        tools: list[FunctionTool | RawFunctionTool],
         extra_kwargs: dict[str, Any],
     ) -> None:
         super().__init__(llm, chat_ctx=chat_ctx, tools=tools, conn_options=conn_options)
@@ -192,7 +206,7 @@ class LLMStream(llm.LLMStream):
         retryable = True
         try:
             async with self._session.client("bedrock-runtime") as client:
-                response = await client.converse_stream(**self._opts)  # type: ignore
+                response = await client.converse_stream(**self._opts)
                 request_id = response["ResponseMetadata"]["RequestId"]
                 if response["ResponseMetadata"]["HTTPStatusCode"] != 200:
                     raise APIStatusError(
@@ -240,6 +254,11 @@ class LLMStream(llm.LLMStream):
                     completion_tokens=metadata["usage"]["outputTokens"],
                     prompt_tokens=metadata["usage"]["inputTokens"],
                     total_tokens=metadata["usage"]["totalTokens"],
+                    prompt_cached_tokens=(
+                        metadata["usage"]["cacheReadInputTokens"]
+                        if "cacheReadInputTokens" in metadata["usage"]
+                        else 0
+                    ),
                 ),
             )
         elif "contentBlockStop" in chunk:

livekit/plugins/aws/models.py

@@ -1,7 +1,7 @@
 from typing import Literal
 
-TTS_SPEECH_ENGINE = Literal["standard", "neural", "long-form", "generative"]
-TTS_LANGUAGE = Literal[
+TTSSpeechEngine = Literal["standard", "neural", "long-form", "generative"]
+TTSLanguages = Literal[
     "arb",
     "cmn-CN",
     "cy-GB",
@@ -45,4 +45,4 @@ TTS_LANGUAGE = Literal[
     "de-CH",
 ]
 
-TTS_OUTPUT_FORMAT = Literal["mp3"]
+TTSEncoding = Literal["mp3"]

livekit/plugins/aws/stt.py

@@ -78,7 +78,7 @@ class STT(stt.STT):
         self._region = region
         self._client = TranscribeStreamingClient(
             region=self._region,
-            credential_resolver=AwsCrtCredentialResolver(None),
+            credential_resolver=AwsCrtCredentialResolver(None),  # type: ignore
         )
 
         self._config = STTOptions(
@@ -153,15 +153,15 @@ class SpeechStream(stt.SpeechStream):
                 "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 self._client.start_stream_transcription(**filtered_config)
+            stream = await self._client.start_stream_transcription(**filtered_config)  # type: ignore
 
-            async def input_generator(stream: StartStreamTranscriptionEventStream):
+            async def input_generator(stream: StartStreamTranscriptionEventStream) -> None:
                 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()
+                await stream.input_stream.end_stream()  # type: ignore
 
-            async def handle_transcript_events(stream: StartStreamTranscriptionEventStream):
+            async def handle_transcript_events(stream: StartStreamTranscriptionEventStream) -> None:
                 async for event in stream.output_stream:
                     if isinstance(event, TranscriptEvent):
                         self._process_transcript_event(event)
@@ -184,7 +184,7 @@ class SpeechStream(stt.SpeechStream):
             finally:
                 await utils.aio.gracefully_cancel(*tasks)
 
-    def _process_transcript_event(self, transcript_event: TranscriptEvent):
+    def _process_transcript_event(self, transcript_event: TranscriptEvent) -> None:
         stream = transcript_event.transcript.results
         for resp in stream:
             if resp.start_time and resp.start_time == 0.0:

livekit/plugins/aws/tts.py

@@ -12,19 +12,18 @@
 
 from __future__ import annotations
 
-import asyncio
-from dataclasses import dataclass
+from dataclasses import dataclass, replace
 
-import aioboto3
-import aiohttp
+import aioboto3  # type: ignore
+import botocore  # type: ignore
+import botocore.exceptions  # type: ignore
+from aiobotocore.config import AioConfig  # type: ignore
 
 from livekit.agents import (
     APIConnectionError,
     APIConnectOptions,
-    APIStatusError,
     APITimeoutError,
     tts,
-    utils,
 )
 from livekit.agents.types import (
     DEFAULT_API_CONNECT_OPTIONS,
@@ -33,36 +32,34 @@ from livekit.agents.types import (
 )
 from livekit.agents.utils import is_given
 
-from .models import TTS_LANGUAGE, TTS_SPEECH_ENGINE
+from .models import TTSLanguages, TTSSpeechEngine
 from .utils import _strip_nones
 
-TTS_NUM_CHANNELS: int = 1
-DEFAULT_SPEECH_ENGINE: TTS_SPEECH_ENGINE = "generative"
+DEFAULT_SPEECH_ENGINE: TTSSpeechEngine = "generative"
 DEFAULT_VOICE = "Ruth"
-DEFAULT_SAMPLE_RATE = 16000
 
 
 @dataclass
 class _TTSOptions:
     # https://docs.aws.amazon.com/polly/latest/dg/API_SynthesizeSpeech.html
-    voice: NotGivenOr[str]
-    speech_engine: NotGivenOr[TTS_SPEECH_ENGINE]
-    region: str
+    voice: str
+    speech_engine: TTSSpeechEngine
+    region: str | None
     sample_rate: int
-    language: NotGivenOr[TTS_LANGUAGE | str]
+    language: TTSLanguages | str | None
 
 
 class TTS(tts.TTS):
     def __init__(
         self,
         *,
-        voice: NotGivenOr[str] = NOT_GIVEN,
-        language: NotGivenOr[TTS_LANGUAGE | str] = NOT_GIVEN,
-        speech_engine: NotGivenOr[TTS_SPEECH_ENGINE] = NOT_GIVEN,
-        sample_rate: int = DEFAULT_SAMPLE_RATE,
-        region: NotGivenOr[str] = NOT_GIVEN,
-        api_key: NotGivenOr[str] = NOT_GIVEN,
-        api_secret: NotGivenOr[str] = NOT_GIVEN,
+        voice: str = "Ruth",
+        language: NotGivenOr[TTSLanguages | str] = NOT_GIVEN,
+        speech_engine: TTSSpeechEngine = "generative",
+        sample_rate: int = 16000,
+        region: str | None = None,
+        api_key: str | None = None,
+        api_secret: str | None = None,
         session: aioboto3.Session | None = None,
     ) -> None:
         """
@@ -88,108 +85,72 @@ class TTS(tts.TTS):
                 streaming=False,
             ),
             sample_rate=sample_rate,
-            num_channels=TTS_NUM_CHANNELS,
+            num_channels=1,
         )
         self._session = session or aioboto3.Session(
             aws_access_key_id=api_key if is_given(api_key) else None,
             aws_secret_access_key=api_secret if is_given(api_secret) else None,
             region_name=region if is_given(region) else None,
         )
+
         self._opts = _TTSOptions(
             voice=voice,
             speech_engine=speech_engine,
-            region=region,
-            language=language,
+            region=region or None,
+            language=language or None,
             sample_rate=sample_rate,
         )
 
     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,
-            text=text,
-            conn_options=conn_options,
-            session=self._session,
-            opts=self._opts,
-        )
+        return ChunkedStream(tts=self, text=text, conn_options=conn_options)
 
 
 class ChunkedStream(tts.ChunkedStream):
     def __init__(
-        self,
-        *,
-        tts: TTS,
-        text: str,
-        session: aioboto3.Session,
-        conn_options: APIConnectOptions = DEFAULT_API_CONNECT_OPTIONS,
-        opts: _TTSOptions,
+        self, *, tts: TTS, text: str, conn_options: APIConnectOptions = DEFAULT_API_CONNECT_OPTIONS
     ) -> None:
         super().__init__(tts=tts, input_text=text, conn_options=conn_options)
-        self._opts = opts
-        self._segment_id = utils.shortuuid()
-        self._session = session
-
-    async def _run(self):
-        request_id = utils.shortuuid()
+        self._tts = tts
+        self._opts = replace(tts._opts)
 
+    async def _run(self, output_emitter: tts.AudioEmitter) -> None:
         try:
-            async with self._session.client("polly") as client:
-                params = {
-                    "Text": self._input_text,
-                    "OutputFormat": "mp3",
-                    "Engine": self._opts.speech_engine
-                    if is_given(self._opts.speech_engine)
-                    else DEFAULT_SPEECH_ENGINE,
-                    "VoiceId": self._opts.voice if is_given(self._opts.voice) else DEFAULT_VOICE,
-                    "TextType": "text",
-                    "SampleRate": str(self._opts.sample_rate),
-                    "LanguageCode": self._opts.language if is_given(self._opts.language) else None,
-                }
-                response = await client.synthesize_speech(**_strip_nones(params))
+            config = AioConfig(
+                connect_timeout=self._conn_options.timeout,
+                read_timeout=10,
+                retries={"mode": "standard", "total_max_attempts": 1},
+            )
+            async with self._tts._session.client("polly", config=config) as client:  # type: ignore
+                response = await client.synthesize_speech(
+                    **_strip_nones(
+                        {
+                            "Text": self._input_text,
+                            "OutputFormat": "mp3",
+                            "Engine": self._opts.speech_engine,
+                            "VoiceId": self._opts.voice,
+                            "TextType": "text",
+                            "SampleRate": str(self._opts.sample_rate),
+                            "LanguageCode": self._opts.language,
+                        }
+                    )
+                )
+
                 if "AudioStream" in response:
-                    decoder = utils.codecs.AudioStreamDecoder(
+                    output_emitter.initialize(
+                        request_id=response["ResponseMetadata"]["RequestId"],
                         sample_rate=self._opts.sample_rate,
                         num_channels=1,
+                        mime_type="audio/mp3",
                     )
 
-                    # Create a task to push data to the decoder
-                    async def push_data():
-                        try:
-                            async with response["AudioStream"] as resp:
-                                async for data, _ in resp.content.iter_chunks():
-                                    decoder.push(data)
-                        finally:
-                            decoder.end_input()
-
-                    # Start pushing data to the decoder
-                    push_task = asyncio.create_task(push_data())
-
-                    try:
-                        # Create emitter and process decoded frames
-                        emitter = tts.SynthesizedAudioEmitter(
-                            event_ch=self._event_ch,
-                            request_id=request_id,
-                            segment_id=self._segment_id,
-                        )
-                        async for frame in decoder:
-                            emitter.push(frame)
-                        emitter.flush()
-                        await push_task
-                    finally:
-                        await utils.aio.gracefully_cancel(push_task)
-
-        except asyncio.TimeoutError:
+                    async with response["AudioStream"] as resp:
+                        async for data, _ in resp.content.iter_chunks():
+                            output_emitter.push(data)
+
+                    output_emitter.flush()
+        except botocore.exceptions.ConnectTimeoutError:
             raise APITimeoutError() from None
-        except aiohttp.ClientResponseError as e:
-            raise APIStatusError(
-                message=e.message,
-                status_code=e.status,
-                request_id=request_id,
-                body=None,
-            ) from None
         except Exception as e:
             raise APIConnectionError() from e

livekit/plugins/aws/utils.py

@@ -1,112 +1,46 @@
 from __future__ import annotations
 
-import json
-from typing import Any
-
 from livekit.agents import llm
-from livekit.agents.llm import ChatContext, FunctionTool, ImageContent, utils
-
-__all__ = ["to_fnc_ctx", "to_chat_ctx"]
+from livekit.agents.llm import FunctionTool, RawFunctionTool
+from livekit.agents.llm.tool_context import (
+    get_raw_function_info,
+    is_function_tool,
+    is_raw_function_tool,
+)
+
+__all__ = ["to_fnc_ctx"]
 DEFAULT_REGION = "us-east-1"
 
 
-def to_fnc_ctx(fncs: list[FunctionTool]) -> list[dict]:
+def to_fnc_ctx(fncs: list[FunctionTool | RawFunctionTool]) -> list[dict]:
     return [_build_tool_spec(fnc) for fnc in fncs]
 
 
-def to_chat_ctx(chat_ctx: ChatContext, cache_key: Any) -> tuple[list[dict], dict | None]:
-    messages: list[dict] = []
-    system_message: dict | None = None
-    current_role: str | None = None
-    current_content: list[dict] = []
-
-    for msg in chat_ctx.items:
-        if msg.type == "message" and msg.role == "system":
-            for content in msg.content:
-                if content and isinstance(content, str):
-                    system_message = {"text": content}
-            continue
-
-        if msg.type == "message":
-            role = "assistant" if msg.role == "assistant" else "user"
-        elif msg.type == "function_call":
-            role = "assistant"
-        elif msg.type == "function_call_output":
-            role = "user"
-
-        # if the effective role changed, finalize the previous turn.
-        if role != current_role:
-            if current_content and current_role is not None:
-                messages.append({"role": current_role, "content": current_content})
-            current_content = []
-            current_role = role
-
-        if msg.type == "message":
-            for content in msg.content:
-                if content and isinstance(content, str):
-                    current_content.append({"text": content})
-                elif isinstance(content, ImageContent):
-                    current_content.append(_build_image(content, cache_key))
-        elif msg.type == "function_call":
-            current_content.append(
+def _build_tool_spec(function: FunctionTool | RawFunctionTool) -> dict:
+    if is_function_tool(function):
+        fnc = llm.utils.build_legacy_openai_schema(function, internally_tagged=True)
+        return {
+            "toolSpec": _strip_nones(
                 {
-                    "toolUse": {
-                        "toolUseId": msg.call_id,
-                        "name": msg.name,
-                        "input": json.loads(msg.arguments or "{}"),
-                    }
+                    "name": fnc["name"],
+                    "description": fnc["description"] if fnc["description"] else None,
+                    "inputSchema": {"json": fnc["parameters"] if fnc["parameters"] else {}},
                 }
             )
-        elif msg.type == "function_call_output":
-            tool_response = {
-                "toolResult": {
-                    "toolUseId": msg.call_id,
-                    "content": [],
-                    "status": "success",
+        }
+    elif is_raw_function_tool(function):
+        info = get_raw_function_info(function)
+        return {
+            "toolSpec": _strip_nones(
+                {
+                    "name": info.name,
+                    "description": info.raw_schema.get("description", ""),
+                    "inputSchema": {"json": info.raw_schema.get("parameters", {})},
                 }
-            }
-            if isinstance(msg.output, dict):
-                tool_response["toolResult"]["content"].append({"json": msg.output})
-            elif isinstance(msg.output, str):
-                tool_response["toolResult"]["content"].append({"text": msg.output})
-            current_content.append(tool_response)
-
-    # Finalize the last message if there’s any content left
-    if current_role is not None and current_content:
-        messages.append({"role": current_role, "content": current_content})
-
-    # Ensure the message list starts with a "user" message
-    if not messages or messages[0]["role"] != "user":
-        messages.insert(0, {"role": "user", "content": [{"text": "(empty)"}]})
-
-    return messages, system_message
-
-
-def _build_tool_spec(fnc: FunctionTool) -> dict:
-    fnc = llm.utils.build_legacy_openai_schema(fnc, internally_tagged=True)
-    return {
-        "toolSpec": _strip_nones(
-            {
-                "name": fnc["name"],
-                "description": fnc["description"] if fnc["description"] else None,
-                "inputSchema": {"json": fnc["parameters"] if fnc["parameters"] else {}},
-            }
-        )
-    }
-
-
-def _build_image(image: ImageContent, cache_key: Any) -> dict:
-    img = utils.serialize_image(image)
-    if img.external_url:
-        raise ValueError("external_url is not supported by AWS Bedrock.")
-    if cache_key not in image._cache:
-        image._cache[cache_key] = img.data_bytes
-    return {
-        "image": {
-            "format": "jpeg",
-            "source": {"bytes": image._cache[cache_key]},
+            )
         }
-    }
+    else:
+        raise ValueError("Invalid function tool")
 
 
 def _strip_nones(d: dict) -> dict:

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.23"
+__version__ = "1.1.0"

{livekit_plugins_aws-1.0.23.dist-info → livekit_plugins_aws-1.1.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: livekit-plugins-aws
-Version: 1.0.23
+Version: 1.1.0
 Summary: LiveKit Agents Plugin for services from AWS
 Project-URL: Documentation, https://docs.livekit.io
 Project-URL: Website, https://livekit.io/
@@ -20,7 +20,7 @@ Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Requires-Python: >=3.9.0
 Requires-Dist: aioboto3>=14.1.0
 Requires-Dist: amazon-transcribe>=0.6.2
-Requires-Dist: livekit-agents>=1.0.23
+Requires-Dist: livekit-agents>=1.1.0
 Description-Content-Type: text/markdown
 
 # AWS plugin for LiveKit Agents

livekit_plugins_aws-1.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+livekit/plugins/aws/__init__.py,sha256=fkbgTfNZc6z4VxbYGNdY73EoGvNuRcJiuD-OlUHvjHU,1322
+livekit/plugins/aws/llm.py,sha256=pSbO7SaqYZYJ-3JGOmyMTmTLLcjoyrZy-j5BSkFOHU8,11922
+livekit/plugins/aws/log.py,sha256=jFief0Xhv0n_F6sp6UFu9VKxs2bXNVGAfYGmEYfR_2Q,66
+livekit/plugins/aws/models.py,sha256=ztI9n3r8OHGlQewWXiyQP3SaavFKHkw-VVuK9Xz4K1I,696
+livekit/plugins/aws/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+livekit/plugins/aws/stt.py,sha256=PSR89aN28wm4i83yEdhkDJ9xzM0CsNIKrc3v3EbPndQ,9018
+livekit/plugins/aws/tts.py,sha256=vYWPOw0QLIAJR-2lNVIV92o3cafNYCFdVBxE3z2L8E8,6127
+livekit/plugins/aws/utils.py,sha256=nA5Ua1f4T-25Loar6EvlrKTXI9N-zpTIH7cdQkwGyGI,1518
+livekit/plugins/aws/version.py,sha256=7SjyflIFTjH0djSotKGIRoRykPCqMpVYetIlvHMFuh0,600
+livekit_plugins_aws-1.1.0.dist-info/METADATA,sha256=54qGUl77s5Hb_LeN8KcCI4WOG0uwoQSp0jzJU-XvbP8,1529
+livekit_plugins_aws-1.1.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+livekit_plugins_aws-1.1.0.dist-info/RECORD,,

livekit_plugins_aws-1.0.23.dist-info/RECORD

@@ -1,12 +0,0 @@
-livekit/plugins/aws/__init__.py,sha256=fkbgTfNZc6z4VxbYGNdY73EoGvNuRcJiuD-OlUHvjHU,1322
-livekit/plugins/aws/llm.py,sha256=Z9FFjAZPKgX3NKE7J2rUBUVul-T-3sIHIl5W4b0bzLs,11249
-livekit/plugins/aws/log.py,sha256=jFief0Xhv0n_F6sp6UFu9VKxs2bXNVGAfYGmEYfR_2Q,66
-livekit/plugins/aws/models.py,sha256=Nf8RFmDulW7h03dG2lERTog3mgDK0TbLvW0eGOncuEE,704
-livekit/plugins/aws/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-livekit/plugins/aws/stt.py,sha256=JzCRxLec7ZbbNHUbjLl5PgzgvZBppeprQMmb_U5EpAI,8946
-livekit/plugins/aws/tts.py,sha256=iO4lBO1ggE2OBN5j54novJnwPa8GhyW0wiY-Xj8VDEk,7336
-livekit/plugins/aws/utils.py,sha256=UcKrSYrZf7SKYua1F51KZHskXRC5L5h-_WpFoPWLowo,4037
-livekit/plugins/aws/version.py,sha256=BRUqwxRBnPVqEcIODJdaZHGAanu4zkwM4NsAQjNtUEM,601
-livekit_plugins_aws-1.0.23.dist-info/METADATA,sha256=KhPRIV0zp8PWXbdobCb8cXUbEnyhI6L37-FO9pCySKw,1531
-livekit_plugins_aws-1.0.23.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-livekit_plugins_aws-1.0.23.dist-info/RECORD,,