vision-agents-plugins-inworld 0.2.3__tar.gz

vision_agents_plugins_inworld-0.2.3/.gitignore

@@ -0,0 +1,90 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.cursor/*
+# Distribution / packaging
+.Python
+build/
+dist/
+downloads/
+develop-eggs/
+eggs/
+.eggs/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+pip-wheel-metadata/
+MANIFEST
+*.egg-info/
+*.egg
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+coverage.xml
+nosetests.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+
+# Type checker / lint caches
+.mypy_cache/
+.dmypy.json
+dmypy.json
+.pytype/
+.pyre/
+.ruff_cache/
+
+# Environments
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+.env
+.env.local
+.env.*.local
+.env.bak
+pyvenv.cfg
+.python-version
+
+# Editors / IDEs
+.vscode/
+.idea/
+
+# Jupyter Notebook
+.ipynb_checkpoints/
+
+# OS / Misc
+.DS_Store
+*.log
+
+# Tooling & repo-specific
+pyrightconfig.json
+shell.nix
+bin/*
+lib/*
+stream-py/
+
+# Artifacts / assets
+*.pt
+*.kef
+*.onnx
+profile.html
+
+/opencode.json

vision_agents_plugins_inworld-0.2.3/PKG-INFO

@@ -0,0 +1,82 @@
+Metadata-Version: 2.4
+Name: vision-agents-plugins-inworld
+Version: 0.2.3
+Summary: Inworld AI TTS integration for Vision Agents
+Project-URL: Documentation, https://visionagents.ai/
+Project-URL: Website, https://visionagents.ai/
+Project-URL: Source, https://github.com/GetStream/Vision-Agents
+License-Expression: MIT
+Keywords: AI,TTS,agents,inworld,text-to-speech,voice agents
+Requires-Python: >=3.10
+Requires-Dist: av>=10.0.0
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: vision-agents
+Description-Content-Type: text/markdown
+
+# Inworld AI Text-to-Speech Plugin
+
+A high-quality Text-to-Speech (TTS) plugin for Vision Agents that uses the Inworld AI API with streaming support.
+
+## Installation
+
+```bash
+uv add vision-agents[inworld]
+```
+
+## Usage
+
+```python
+from vision_agents.plugins import inworld
+
+# Initialize with API key from environment variable
+tts = inworld.TTS()
+
+# Or specify API key and other options directly
+tts = inworld.TTS(
+    api_key="your_inworld_api_key",
+    voice_id="Dennis",
+    model_id="inworld-tts-1",
+    temperature=1.1
+)
+
+# Use with an Agent
+from vision_agents.core import Agent
+from vision_agents.plugins import getstream, gemini, smart_turn
+
+agent = Agent(
+    edge=getstream.Edge(),
+    tts=inworld.TTS(),
+    llm=gemini.LLM("gemini-2.0-flash"),
+    turn_detection=smart_turn.TurnDetection(),
+)
+```
+
+## Configuration Options
+
+- `api_key`: Inworld AI API key (default: reads from `INWORLD_API_KEY` environment variable)
+- `voice_id`: The voice ID to use for synthesis (default: "Dennis")
+- `model_id`: The model ID to use for synthesis. Options: "inworld-tts-1", "inworld-tts-1-max" (default: "inworld-tts-1")
+- `temperature`: Determines the degree of randomness when sampling audio tokens. Accepts values between 0 and 2 (default: 1.1)
+
+## Requirements
+
+- Python 3.10+
+- httpx>=0.27.0
+  "av>=10.0.0",
+
+## Getting Started
+
+1. Get your Inworld AI API key from the [Inworld Portal](https://studio.inworld.ai/)
+2. Set the `INWORLD_API_KEY` environment variable:
+   ```bash
+   export INWORLD_API_KEY="your_api_key_here"
+   ```
+3. Use the plugin in your Vision Agents application
+
+## API Reference
+
+The plugin implements the standard Vision Agents TTS interface:
+
+- `stream_audio(text: str)`: Convert text to speech and return an async iterator of `PcmData` chunks
+- `stop_audio()`: Stop audio playback (no-op for this plugin)
+- `send(text: str)`: Send text to be converted to speech (inherited from base class)

vision_agents_plugins_inworld-0.2.3/README.md

@@ -0,0 +1,67 @@
+# Inworld AI Text-to-Speech Plugin
+
+A high-quality Text-to-Speech (TTS) plugin for Vision Agents that uses the Inworld AI API with streaming support.
+
+## Installation
+
+```bash
+uv add vision-agents[inworld]
+```
+
+## Usage
+
+```python
+from vision_agents.plugins import inworld
+
+# Initialize with API key from environment variable
+tts = inworld.TTS()
+
+# Or specify API key and other options directly
+tts = inworld.TTS(
+    api_key="your_inworld_api_key",
+    voice_id="Dennis",
+    model_id="inworld-tts-1",
+    temperature=1.1
+)
+
+# Use with an Agent
+from vision_agents.core import Agent
+from vision_agents.plugins import getstream, gemini, smart_turn
+
+agent = Agent(
+    edge=getstream.Edge(),
+    tts=inworld.TTS(),
+    llm=gemini.LLM("gemini-2.0-flash"),
+    turn_detection=smart_turn.TurnDetection(),
+)
+```
+
+## Configuration Options
+
+- `api_key`: Inworld AI API key (default: reads from `INWORLD_API_KEY` environment variable)
+- `voice_id`: The voice ID to use for synthesis (default: "Dennis")
+- `model_id`: The model ID to use for synthesis. Options: "inworld-tts-1", "inworld-tts-1-max" (default: "inworld-tts-1")
+- `temperature`: Determines the degree of randomness when sampling audio tokens. Accepts values between 0 and 2 (default: 1.1)
+
+## Requirements
+
+- Python 3.10+
+- httpx>=0.27.0
+  "av>=10.0.0",
+
+## Getting Started
+
+1. Get your Inworld AI API key from the [Inworld Portal](https://studio.inworld.ai/)
+2. Set the `INWORLD_API_KEY` environment variable:
+   ```bash
+   export INWORLD_API_KEY="your_api_key_here"
+   ```
+3. Use the plugin in your Vision Agents application
+
+## API Reference
+
+The plugin implements the standard Vision Agents TTS interface:
+
+- `stream_audio(text: str)`: Convert text to speech and return an async iterator of `PcmData` chunks
+- `stop_audio()`: Stop audio playback (no-op for this plugin)
+- `send(text: str)`: Send text to be converted to speech (inherited from base class)

vision_agents_plugins_inworld-0.2.3/pyproject.toml

@@ -0,0 +1,42 @@
+[build-system]
+requires = ["hatchling", "hatch-vcs"]
+build-backend = "hatchling.build"
+
+[project]
+name = "vision-agents-plugins-inworld"
+dynamic = ["version"]
+description = "Inworld AI TTS integration for Vision Agents"
+readme = "README.md"
+keywords = ["inworld", "TTS", "text-to-speech", "AI", "voice agents", "agents"]
+requires-python = ">=3.10"
+license = "MIT"
+dependencies = [
+    "vision-agents",
+    "httpx>=0.27.0",
+    "av>=10.0.0",
+]
+
+[project.urls]
+Documentation = "https://visionagents.ai/"
+Website = "https://visionagents.ai/"
+Source = "https://github.com/GetStream/Vision-Agents"
+
+[tool.hatch.version]
+source = "vcs"
+raw-options = { root = "..", search_parent_directories = true, fallback_version = "0.0.0" }
+
+[tool.hatch.build.targets.wheel]
+packages = [".", "vision_agents"]
+
+[tool.hatch.build.targets.sdist]
+include = ["/vision_agents"]
+
+[tool.uv.sources]
+vision-agents = { workspace = true }
+
+[dependency-groups]
+dev = [
+    "pytest>=8.4.1",
+    "pytest-asyncio>=1.0.0",
+]
+

vision_agents_plugins_inworld-0.2.3/vision_agents/plugins/inworld/__init__.py

@@ -0,0 +1,3 @@
+from vision_agents.plugins.inworld.tts import TTS
+
+__all__ = ["TTS"]

vision_agents_plugins_inworld-0.2.3/vision_agents/plugins/inworld/tts.py

@@ -0,0 +1,172 @@
+import base64
+import io
+import json
+import logging
+import os
+from typing import AsyncIterator, Literal, Optional
+
+import av
+import httpx
+from getstream.video.rtc.track_util import PcmData
+
+from vision_agents.core import tts
+
+logger = logging.getLogger(__name__)
+
+INWORLD_API_BASE = "https://api.inworld.ai"
+
+
+class TTS(tts.TTS):
+    """
+    Inworld AI Text-to-Speech implementation.
+    Inworld AI provides high-quality text-to-speech synthesis with streaming support.
+    """
+
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        voice_id: str = "Dennis",
+        model_id: Literal["inworld-tts-1", "inworld-tts-1-max"] = "inworld-tts-1",
+        temperature: float = 1.1,
+    ):
+        """
+        Initialize the Inworld AI TTS service.
+        Args:
+            api_key: Inworld AI API key. If not provided, the INWORLD_API_KEY
+                    environment variable will be used.
+            voice_id: The voice ID to use for synthesis (default: "Dennis").
+            model_id: The model ID to use for synthesis. Options: "inworld-tts-1",
+                     "inworld-tts-1-max" (default: "inworld-tts-1").
+            temperature: Determines the degree of randomness when sampling audio tokens.
+                        Accepts values between 0 and 2. Default: 1.1.
+        """
+        super().__init__(provider_name="inworld")
+
+        api_key = api_key or os.getenv("INWORLD_API_KEY")
+        if not api_key:
+            raise ValueError(
+                "INWORLD_API_KEY environment variable must be set or api_key must be provided"
+            )
+
+        self.api_key = api_key
+        self.voice_id = voice_id
+        self.model_id = model_id
+        self.temperature = temperature
+        self.base_url = INWORLD_API_BASE
+        self.client = httpx.AsyncClient(timeout=60.0)
+
+    async def stream_audio(self, text: str, *_, **__) -> AsyncIterator[PcmData]:
+        """
+        Convert text to speech using Inworld AI API.
+        Args:
+            text: The text to convert to speech (max 2,000 characters).
+        Returns:
+            An async iterator of audio chunks as PcmData objects.
+        """
+        url = f"{self.base_url}/tts/v1/voice:stream"
+
+        credentials = f"Basic {self.api_key}"
+        headers = {
+            "Authorization": credentials,
+            "Content-Type": "application/json",
+        }
+
+        payload = {
+            "text": text,
+            "voiceId": self.voice_id,
+            "modelId": self.model_id,
+            "audioConfig": {
+                "temperature": self.temperature,
+            },
+        }
+
+        async def _stream_audio() -> AsyncIterator[PcmData]:
+            try:
+                async with self.client.stream(
+                    "POST", url, headers=headers, json=payload
+                ) as response:
+                    async for pcm in self._process_response(response):
+                        yield pcm
+            except httpx.HTTPStatusError as e:
+                logger.error(
+                    "Inworld AI API HTTP error: %s - %s",
+                    e.response.status_code,
+                    e.response.text,
+                )
+                raise
+            except Exception as e:
+                logger.error("Error streaming audio from Inworld AI: %s", e)
+                raise
+
+        # Return the async generator
+        return _stream_audio()
+
+    async def _process_response(
+        self, response: httpx.Response
+    ) -> AsyncIterator[PcmData]:
+        # Check status before processing streaming response
+        if response.status_code >= 400:
+            error_text = await response.aread()
+            error_msg = error_text.decode() if error_text else "Unknown error"
+            logger.error(
+                "Inworld AI API HTTP error: %s - %s",
+                response.status_code,
+                error_msg,
+            )
+            raise httpx.HTTPStatusError(
+                f"HTTP {response.status_code}: {error_msg}",
+                request=response.request,
+                response=response,
+            )
+
+        async for line in response.aiter_lines():
+            if not line.strip():
+                continue
+
+            try:
+                data = json.loads(line)
+                if "error" in data:
+                    error_msg = data["error"].get("message", "Unknown error")
+                    logger.error("Inworld AI API error: %s", error_msg)
+                    continue
+
+                if "result" in data and "audioContent" in data["result"]:
+                    wav_bytes = base64.b64decode(data["result"]["audioContent"])
+
+                    container = av.open(io.BytesIO(wav_bytes))
+                    assert isinstance(container, av.container.InputContainer)
+                    with container:
+                        audio_stream = container.streams.audio[0]
+                        pcm: Optional[PcmData] = None
+                        for frame in container.decode(audio_stream):
+                            frame_pcm = PcmData.from_av_frame(frame)
+                            if pcm is None:
+                                pcm = frame_pcm
+                            else:
+                                pcm.append(frame_pcm)
+
+                        if pcm:
+                            pcm = pcm.resample(
+                                target_sample_rate=pcm.sample_rate,
+                                target_channels=1,
+                            ).to_int16()
+                            yield pcm
+            except json.JSONDecodeError as e:
+                logger.warning("Failed to parse JSON line: %s", e)
+                continue
+            except Exception as e:
+                logger.warning("Error processing audio chunk: %s", e)
+                continue
+
+    async def stop_audio(self) -> None:
+        """
+        Clears the queue and stops playing audio.
+        This method can be used manually or under the hood in response to turn events.
+        Returns:
+            None
+        """
+        logger.info("🎤 Inworld AI TTS stop requested (no-op)")
+
+    async def close(self) -> None:
+        if self.client:
+            await self.client.aclose()