livekit-plugins-aws 1.0.22__tar.gz → 1.1.0__tar.gz

{livekit_plugins_aws-1.0.22 → livekit_plugins_aws-1.1.0}/.gitignore

@@ -146,6 +146,9 @@ venv.bak/
 .dmypy.json
 dmypy.json
 
+# trunk
+.trunk/
+
 # Pyre type checker
 .pyre/
 

{livekit_plugins_aws-1.0.22 → livekit_plugins_aws-1.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: livekit-plugins-aws
-Version: 1.0.22
+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.22
+Requires-Dist: livekit-agents>=1.1.0
 Description-Content-Type: text/markdown
 
 # AWS plugin for LiveKit Agents

{livekit_plugins_aws-1.0.22 → livekit_plugins_aws-1.1.0}/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-1.0.22 → livekit_plugins_aws-1.1.0}/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-1.0.22 → livekit_plugins_aws-1.1.0}/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-1.1.0/livekit/plugins/aws/tts.py

@@ -0,0 +1,156 @@
+# 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
+
+from dataclasses import dataclass, replace
+
+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,
+    APITimeoutError,
+    tts,
+)
+from livekit.agents.types import (
+    DEFAULT_API_CONNECT_OPTIONS,
+    NOT_GIVEN,
+    NotGivenOr,
+)
+from livekit.agents.utils import is_given
+
+from .models import TTSLanguages, TTSSpeechEngine
+from .utils import _strip_nones
+
+DEFAULT_SPEECH_ENGINE: TTSSpeechEngine = "generative"
+DEFAULT_VOICE = "Ruth"
+
+
+@dataclass
+class _TTSOptions:
+    # https://docs.aws.amazon.com/polly/latest/dg/API_SynthesizeSpeech.html
+    voice: str
+    speech_engine: TTSSpeechEngine
+    region: str | None
+    sample_rate: int
+    language: TTSLanguages | str | None
+
+
+class TTS(tts.TTS):
+    def __init__(
+        self,
+        *,
+        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:
+        """
+        Create a new instance of AWS Polly TTS.
+
+        ``api_key``  and ``api_secret`` must be set to your AWS Access key id and secret access key, either using the argument or by setting the
+        ``AWS_ACCESS_KEY_ID`` and ``AWS_SECRET_ACCESS_KEY`` environmental variables.
+
+        See https://docs.aws.amazon.com/polly/latest/dg/API_SynthesizeSpeech.html for more details on the the AWS Polly TTS.
+
+        Args:
+            Voice (TTSModels, optional): Voice ID to use for the synthesis. Defaults to "Ruth".
+            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".
+            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(
+                streaming=False,
+            ),
+            sample_rate=sample_rate,
+            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 or None,
+            language=language or None,
+            sample_rate=sample_rate,
+        )
+
+    def synthesize(
+        self, text: str, *, conn_options: APIConnectOptions = DEFAULT_API_CONNECT_OPTIONS
+    ) -> ChunkedStream:
+        return ChunkedStream(tts=self, text=text, conn_options=conn_options)
+
+
+class ChunkedStream(tts.ChunkedStream):
+    def __init__(
+        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._tts = tts
+        self._opts = replace(tts._opts)
+
+    async def _run(self, output_emitter: tts.AudioEmitter) -> None:
+        try:
+            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:
+                    output_emitter.initialize(
+                        request_id=response["ResponseMetadata"]["RequestId"],
+                        sample_rate=self._opts.sample_rate,
+                        num_channels=1,
+                        mime_type="audio/mp3",
+                    )
+
+                    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 Exception as e:
+            raise APIConnectionError() from e

livekit_plugins_aws-1.1.0/livekit/plugins/aws/utils.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+from livekit.agents import llm
+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 | RawFunctionTool]) -> list[dict]:
+    return [_build_tool_spec(fnc) for fnc in fncs]
+
+
+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(
+                {
+                    "name": fnc["name"],
+                    "description": fnc["description"] if fnc["description"] else None,
+                    "inputSchema": {"json": fnc["parameters"] if fnc["parameters"] else {}},
+                }
+            )
+        }
+    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", {})},
+                }
+            )
+        }
+    else:
+        raise ValueError("Invalid function tool")
+
+
+def _strip_nones(d: dict) -> dict:
+    return {k: v for k, v in d.items() if v is not None}

{livekit_plugins_aws-1.0.22 → livekit_plugins_aws-1.1.0}/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.22"
+__version__ = "1.1.0"

{livekit_plugins_aws-1.0.22 → livekit_plugins_aws-1.1.0}/pyproject.toml

@@ -23,7 +23,7 @@ classifiers = [
     "Programming Language :: Python :: 3 :: Only",
 ]
 dependencies = [
-    "livekit-agents>=1.0.22",
+    "livekit-agents>=1.1.0",
     "aioboto3>=14.1.0",
     "amazon-transcribe>=0.6.2",
 ]

livekit_plugins_aws-1.0.22/livekit/plugins/aws/tts.py

@@ -1,195 +0,0 @@
-# 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
-from dataclasses import dataclass
-
-import aioboto3
-import aiohttp
-
-from livekit.agents import (
-    APIConnectionError,
-    APIConnectOptions,
-    APIStatusError,
-    APITimeoutError,
-    tts,
-    utils,
-)
-from livekit.agents.types import (
-    DEFAULT_API_CONNECT_OPTIONS,
-    NOT_GIVEN,
-    NotGivenOr,
-)
-from livekit.agents.utils import is_given
-
-from .models import TTS_LANGUAGE, TTS_SPEECH_ENGINE
-from .utils import _strip_nones
-
-TTS_NUM_CHANNELS: int = 1
-DEFAULT_SPEECH_ENGINE: TTS_SPEECH_ENGINE = "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
-    sample_rate: int
-    language: NotGivenOr[TTS_LANGUAGE | str]
-
-
-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,
-        session: aioboto3.Session | None = None,
-    ) -> None:
-        """
-        Create a new instance of AWS Polly TTS.
-
-        ``api_key``  and ``api_secret`` must be set to your AWS Access key id and secret access key, either using the argument or by setting the
-        ``AWS_ACCESS_KEY_ID`` and ``AWS_SECRET_ACCESS_KEY`` environmental variables.
-
-        See https://docs.aws.amazon.com/polly/latest/dg/API_SynthesizeSpeech.html for more details on the the AWS Polly TTS.
-
-        Args:
-            Voice (TTSModels, optional): Voice ID to use for the synthesis. Defaults to "Ruth".
-            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".
-            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(
-                streaming=False,
-            ),
-            sample_rate=sample_rate,
-            num_channels=TTS_NUM_CHANNELS,
-        )
-        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,
-            sample_rate=sample_rate,
-        )
-
-    def synthesize(
-        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,
-        )
-
-
-class ChunkedStream(tts.ChunkedStream):
-    def __init__(
-        self,
-        *,
-        tts: TTS,
-        text: str,
-        session: aioboto3.Session,
-        conn_options: APIConnectOptions = DEFAULT_API_CONNECT_OPTIONS,
-        opts: _TTSOptions,
-    ) -> 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()
-
-        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))
-                if "AudioStream" in response:
-                    decoder = utils.codecs.AudioStreamDecoder(
-                        sample_rate=self._opts.sample_rate,
-                        num_channels=1,
-                    )
-
-                    # 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:
-            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-1.0.22/livekit/plugins/aws/utils.py

@@ -1,113 +0,0 @@
-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"]
-DEFAULT_REGION = "us-east-1"
-
-
-def to_fnc_ctx(fncs: list[FunctionTool]) -> 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(
-                {
-                    "toolUse": {
-                        "toolUseId": msg.call_id,
-                        "name": msg.name,
-                        "input": json.loads(msg.arguments or "{}"),
-                    }
-                }
-            )
-        elif msg.type == "function_call_output":
-            tool_response = {
-                "toolResult": {
-                    "toolUseId": msg.call_id,
-                    "content": [],
-                    "status": "success",
-                }
-            }
-            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]},
-        }
-    }
-
-
-def _strip_nones(d: dict) -> dict:
-    return {k: v for k, v in d.items() if v is not None}