livekit-plugins-aws 1.0.0rc6__py3-none-any.whl → 1.3.9__py3-none-any.whl

livekit/plugins/aws/utils.py

@@ -1,142 +1,46 @@
 from __future__ import annotations
 
-import json
-import os
-from typing import Any, cast
-
-import boto3
-
 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"]
-
+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 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 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.0.rc6'
+__version__ = "1.3.9"

livekit_plugins_aws-1.3.9.dist-info/METADATA

@@ -0,0 +1,385 @@
+Metadata-Version: 2.4
+Name: livekit-plugins-aws
+Version: 1.3.9
+Summary: LiveKit Agents Plugin for services from AWS
+Project-URL: Documentation, https://docs.livekit.io
+Project-URL: Website, https://livekit.io/
+Project-URL: Source, https://github.com/livekit/agents
+Author-email: LiveKit <hello@livekit.io>
+License-Expression: Apache-2.0
+Keywords: ai,audio,aws,livekit,nova,realtime,sonic,video,voice
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Multimedia :: Sound/Audio
+Classifier: Topic :: Multimedia :: Video
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.9.0
+Requires-Dist: aioboto3>=14.1.0
+Requires-Dist: aws-sdk-transcribe-streaming>=0.2.0; python_version >= '3.12'
+Requires-Dist: livekit-agents>=1.3.9
+Provides-Extra: realtime
+Requires-Dist: aws-sdk-bedrock-runtime>=0.2.0; (python_version >= '3.12') and extra == 'realtime'
+Requires-Dist: aws-sdk-signers>=0.0.3; (python_version >= '3.12') and extra == 'realtime'
+Requires-Dist: boto3>1.35.10; extra == 'realtime'
+Description-Content-Type: text/markdown
+
+# AWS Plugin for LiveKit Agents
+
+Complete AWS AI integration for LiveKit Agents, including Bedrock, Polly, Transcribe, and realtime voice-to-voice support for Amazon Nova 2 Sonic
+
+**What's included:**
+- **RealtimeModel** - Amazon Nova Sonic 1.0 & 2.0 for speech-to-speech
+- **LLM** - Powered by Amazon Bedrock, defaults to Nova 2 Lite
+- **STT** - Powered by AWS Transcribe
+- **TTS** - Powered by Amazon Polly
+
+See [https://docs.livekit.io/agents/integrations/aws/](https://docs.livekit.io/agents/integrations/aws/) for more information.
+
+## ⚠️ Breaking Change
+
+**Default model changed to Nova 2.0 Sonic**: `RealtimeModel()` now defaults to `amazon.nova-2-sonic-v1:0` with `modalities="mixed"` (was `amazon.nova-sonic-v1:0` with `modalities="audio"`).
+
+If you need the previous behavior, explicitly specify Nova 1.0 Sonic:
+```python
+model = aws.realtime.RealtimeModel.with_nova_sonic_1()
+# or
+model = aws.realtime.RealtimeModel(
+    model="amazon.nova-sonic-v1:0",
+    modalities="audio"
+)
+```
+
+## Installation
+
+```bash
+pip install livekit-plugins-aws
+
+# For Nova Sonic realtime models
+pip install livekit-plugins-aws[realtime]
+```
+
+## Prerequisites
+
+### AWS Credentials
+
+You'll need AWS credentials with access to Amazon Bedrock. Set them as environment variables:
+
+```bash
+export AWS_ACCESS_KEY_ID=<your-access-key>
+export AWS_SECRET_ACCESS_KEY=<your-secret-key>
+export AWS_DEFAULT_REGION=us-east-1  # or your preferred region
+```
+
+### Getting Temporary Credentials from SSO (Local Testing)
+
+If you use AWS SSO for authentication, get temporary credentials for local testing:
+
+```bash
+# Login to your SSO profile
+aws sso login --profile your-profile-name
+
+# Export credentials from your SSO session
+eval $(aws configure export-credentials --profile your-profile-name --format env)
+
+# Verify credentials are set
+aws sts get-caller-identity
+```
+
+Alternatively, add this to your shell profile for automatic credential export:
+
+```bash
+# Add to ~/.bashrc or ~/.zshrc
+function aws-creds() {
+    eval $(aws configure export-credentials --profile $1 --format env)
+}
+
+# Usage: aws-creds your-profile-name
+```
+
+## Quick Start Example
+
+The `realtime_joke_teller.py` example demonstrates both realtime and pipeline modes:
+
+### Demonstrates Both Modes
+- **Realtime mode**: Nova Sonic 2.0 for end-to-end speech-to-speech
+- **Pipeline mode**: AWS Transcribe + Nova 2 Lite + Amazon Polly
+
+### Demonstrates Nova 2 Sonic Capabilities
+- **Text prompting**: Agent greets users first using `generate_reply()`
+- **Multilingual support**: Automatic language detection and response in 8 languages
+- **Multiple voices**: 15 expressive voices across languages
+- **Function calling**: Weather lookup, web search, and joke telling
+
+### Setup
+
+1. **Install dependencies:**
+   ```bash
+   pip install livekit-plugins-aws[realtime] \
+               livekit-plugins-silero \
+               jokeapi \
+               duckduckgo-search \
+               python-weather \
+               python-dotenv
+   ```
+
+2. **Copy the example locally:**
+   ```bash
+   curl -O https://raw.githubusercontent.com/livekit/agents/main/examples/voice_agents/realtime_joke_teller.py
+   ```
+
+3. **Set up environment variables:**
+   ```bash
+   # Create .env file
+   echo "AWS_DEFAULT_REGION=us-east-1" > .env
+   # Add your AWS credentials (see Prerequisites above)
+   ```
+
+4. **(Optional) Run local LiveKit server:**
+   
+   For testing without LiveKit Cloud, run a local server:
+   ```bash
+   # Install LiveKit server
+   brew install livekit  # macOS
+   # or download from https://github.com/livekit/livekit/releases
+   
+   # Run in dev mode
+   livekit-server --dev
+   ```
+   
+   Add to your `.env` file:
+   ```bash
+   LIVEKIT_URL=wss://127.0.0.1:7880
+   LIVEKIT_API_KEY=devkey
+   LIVEKIT_API_SECRET=secret
+   ```
+   
+   See [self-hosting documentation](https://docs.livekit.io/home/self-hosting/local/) for more details.
+
+### Running the Example
+
+**Realtime Mode (Nova Sonic 2.0)** - Recommended for testing:
+```bash
+python realtime_joke_teller.py console
+```
+This runs locally using your computer's speakers and microphone. **Use a headset to prevent echo.**
+
+**Multilingual Support:** Sonic automatically detects and responds in your language. Just start speaking in your preferred language (English, French, Italian, German, Spanish, Portuguese, or Hindi) and Sonic will respond in the same language!
+
+**Pipeline Mode (Transcribe + Nova Lite + Polly)**:
+```bash
+python realtime_joke_teller.py console --mode pipeline
+```
+
+**Dev Mode** (connect to LiveKit room for remote testing):
+```bash
+python realtime_joke_teller.py dev
+# or
+python realtime_joke_teller.py dev --mode pipeline
+```
+
+Try asking:
+- "What's the weather in Seattle?"
+- "Tell me a programming joke"
+- "Search for information about my favorite movie, Short Circuit"
+
+## Features
+
+### Nova 2 Sonic Capabilities
+
+Amazon Nova 2 Sonic is a unified speech-to-speech foundation model that delivers:
+
+- **Realtime bidirectional streaming** - Low-latency, natural conversations
+- **Multilingual support** - English, French, Italian, German, Spanish, Portuguese, Hindi
+- **Automatic language mirroring** - Responds in the user's spoken language
+- **Polyglot voices** - Matthew and Tiffany can seamlessly switch between languages within a single conversation, ideal for multilingual applications
+- **16 expressive voices** - Multiple voices per language with natural prosody
+- **Function calling** - Built-in tool use and agentic workflows
+- **Interruption handling** - Graceful handling without losing context
+- **Noise robustness** - Works in real-world environments
+- **Text input support** (Nova 2.0 only) - Programmatic text prompting
+
+### Model Selection
+
+```python
+from livekit.plugins import aws
+
+# Nova Sonic 1.0 (audio-only, original model)
+model = aws.realtime.RealtimeModel.with_nova_sonic_1()
+
+# Nova Sonic 2.0 (audio + text input, latest)
+model = aws.realtime.RealtimeModel.with_nova_sonic_2()
+```
+
+### Voice Selection
+
+Voices are specified as lowercase strings. Import `SONIC1_VOICES` or `SONIC2_VOICES` type hints for IDE autocomplete.
+
+```python
+from livekit.plugins.aws.experimental.realtime import SONIC2_VOICES
+
+model = aws.realtime.RealtimeModel.with_nova_sonic_2(
+    voice="carolina"  # Portuguese, feminine
+)
+```
+
+#### Nova Sonic 1.0 Voices (11 voices)
+
+- **English (US)**: `matthew`, `tiffany`
+- **English (GB)**: `amy`
+- **Spanish**: `lupe`, `carlos`
+- **French**: `ambre`, `florian`
+- **German**: `greta`, `lennart`
+- **Italian**: `beatrice`, `lorenzo`
+
+#### Nova Sonic 2.0 Voices (16 voices)
+
+- **English (US)**: `matthew` (polyglot), `tiffany` (polyglot), `olivia`
+- **English (GB)**: `amy`
+- **Spanish**: `lupe`, `carlos`
+- **French**: `ambre`, `florian`
+- **German**: `tina`, `lennart`
+- **Italian**: `beatrice`, `lorenzo`
+- **Portuguese (Brazilian)**: `carolina`, `leo`
+- **Hindi**: `arjun`, `kiara`
+
+**Note**: Matthew and Tiffany in Nova 2.0 support polyglot mode, seamlessly switching between languages within a single conversation.
+
+### Text Prompting with `generate_reply()`
+
+Nova 2 Sonic supports programmatic text input to trigger agent responses:
+
+```python
+class Assistant(Agent):
+    async def on_enter(self):
+        # Make the agent speak first with a greeting
+        await self.session.generate_reply(
+            instructions="Greet the user and introduce your capabilities"
+        )
+```
+
+#### `instructions` vs `user_input`
+
+The `generate_reply()` method accepts two parameters with different behaviors:
+
+**`instructions`** - System-level commands (recommended):
+```python
+await session.generate_reply(
+    instructions="Greet the user warmly and ask how you can help"
+)
+```
+- Sent as a system prompt/command to the model
+- Triggers immediate generation
+- Does not appear in conversation history as user message
+- Use for: Agent-initiated speech, prompting specific behaviors
+
+**`user_input`** - Simulated user messages:
+```python
+await session.generate_reply(
+    user_input="Hello, I need help with my account"
+)
+```
+- Sent as interactive USER role content
+- Added to Nova's conversation context
+- Triggers generation as if user spoke
+- Use for: Testing, simulating user input, programmatic conversations
+
+**When to use each:**
+- **Agent greetings**: Use `instructions` - agent should speak without user input
+- **Guided responses**: Use `instructions` - direct the agent's next action
+- **Simulated conversations**: Use `user_input` - test multi-turn dialogs
+- **Programmatic user input**: Use `user_input` - inject text as if user spoke
+
+### Turn-Taking Sensitivity
+
+Control how quickly the agent responds to pauses:
+
+```python
+model = aws.realtime.RealtimeModel.with_nova_sonic_2(
+    turn_detection="MEDIUM"  # HIGH, MEDIUM (default), LOW
+)
+```
+
+- **HIGH**: Fast responses, may interrupt slower speakers
+- **MEDIUM**: Balanced, works for most use cases (recommended)
+- **LOW**: Patient, better for thoughtful or hesitant speakers
+
+### Complete Example
+
+```python
+from livekit import agents
+from livekit.agents import Agent, AgentSession
+from livekit.plugins import aws
+from dotenv import load_dotenv
+
+
+load_dotenv()
+
+class Assistant(Agent):
+    def __init__(self):
+        super().__init__(
+            instructions="You are a helpful voice assistant powered by Amazon Nova Sonic 2.0."
+        )
+    
+    async def on_enter(self):
+        await self.session.generate_reply(
+            instructions="Greet the user and offer assistance"
+        )
+
+server = agents.AgentServer()
+
+@server.rtc_session()
+async def entrypoint(ctx: agents.JobContext):
+    await ctx.connect()
+    
+    session = AgentSession(
+        llm=aws.realtime.RealtimeModel.with_nova_sonic_2(
+            voice="matthew",
+            turn_detection="MEDIUM",
+            tool_choice="auto"
+        )
+    )
+    
+    await session.start(room=ctx.room, agent=Assistant())
+
+if __name__ == "__main__":
+    agents.cli.run_app(server)
+```
+
+## Pipeline Mode (STT + LLM + TTS)
+
+For more control over individual components, use pipeline mode:
+
+```python
+from livekit.plugins import aws, silero
+
+session = AgentSession(
+    stt=aws.STT(),                    # AWS Transcribe
+    llm=aws.LLM(),                    # Nova 2 Lite (default)
+    tts=aws.TTS(),                    # Amazon Polly
+    vad=silero.VAD.load(),
+)
+```
+
+### Nova 2 Lite
+
+Amazon Nova 2 Lite is a fast, cost-effective reasoning model optimized for everyday AI workloads:
+
+- **Lightning-fast processing** - Very low latency for real-time conversations
+- **Cost-effective** - Industry-leading price-performance
+- **Multimodal inputs** - Text and images ([source](https://docs.aws.amazon.com/bedrock/latest/userguide/models-supported.html))
+- **1 million token context window** - Handle long conversations and complex context ([source](https://aws.amazon.com/blogs/aws/introducing-amazon-nova-2-lite-a-fast-cost-effective-reasoning-model/))
+- **Agentic workflows** - RAG systems, function calling, tool use
+- **Fine-tuning support** - Customize for your specific use case
+
+Ideal for pipeline mode where you need fast, accurate LLM responses in voice applications.
+
+## Resources
+
+- [LiveKit Agents Documentation](https://docs.livekit.io/agents/)
+- [AWS Nova Documentation](https://docs.aws.amazon.com/nova/latest/userguide/speech.html)
+- [Example: realtime_joke_teller.py](https://github.com/livekit/agents/blob/main/examples/voice_agents/realtime_joke_teller.py)

livekit_plugins_aws-1.3.9.dist-info/RECORD

@@ -0,0 +1,18 @@
+livekit/plugins/aws/__init__.py,sha256=dCZISj1yZG0WZTojk3sU-Ub4PK1ThCVhamrl9k_NbBw,2047
+livekit/plugins/aws/llm.py,sha256=jupj91Yi-bxrgEi62JP6oIjjTzl4if5IOxR-8QVSvSM,13042
+livekit/plugins/aws/log.py,sha256=S5ICcsnwshZhMG0HPmc_lI3mtHmcY4oQMJBsnnho-bM,289
+livekit/plugins/aws/models.py,sha256=J4yzik9sR68RPZpR1ubRQ9hdn14D9IwA3KaRvAf5tAE,734
+livekit/plugins/aws/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+livekit/plugins/aws/stt.py,sha256=2bcqwtC9MbHaLObx445-Vzj2-AstyGmAzbK2RNrbIy4,13584
+livekit/plugins/aws/tts.py,sha256=oav-XWf9ysVGCmERWej6BgACu8vsLbRo9vFGpo9N6Ec,7184
+livekit/plugins/aws/utils.py,sha256=nA5Ua1f4T-25Loar6EvlrKTXI9N-zpTIH7cdQkwGyGI,1518
+livekit/plugins/aws/version.py,sha256=Nr6Pqjd3G4o4xsBcOohDAA8MX74m67zVm0Ti65IKCsM,600
+livekit/plugins/aws/experimental/realtime/__init__.py,sha256=w-Y5TEWOFGfHlTtlEhpvKPxaqbHE2hKGdSFvmzZs8uE,278
+livekit/plugins/aws/experimental/realtime/events.py,sha256=2UQHHMgZZFCD3qFwpaj6SBuEKN1AlOhU9PBOaQeMSZU,16836
+livekit/plugins/aws/experimental/realtime/pretty_printer.py,sha256=KN7KPrfQu8cU7ff34vFAtfrd1umUSTVNKXQU7D8AMiM,1442
+livekit/plugins/aws/experimental/realtime/realtime_model.py,sha256=TQoAcMfgMjcWsDe4pC0DuqhMu_e62M5ai-vZ0w8Zt9A,97853
+livekit/plugins/aws/experimental/realtime/turn_tracker.py,sha256=kGk-2nZDZPviq_8AzrI6TlCqhWe8MGItBZf4fxl8Bbw,6354
+livekit/plugins/aws/experimental/realtime/types.py,sha256=lEiIV1bAUn0CPQzRQaooPUrCCm2_I6ZKfGBWxQ_5HUc,1308
+livekit_plugins_aws-1.3.9.dist-info/METADATA,sha256=luHDElv87SCHwAovRsQOmIk8E-5fTzlONMJ69m_VDqU,12741
+livekit_plugins_aws-1.3.9.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+livekit_plugins_aws-1.3.9.dist-info/RECORD,,

{livekit_plugins_aws-1.0.0rc6.dist-info → livekit_plugins_aws-1.3.9.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.27.0
+Generator: hatchling 1.28.0
 Root-Is-Purelib: true
 Tag: py3-none-any

livekit_plugins_aws-1.0.0rc6.dist-info/METADATA

@@ -1,43 +0,0 @@
-Metadata-Version: 2.4
-Name: livekit-plugins-aws
-Version: 1.0.0rc6
-Summary: LiveKit Agents Plugin for services from AWS
-Project-URL: Documentation, https://docs.livekit.io
-Project-URL: Website, https://livekit.io/
-Project-URL: Source, https://github.com/livekit/agents
-Author-email: LiveKit <hello@livekit.io>
-License-Expression: Apache-2.0
-Keywords: audio,aws,livekit,realtime,video,webrtc
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: Apache Software License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3 :: Only
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.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
-Description-Content-Type: text/markdown
-
-# LiveKit Plugins AWS
-
-Agent Framework plugin for services from AWS.
-
-- aws polly for tts
-- aws transcribe for stt
-- aws bedrock for llm
-
-## Installation
-
-```bash
-pip install livekit-plugins-aws
-```
-
-## Pre-requisites
-
-You'll need to specify an AWS Access Key and a Deployment Region. They can be set as environment variables: `AWS_ACCESS_KEY_ID`, `AWS_SECRET_ACCESS_KEY` and `AWS_DEFAULT_REGION`, respectively.

livekit_plugins_aws-1.0.0rc6.dist-info/RECORD

@@ -1,12 +0,0 @@
-livekit/plugins/aws/__init__.py,sha256=Ea-hK7QdutnwdZvvs9K2fiR8RWJqz2JcONxXnV1kXF0,977
-livekit/plugins/aws/llm.py,sha256=rIji8jLIyV-xfrDzDewqQiHIzV-oZAE9Cj6p6bba6Nw,11353
-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=j2vEsoixFcsyTbCNhW5EWea5CEv3K-DzL9wmweebf3o,8030
-livekit/plugins/aws/tts.py,sha256=4EOI4VabvhjCcDyp_QoDhlXOdrMrKpnmNIDTeoJ8kcU,7601
-livekit/plugins/aws/utils.py,sha256=FBUOsVNC0J2-_bfdRMbAtny72Tqji3UnC0RZdMND7jo,5011
-livekit/plugins/aws/version.py,sha256=PDOEKN5zsYLQdbfAm5Di6G1sFYANNA0LqJR8zZzeghg,604
-livekit_plugins_aws-1.0.0rc6.dist-info/METADATA,sha256=H7G8v1bskBEj88pLijagWXR_uG-LwkUKnLwLs0R8JU8,1483
-livekit_plugins_aws-1.0.0rc6.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-livekit_plugins_aws-1.0.0rc6.dist-info/RECORD,,