pipecat-sprag 0.1.0__py3-none-any.whl

pipecat_sprag/__init__.py

@@ -0,0 +1 @@
+"""Sprag speech and language models for Pipecat."""

pipecat_sprag/common/__init__.py

@@ -0,0 +1,26 @@
+"""Configuration shared by the Sprag Pipecat services."""
+
+import os
+from importlib.metadata import version
+
+__version__ = version("pipecat-sprag")
+
+SPRAG_BASE_URL = "https://api.sprag.ai/v1"
+SPRAG_TRANSCRIPTION_URL = "wss://api.sprag.ai/v1/audio/transcriptions"
+SPRAG_SPEECH_URL = "wss://api.sprag.ai/v1/audio/speech"
+ATTRIBUTION_HEADERS = {"X-Sprag-Integration": f"pipecat/{__version__}"}
+
+
+def resolve_api_key(api_key: str | None) -> str:
+    """Return the given API key, or ``SPRAG_API_KEY`` from the environment.
+
+    Raises:
+        ValueError: If neither is set.
+    """
+    resolved = api_key or os.environ.get("SPRAG_API_KEY")
+    if not resolved:
+        raise ValueError(
+            "SPRAG_API_KEY is required, either as the api_key argument or the "
+            "SPRAG_API_KEY environment variable"
+        )
+    return resolved

pipecat_sprag/llm/__init__.py

@@ -0,0 +1,5 @@
+"""Sprag LLM service for Pipecat."""
+
+from pipecat_sprag.llm.service import SpragLLMService, SpragLLMSettings
+
+__all__ = ["SpragLLMService", "SpragLLMSettings"]

pipecat_sprag/llm/service.py

@@ -0,0 +1,113 @@
+"""Sprag's Symphony model as a Pipecat LLM service."""
+
+from __future__ import annotations
+
+from collections.abc import AsyncIterator, Mapping
+from dataclasses import dataclass
+from typing import Any
+
+from openai import AsyncStream
+from openai.types.chat import ChatCompletionChunk
+from openai.types.completion_usage import CompletionTokensDetails, PromptTokensDetails
+from pipecat.processors.aggregators.llm_context import LLMContext
+from pipecat.services.openai.base_llm import OpenAILLMSettings
+from pipecat.services.openai.llm import OpenAILLMService
+
+from pipecat_sprag.common import ATTRIBUTION_HEADERS, SPRAG_BASE_URL, resolve_api_key
+
+
+@dataclass
+class SpragLLMSettings(OpenAILLMSettings):
+    """Settings for SpragLLMService."""
+
+
+class SpragLLMService(OpenAILLMService):
+    """Sprag's Symphony model through Sprag's OpenAI-compatible chat completions API.
+
+    Sprag reports usage per billing axis (``usage.input.text.tokens``,
+    ``usage.input.audio.duration`` and so on) rather than as ``prompt_tokens`` and
+    ``completion_tokens``. This service reports the text tokens in the fields Pipecat
+    reads, so usage metrics and function calls work. Media is billed on its own axes,
+    which Pipecat's token metrics have no place for; Sprag's full usage stays on the
+    chunk for anyone who needs it.
+    """
+
+    Settings = SpragLLMSettings
+    _settings: SpragLLMSettings
+
+    def __init__(
+        self,
+        *,
+        api_key: str | None = None,
+        base_url: str = SPRAG_BASE_URL,
+        default_headers: Mapping[str, str] | None = None,
+        settings: SpragLLMSettings | None = None,
+        **kwargs: Any,
+    ) -> None:
+        """Initialize the Sprag LLM service.
+
+        Args:
+            api_key: Your Sprag API key. Defaults to the ``SPRAG_API_KEY`` environment
+                variable.
+            base_url: The Sprag API base URL.
+            default_headers: Extra headers sent with every request.
+            settings: Runtime-updatable settings. The model defaults to ``symphony``.
+            **kwargs: Additional arguments passed to OpenAILLMService.
+        """
+        default_settings = self.Settings(model="symphony")
+        if settings is not None:
+            default_settings.apply_update(settings)
+        super().__init__(
+            api_key=resolve_api_key(api_key),
+            base_url=base_url,
+            default_headers={**ATTRIBUTION_HEADERS, **(default_headers or {})},
+            settings=default_settings,
+            **kwargs,
+        )
+
+    async def get_chat_completions(  # type: ignore[override]
+        self, context: LLMContext
+    ) -> _OpenAIUsageStream:
+        """Stream chat completions, with Sprag's usage mapped onto OpenAI's fields.
+
+        Args:
+            context: The context to complete.
+
+        Returns:
+            The chunk stream.
+        """
+        return _OpenAIUsageStream(await super().get_chat_completions(context))
+
+
+class _OpenAIUsageStream:
+    def __init__(self, stream: AsyncStream[ChatCompletionChunk]) -> None:
+        self._stream = stream
+
+    def __aiter__(self) -> AsyncIterator[ChatCompletionChunk]:
+        return self._iterate()
+
+    async def _iterate(self) -> AsyncIterator[ChatCompletionChunk]:
+        async for chunk in self._stream:
+            yield _with_openai_usage(chunk)
+
+    async def close(self) -> None:
+        await self._stream.close()
+
+
+def _with_openai_usage(chunk: ChatCompletionChunk) -> ChatCompletionChunk:
+    usage = chunk.usage
+    if usage is None or usage.prompt_tokens is not None:
+        return chunk
+    extra = usage.model_extra or {}
+    text_in: dict[str, Any] = (extra.get("input") or {}).get("text") or {}
+    text_out: dict[str, Any] = (extra.get("output") or {}).get("text") or {}
+    usage.prompt_tokens = text_in.get("tokens") or 0
+    usage.completion_tokens = text_out.get("tokens") or 0
+    usage.total_tokens = usage.prompt_tokens + usage.completion_tokens
+    if text_in.get("cached_tokens"):
+        usage.prompt_tokens_details = PromptTokensDetails(cached_tokens=text_in["cached_tokens"])
+    if text_out.get("reasoning_tokens"):
+        usage.completion_tokens_details = CompletionTokensDetails(
+            reasoning_tokens=text_out["reasoning_tokens"]
+        )
+    return chunk

pipecat_sprag/stt/__init__.py

@@ -0,0 +1,5 @@
+"""Sprag STT service for Pipecat."""
+
+from pipecat_sprag.stt.service import SpragSTTService, SpragSTTSettings
+
+__all__ = ["SpragSTTService", "SpragSTTSettings"]

pipecat_sprag/stt/service.py

@@ -0,0 +1,62 @@
+"""Sprag's Rhythm model as a Pipecat speech-to-text service."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Literal
+
+from pipecat.services.openai.stt import OpenAIRealtimeSTTService, OpenAIRealtimeSTTSettings
+
+from pipecat_sprag.common import SPRAG_TRANSCRIPTION_URL, resolve_api_key
+
+
+@dataclass
+class SpragSTTSettings(OpenAIRealtimeSTTSettings):
+    """Settings for SpragSTTService."""
+
+
+class SpragSTTService(OpenAIRealtimeSTTService):
+    """Streaming transcription with Rhythm over Sprag's streaming transcription socket.
+
+    By default the pipeline's own VAD decides when a turn ends. Pass
+    ``turn_detection={"type": "server_vad"}`` to have Sprag detect turns instead.
+
+    Unlike the LLM and TTS services, it sends no ``X-Sprag-Integration`` header: Pipecat's
+    realtime STT connects with a fixed set of headers.
+    """
+
+    Settings = SpragSTTSettings
+    _settings: SpragSTTSettings
+
+    def __init__(
+        self,
+        *,
+        api_key: str | None = None,
+        base_url: str = SPRAG_TRANSCRIPTION_URL,
+        turn_detection: dict[str, Any] | Literal[False] | None = False,
+        settings: SpragSTTSettings | None = None,
+        **kwargs: Any,
+    ) -> None:
+        """Initialize the Sprag STT service.
+
+        Args:
+            api_key: Your Sprag API key. Defaults to the ``SPRAG_API_KEY`` environment
+                variable.
+            base_url: The Sprag streaming transcription WebSocket URL.
+            turn_detection: ``False`` (the default) leaves turn detection to the
+                pipeline's VAD. A dict such as ``{"type": "server_vad"}`` enables
+                Sprag's server-side VAD.
+            settings: Runtime-updatable settings. The model defaults to ``rhythm``.
+            **kwargs: Additional arguments passed to OpenAIRealtimeSTTService.
+        """
+        # Rhythm takes no language parameter
+        default_settings = self.Settings(model="rhythm", language=None)
+        if settings is not None:
+            default_settings.apply_update(settings)
+        super().__init__(
+            api_key=resolve_api_key(api_key),
+            base_url=base_url,
+            turn_detection=turn_detection,
+            settings=default_settings,
+            **kwargs,
+        )

pipecat_sprag/tts/__init__.py

@@ -0,0 +1,5 @@
+"""Sprag TTS service for Pipecat."""
+
+from pipecat_sprag.tts.service import SpragTTSService, SpragTTSSettings
+
+__all__ = ["SpragTTSService", "SpragTTSSettings"]

pipecat_sprag/tts/service.py

@@ -0,0 +1,366 @@
+"""Sprag's Chorus models as a Pipecat text-to-speech service."""
+
+from __future__ import annotations
+
+import asyncio
+import base64
+import json
+import uuid
+from collections import Counter
+from collections.abc import AsyncGenerator
+from dataclasses import dataclass
+from typing import Any
+from urllib.parse import urlencode, urlsplit, urlunsplit
+
+from pipecat.frames.frames import (
+    ErrorFrame,
+    Frame,
+    StartFrame,
+    TTSAudioRawFrame,
+    TTSStoppedFrame,
+)
+from pipecat.services.settings import TTSSettings
+from pipecat.services.tts_service import InterruptibleTTSService
+from websockets.asyncio.client import ClientConnection
+from websockets.protocol import State
+
+from pipecat_sprag.common import ATTRIBUTION_HEADERS, SPRAG_SPEECH_URL, resolve_api_key
+
+SAMPLE_RATE = 24000
+
+
+@dataclass
+class SpragTTSSettings(TTSSettings):
+    """Settings for SpragTTSService."""
+
+
+class SpragTTSService(InterruptibleTTSService):
+    """Streaming speech with Sprag's Chorus models over Sprag's streaming speech socket.
+
+    Each sentence is spoken as its own response, sent as soon as Pipecat hands it over;
+    the session queues responses and speaks them in order. Each response carries its
+    turn's context id as metadata, which routes its audio back to that turn. Sprag
+    cannot stop a response once it has started, so an interruption replaces the
+    connection rather than cancelling. Sentences sent on a connection that drops are
+    lost; sentences that arrive while it reconnects are spoken on the new one.
+    """
+
+    Settings = SpragTTSSettings
+    _settings: SpragTTSSettings
+
+    def __init__(
+        self,
+        *,
+        api_key: str | None = None,
+        url: str = SPRAG_SPEECH_URL,
+        connect_timeout: float = 10.0,
+        settings: SpragTTSSettings | None = None,
+        **kwargs: Any,
+    ) -> None:
+        """Initialize the Sprag TTS service.
+
+        Args:
+            api_key: Your Sprag API key. Defaults to the ``SPRAG_API_KEY`` environment
+                variable.
+            url: The Sprag streaming speech WebSocket URL.
+            connect_timeout: Seconds the session may take to be configured.
+            settings: Runtime-updatable settings. Defaults to the ``chorus`` model
+                and the ``wade`` voice.
+            **kwargs: Additional arguments passed to InterruptibleTTSService.
+        """
+        default_settings = self.Settings(model="chorus", voice="wade", language=None)
+        if settings is not None:
+            default_settings.apply_update(settings)
+        super().__init__(
+            push_start_frame=True,
+            push_stop_frames=True,
+            pause_frame_processing=True,
+            sample_rate=SAMPLE_RATE,
+            settings=default_settings,
+            **kwargs,
+        )
+        self._api_key = resolve_api_key(api_key)
+        self._url = url
+        self._connect_timeout = connect_timeout
+        self._receive_task: asyncio.Task[None] | None = None
+        self._unfinished: Counter[str] = Counter()
+        self._flushed: set[str] = set()
+        self._unstarted: dict[str, tuple[str, str]] = {}
+        self._held: list[tuple[str, str]] = []
+        self._speaking_context: str | None = None
+        # run_tts and the receive loop's reconnect may both reach for a new socket
+        self._connect_lock = asyncio.Lock()
+
+    def can_generate_metrics(self) -> bool:
+        """Report that this service emits TTFB and usage metrics.
+
+        Returns:
+            True.
+        """
+        return True
+
+    async def start(self, frame: StartFrame) -> None:
+        """Connect when the pipeline starts.
+
+        Args:
+            frame: The start frame.
+        """
+        await super().start(frame)
+        await self._connect()
+
+    async def _update_settings(self, delta: TTSSettings) -> dict[str, Any]:  # type: ignore[override]
+        changed = await super()._update_settings(delta)
+        if changed:
+            # model and voice are fixed for the life of a session
+            await self._disconnect()
+            await self._connect()
+        return changed
+
+    async def _connect(self) -> None:
+        await super()._connect()
+        await self._connect_websocket()
+        if self._websocket and (not self._receive_task or self._receive_task.done()):
+            self._receive_task = self.create_task(self._receive_task_handler(self._report_error))
+
+    async def _disconnect(self) -> None:
+        await super()._disconnect()
+        if self._receive_task:
+            await self.cancel_task(self._receive_task, timeout=1.0)
+            self._receive_task = None
+        await self._disconnect_websocket()
+
+    async def _connect_websocket(self) -> None:
+        async with self._connect_lock:
+            await self._open_session()
+
+    async def _open_session(self) -> None:
+        if self._websocket and self._websocket.state is State.OPEN:
+            return
+        if self._websocket is not None:
+            # closed without passing through _disconnect_websocket, e.g. with no reconnect
+            await self._strand()
+        self._websocket = None
+        parts = urlsplit(self._url)
+        query = "&".join(q for q in (parts.query, urlencode({"model": self._settings.model})) if q)
+        # an interrupted turn's held sentences are dropped
+        waiting, self._held = self._held, []
+        unsent = []
+        for context_id, text in waiting:
+            if self.audio_context_available(context_id):
+                unsent.append((context_id, text))
+            else:
+                await self._finish_response(context_id)
+        websocket: ClientConnection | None = None
+        try:
+            websocket = await self._websocket_connect(
+                urlunsplit(parts._replace(query=query)),
+                additional_headers={
+                    "Authorization": f"Bearer {self._api_key}",
+                    **ATTRIBUTION_HEADERS,
+                },
+            )
+            await asyncio.wait_for(
+                self._configure_session(websocket), timeout=self._connect_timeout
+            )
+            # sent before the socket is visible, so they keep their place ahead of new sentences
+            while unsent:
+                context_id, text = unsent.pop(0)
+                await self._request(websocket, context_id, text)
+        except BaseException as e:
+            if websocket:
+                await websocket.close()
+            for context_id, _ in self._unstarted.values():
+                await self._finish_response(context_id)
+            self._unstarted.clear()
+            self._held = unsent + self._held
+            if not isinstance(e, Exception):
+                raise
+            await self.push_error(error_msg=f"Error connecting to Sprag TTS: {e}", exception=e)
+            return
+        # run_tts may send as soon as the socket is visible, so it becomes visible configured
+        self._websocket = websocket
+        await self._call_event_handler("on_connected")
+
+    async def _configure_session(self, websocket: ClientConnection) -> None:
+        session = {"type": "realtime", "audio": {"output": {"voice": self._settings.voice}}}
+        await websocket.send(json.dumps({"type": "session.update", "session": session}))
+        async for message in websocket:
+            event = json.loads(message)
+            if event.get("type") == "session.updated":
+                return
+            if event.get("type") == "error":
+                raise RuntimeError(_error_message(event))
+        raise ConnectionError("the session closed before it was configured")
+
+    async def _disconnect_websocket(self) -> None:
+        try:
+            if self._websocket:
+                await self._websocket.close()
+        finally:
+            self._websocket = None
+            await self._strand()
+            await self._call_event_handler("on_disconnected")
+
+    async def _strand(self) -> None:
+        stranded = [context_id for context_id, _ in self._unstarted.values()]
+        self._unstarted.clear()
+        speaking, self._speaking_context = self._speaking_context, None
+        if speaking is not None:
+            stranded.append(speaking)
+        for context_id in stranded:
+            await self._finish_response(context_id)
+
+    async def flush_audio(self, context_id: str | None = None) -> None:
+        """Close the turn's audio context once its last response has finished.
+
+        Args:
+            context_id: The turn's audio context.
+        """
+        if not context_id:
+            return
+        if self._unfinished[context_id]:
+            self._flushed.add(context_id)
+        else:
+            await self._close_context(context_id)
+
+    async def _close_context(self, context_id: str) -> None:
+        if self.audio_context_available(context_id):
+            await self.append_to_audio_context(context_id, TTSStoppedFrame(context_id=context_id))
+            await self.remove_audio_context(context_id)
+
+    async def _receive_messages(self) -> None:
+        assert self._websocket is not None
+        async for message in self._websocket:
+            if not isinstance(message, str):
+                continue
+            event = json.loads(message)
+            event_type = event.get("type")
+            if event_type == "response.created":
+                self._on_response_created(event)
+            elif event_type == "response.output_audio.delta":
+                await self._on_audio(event)
+            elif event_type == "response.done":
+                await self._on_response_done(event)
+            elif event_type == "error":
+                await self._on_error(event)
+
+    def _on_response_created(self, event: dict[str, Any]) -> None:
+        context_id = _context_of(event)
+        self._speaking_context = context_id
+        # responses start in the order they were asked for, so this answers the turn's oldest
+        for event_id, (owner, _) in self._unstarted.items():
+            if owner == context_id:
+                del self._unstarted[event_id]
+                break
+
+    async def _on_audio(self, event: dict[str, Any]) -> None:
+        context_id = self._speaking_context
+        if context_id is None or not self.audio_context_available(context_id):
+            return  # an interrupted turn's queued responses still play out on the session
+        await self.stop_ttfb_metrics()
+        frame = TTSAudioRawFrame(
+            audio=base64.b64decode(event["delta"]),
+            sample_rate=self.sample_rate,
+            num_channels=1,
+            context_id=context_id,
+        )
+        await self.append_to_audio_context(context_id, frame)
+
+    async def _on_response_done(self, event: dict[str, Any]) -> None:
+        response = event.get("response") or {}
+        if response.get("status") != "completed":
+            error = (response.get("status_details") or {}).get("error") or {}
+            await self.push_error(
+                error_msg=f"Sprag TTS response ended as {response.get('status')}: "
+                f"{error.get('code', 'unknown')}"
+            )
+        self._speaking_context = None
+        context_id = _context_of(event)
+        if context_id is not None:
+            await self._finish_response(context_id)
+
+    async def _on_error(self, event: dict[str, Any]) -> None:
+        await self.push_error(error_msg=_error_message(event))
+        # a refused response.create opens no response
+        refused = self._unstarted.pop((event.get("error") or {}).get("event_id") or "", None)
+        if refused is not None:
+            await self._finish_response(refused[0])
+
+    async def _finish_response(self, context_id: str) -> None:
+        self._unfinished[context_id] -= 1
+        if self._unfinished[context_id] > 0:
+            return
+        del self._unfinished[context_id]
+        if context_id in self._flushed:
+            self._flushed.discard(context_id)
+            await self._close_context(context_id)
+
+    async def run_tts(self, text: str, context_id: str) -> AsyncGenerator[Frame | None, None]:
+        """Speak one sentence as a response on the session.
+
+        Args:
+            text: The sentence to speak.
+            context_id: The turn's audio context.
+
+        Yields:
+            Nothing directly; audio arrives on the receive task.
+        """
+        reconnecting = self._receive_task is not None and not self._receive_task.done()
+        if self._websocket and self._websocket.state is not State.OPEN and reconnecting:
+            # the receive loop's reconnect sends it once the new session is configured
+            self._unfinished[context_id] += 1
+            self._held.append((context_id, text))
+            await self.start_tts_usage_metrics(text)
+            yield None
+            return
+        if not self._websocket or self._websocket.state is not State.OPEN:
+            await self._connect()
+        if not self._websocket:
+            yield ErrorFrame(error="Sprag TTS is not connected")
+            return
+        self._unfinished[context_id] += 1
+        websocket = self._websocket
+        try:
+            await self._request(websocket, context_id, text)
+        except Exception as e:
+            yield ErrorFrame(error=f"Sprag TTS send error: {e}")
+            return
+        await self.start_tts_usage_metrics(text)
+        yield None
+
+    async def _request(self, websocket: ClientConnection, context_id: str, text: str) -> None:
+        item = {
+            "type": "message",
+            "role": "user",
+            "content": [{"type": "input_text", "text": text}],
+        }
+        event_id = f"evt_{uuid.uuid4().hex}"
+        create = {
+            "type": "response.create",
+            "event_id": event_id,
+            "response": {"metadata": {_CONTEXT_KEY: context_id}},
+        }
+        # recorded first: the response can start before the send returns
+        self._unstarted[event_id] = (context_id, text)
+        try:
+            await websocket.send(json.dumps({"type": "conversation.item.create", "item": item}))
+            await websocket.send(json.dumps(create))
+        except Exception:
+            # a drop noticed mid-send has already released it
+            if self._unstarted.pop(event_id, None) is not None:
+                await self._finish_response(context_id)
+            raise
+
+
+_CONTEXT_KEY = "context_id"
+
+
+def _context_of(event: dict[str, Any]) -> str | None:
+    metadata = (event.get("response") or {}).get("metadata") or {}
+    context_id = metadata.get(_CONTEXT_KEY)
+    return context_id if isinstance(context_id, str) else None
+
+
+def _error_message(event: dict[str, Any]) -> str:
+    error = event.get("error") or {}
+    return f"Sprag TTS error [{error.get('code', 'unknown')}]: {error.get('message', '')}"

pipecat_sprag-0.1.0.dist-info/METADATA

@@ -0,0 +1,88 @@
+Metadata-Version: 2.5
+Name: pipecat-sprag
+Version: 0.1.0
+Summary: Sprag speech and language models for Pipecat: Rhythm STT, Symphony LLM, and Chorus TTS
+Project-URL: Homepage, https://sprag.ai
+Project-URL: Source, https://github.com/sprag-ai/pipecat-sprag
+Project-URL: Changelog, https://github.com/sprag-ai/pipecat-sprag/blob/main/CHANGELOG.md
+Author: Sprag AI Inc.
+License-Expression: BSD-2-Clause
+License-File: LICENSE
+Keywords: ai,llm,pipecat,sprag,stt,tts,voice
+Requires-Python: >=3.11
+Requires-Dist: pipecat-ai<2,>=1.8
+Description-Content-Type: text/markdown
+
+# pipecat-sprag
+
+[Sprag](https://sprag.ai/) speech and language models for [Pipecat](https://github.com/pipecat-ai/pipecat).
+
+This integration is maintained by Sprag.
+
+| Service | Import | Model |
+| --- | --- | --- |
+| `SpragSTTService` | `pipecat_sprag.stt` | Rhythm (speech to text) |
+| `SpragLLMService` | `pipecat_sprag.llm` | Symphony (LLM) |
+| `SpragTTSService` | `pipecat_sprag.tts` | Chorus (text to speech) |
+
+## Installation
+
+```bash
+uv add pipecat-sprag
+```
+
+Each service reads your API key from the `SPRAG_API_KEY` environment variable, or takes it as `api_key=`. You can generate a key from [API keys](https://sprag.ai/app/api-keys) in the Sprag app.
+
+## Usage
+
+Each service drops into a Pipecat pipeline in place of any other STT, LLM, or TTS service:
+
+```python
+from pipecat_sprag.llm import SpragLLMService
+from pipecat_sprag.stt import SpragSTTService
+from pipecat_sprag.tts import SpragTTSService
+
+stt = SpragSTTService()
+llm = SpragLLMService()
+tts = SpragTTSService(settings=SpragTTSService.Settings(voice="wade"))
+
+pipeline = Pipeline(
+    [transport.input(), stt, user_aggregator, llm, tts, transport.output(), assistant_aggregator]
+)
+```
+
+- **`SpragSTTService`** streams audio to Rhythm over Sprag's streaming transcription socket (`wss://api.sprag.ai/v1/audio/transcriptions`). By default your pipeline's VAD decides when a turn ends; pass `turn_detection={"type": "server_vad"}` to let Sprag detect turns instead.
+- **`SpragLLMService`** runs Symphony through Sprag's chat completions API, with function calling and token usage metrics.
+- **`SpragTTSService`** streams Chorus speech over Sprag's streaming speech socket (`wss://api.sprag.ai/v1/audio/speech`), one sentence at a time. It defaults to the `chorus` model and the `wade` voice; the available voices are listed in [voice presets](https://sprag.ai/docs/tts/voices/presets).
+
+Each service takes `settings=<Service>.Settings(...)` for its model and other options, and `api_key=` if you don't use the `SPRAG_API_KEY` environment variable.
+
+## Example
+
+[`examples/voice_agent.py`](https://github.com/sprag-ai/pipecat-sprag/blob/main/examples/voice_agent.py) is a complete voice agent running on Rhythm, Symphony, and Chorus. It uses Pipecat's development runner:
+
+```bash
+uv sync --group examples
+SPRAG_API_KEY=... uv run examples/voice_agent.py
+```
+
+Then open the printed URL in your browser and talk to it.
+
+## Compatibility
+
+Requires `pipecat-ai>=1.8,<2`. Tested with Pipecat v1.12.0.
+
+## Development
+
+```bash
+uv sync
+uv run ruff check && uv run ruff format --check
+uv run mypy src
+uv run pytest
+```
+
+Live tests call api.sprag.ai and are skipped by default: `SPRAG_API_KEY=... uv run pytest -m live`.
+
+## License
+
+BSD 2-Clause. See [LICENSE](https://github.com/sprag-ai/pipecat-sprag/blob/main/LICENSE).

pipecat_sprag-0.1.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+pipecat_sprag/__init__.py,sha256=jj2K0aFVnG84gV3ejUynpqi-17Y-PSiq8QXsYLtQMkI,52
+pipecat_sprag/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pipecat_sprag/common/__init__.py,sha256=0NNFzV3i8kMxiAr9tr7Be21AfeG4-Tmwqm50yKK0JDU,842
+pipecat_sprag/llm/__init__.py,sha256=yeeXswaYPrHgANdEbSFD-T1tJL4NK0Bw18sRn-Cp_Vk,161
+pipecat_sprag/llm/service.py,sha256=F8K-ymsQAvXyxbBifyZ76SdXuCFssMwAGfVO7ERazoY,4246
+pipecat_sprag/stt/__init__.py,sha256=jGqgnxSc20aEw2cd_9yEFnNTET32LypKyv5hcRK2HL4,161
+pipecat_sprag/stt/service.py,sha256=IN5D_9dog7s5M3MoXMLMenwqWTMvk4YnSrzDUec_dA0,2281
+pipecat_sprag/tts/__init__.py,sha256=qMGkkp7nXpdI4hDtgKQxlXsV73S-UMB1lT_aWEDU5LU,161
+pipecat_sprag/tts/service.py,sha256=vP6vZZHvHklzQDEEz5T14DfLtH_Qwwf2x4s6nGtJYUw,14657
+pipecat_sprag-0.1.0.dist-info/METADATA,sha256=XZuiKZMlh3isIJMxjrv3FUs1vjxjqrNm6QQVgRIK5MM,3354
+pipecat_sprag-0.1.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+pipecat_sprag-0.1.0.dist-info/licenses/LICENSE,sha256=Rxht0FLOjOvZJpEgMfaL9cpa0abj13KIs3gW1y2n2OY,1302
+pipecat_sprag-0.1.0.dist-info/RECORD,,

pipecat_sprag-0.1.0.dist-info/WHEEL

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

pipecat_sprag-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,24 @@
+BSD 2-Clause License
+
+Copyright (c) 2026, Sprag AI Inc.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.