dv-pipecat-ai 0.0.93.dev101__tar.gz → 0.0.93.dev103__tar.gz

{dv_pipecat_ai-0.0.93.dev101/src/dv_pipecat_ai.egg-info → dv_pipecat_ai-0.0.93.dev103}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dv-pipecat-ai
-Version: 0.0.93.dev101
+Version: 0.0.93.dev103
 Summary: An open source framework for voice (and multimodal) assistants
 License-Expression: BSD-2-Clause
 Project-URL: Source, https://github.com/pipecat-ai/pipecat

{dv_pipecat_ai-0.0.93.dev101 → dv_pipecat_ai-0.0.93.dev103/src/dv_pipecat_ai.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dv-pipecat-ai
-Version: 0.0.93.dev101
+Version: 0.0.93.dev103
 Summary: An open source framework for voice (and multimodal) assistants
 License-Expression: BSD-2-Clause
 Project-URL: Source, https://github.com/pipecat-ai/pipecat

{dv_pipecat_ai-0.0.93.dev101 → dv_pipecat_ai-0.0.93.dev103}/src/dv_pipecat_ai.egg-info/SOURCES.txt

@@ -362,6 +362,8 @@ src/pipecat/services/inworld/__init__.py
 src/pipecat/services/inworld/tts.py
 src/pipecat/services/lmnt/__init__.py
 src/pipecat/services/lmnt/tts.py
+src/pipecat/services/maya/__init__.py
+src/pipecat/services/maya/tts.py
 src/pipecat/services/mem0/__init__.py
 src/pipecat/services/mem0/memory.py
 src/pipecat/services/minimax/__init__.py

{dv_pipecat_ai-0.0.93.dev101 → dv_pipecat_ai-0.0.93.dev103}/src/dv_pipecat_ai.egg-info/scm_file_list.json

@@ -126,6 +126,8 @@
     "src/pipecat/services/mem0/__init__.py",
     "src/pipecat/services/neuphonic/tts.py",
     "src/pipecat/services/neuphonic/__init__.py",
+    "src/pipecat/services/maya/tts.py",
+    "src/pipecat/services/maya/__init__.py",
     "src/pipecat/services/perplexity/llm.py",
     "src/pipecat/services/perplexity/__init__.py",
     "src/pipecat/services/rime/tts.py",
@@ -830,6 +832,7 @@
     "examples/ringg-chatbot/rag/helpers.py",
     "examples/ringg-chatbot/rag/weaviate_script.py",
     "tests/test_openai_responses_websocket.py",
+    "tests/test_maya_tts.py",
     "tests/test_daily_transport_service.py",
     "tests/test_openai_responses_adapter.py",
     "tests/test_llm_response.py",

{dv_pipecat_ai-0.0.93.dev101 → dv_pipecat_ai-0.0.93.dev103}/src/dv_pipecat_ai.egg-info/scm_version.json

@@ -1,7 +1,7 @@
 {
   "tag": "0.0.92",
-  "distance": 101,
-  "node": "g49471f0121dde35ce3039d1c7ad3bb3febb8cf83",
+  "distance": 103,
+  "node": "gab00bd6e279f852c4782ee9851c4a1e79ee1328e",
   "dirty": false,
   "branch": "dv-stage",
   "node_date": "2026-07-22"

dv_pipecat_ai-0.0.93.dev103/src/pipecat/services/maya/__init__.py

@@ -0,0 +1,9 @@
+#
+# Copyright (c) 2024–2025, Daily
+#
+# SPDX-License-Identifier: BSD 2-Clause License
+#
+
+from .tts import MayaTTSService
+
+__all__ = ["MayaTTSService"]

dv_pipecat_ai-0.0.93.dev103/src/pipecat/services/maya/tts.py

@@ -0,0 +1,222 @@
+#
+# Copyright (c) 2024–2025, Daily
+#
+# SPDX-License-Identifier: BSD 2-Clause License
+#
+
+"""Maya Text-to-Speech service implementation.
+
+This module implements text-to-speech synthesis using Maya Research's HTTP API.
+Maya specializes in ten Indian languages (Hindi, Bengali, Gujarati, Kannada,
+Malayalam, Marathi, Odia, Punjabi, Tamil, Telugu) with two voices — "Ananya"
+(female) and "Arjun" (male). It streams raw PCM (16-bit LE, mono, 24000 Hz)
+over a single HTTP POST, so audio can be forwarded as it arrives.
+"""
+
+from typing import AsyncGenerator, Optional
+
+import aiohttp
+from loguru import logger
+from pydantic import BaseModel
+from typing_extensions import override
+
+from pipecat.frames.frames import (
+    ErrorFrame,
+    Frame,
+    TTSStartedFrame,
+    TTSStoppedFrame,
+)
+from pipecat.services.tts_service import TTSService
+from pipecat.transcriptions.language import Language
+from pipecat.utils.tracing.service_decorators import traced_tts
+
+# Maya's fixed output rate. The endpoint always returns 24000 Hz mono 16-bit LE
+# PCM; downstream transports resample to their own output rate.
+MAYA_SAMPLE_RATE = 24000
+
+
+def language_to_maya_language(language: Language) -> Optional[str]:
+    """Convert a pipecat Language to Maya's base language code.
+
+    Maya accepts only bare base codes (``hi``, ``bn``, ...) — there is no
+    auto-detect and locale-qualified codes are not accepted. Regional variants
+    (e.g. ``hi-IN``, ``ta-LK``) collapse to their base code.
+
+    Args:
+        language: The pipecat Language enum value.
+
+    Returns:
+        The Maya base language code, or None if unsupported.
+    """
+    LANGUAGE_MAP = {
+        Language.HI: "hi",
+        Language.HI_IN: "hi",
+        Language.BN: "bn",
+        Language.BN_BD: "bn",
+        Language.BN_IN: "bn",
+        Language.GU: "gu",
+        Language.GU_IN: "gu",
+        Language.KN: "kn",
+        Language.KN_IN: "kn",
+        Language.ML: "ml",
+        Language.ML_IN: "ml",
+        Language.MR: "mr",
+        Language.MR_IN: "mr",
+        Language.OR: "or",
+        Language.OR_IN: "or",
+        Language.PA: "pa",
+        Language.PA_IN: "pa",
+        Language.TA: "ta",
+        Language.TA_IN: "ta",
+        Language.TA_LK: "ta",
+        Language.TA_MY: "ta",
+        Language.TA_SG: "ta",
+        Language.TE: "te",
+        Language.TE_IN: "te",
+    }
+    return LANGUAGE_MAP.get(language)
+
+
+class MayaTTSService(TTSService):
+    """Maya Research Text-to-Speech service.
+
+    Uses Maya's HTTP API for streaming synthesis of ten Indian languages. The
+    endpoint returns headerless raw PCM (16-bit LE, mono, 24000 Hz) that begins
+    arriving before the full clip is generated, so frames are emitted as they
+    stream in.
+
+    Args:
+        api_key: Maya API key for authentication (Bearer token).
+        voice_id: Maya voice name — "Ananya" (female) or "Arjun" (male).
+        params: Additional generation parameters (language).
+        base_url: Maya API base URL.
+        aiohttp_session: Optional aiohttp session for connection pooling.
+        **kwargs: Additional arguments passed to TTSService.
+    """
+
+    class InputParams(BaseModel):
+        """Configuration parameters for Maya TTS service.
+
+        Parameters:
+            language: Language for synthesis. Maya has no auto-detect, so this
+                selects how the text is pronounced.
+        """
+
+        language: Optional[Language] = Language.HI
+
+    def __init__(
+        self,
+        *,
+        api_key: str,
+        voice_id: str,
+        params: Optional["MayaTTSService.InputParams"] = None,
+        base_url: str = "https://tts.mayaresearch.ai",
+        aiohttp_session: Optional[aiohttp.ClientSession] = None,
+        sample_rate: Optional[int] = MAYA_SAMPLE_RATE,
+        **kwargs,
+    ):
+        super().__init__(sample_rate=sample_rate, **kwargs)
+
+        params = params or MayaTTSService.InputParams()
+
+        self._api_key = api_key
+        self._base_url = base_url.rstrip("/")
+        self._endpoint = f"{self._base_url}/v1/tts"
+        self._aiohttp_session = aiohttp_session
+
+        self.set_voice(voice_id)
+
+        self._settings = {
+            "language": self.language_to_service_language(params.language)
+            if params.language
+            else "hi",
+        }
+
+    def can_generate_metrics(self) -> bool:
+        """Maya TTS supports TTFB and usage metrics."""
+        return True
+
+    def language_to_service_language(self, language: Language) -> Optional[str]:
+        """Convert a pipecat Language to Maya's base language code.
+
+        Args:
+            language: The language to convert.
+
+        Returns:
+            The Maya-specific base language code, or None if unsupported.
+        """
+        return language_to_maya_language(language)
+
+    @traced_tts
+    @override
+    async def run_tts(self, text: str) -> AsyncGenerator[Frame, None]:
+        """Run streaming text-to-speech synthesis on the provided text.
+
+        Args:
+            text: The text to synthesize.
+
+        Yields:
+            Frame: TTSStartedFrame, TTSAudioRawFrame(s), TTSStoppedFrame, or
+                ErrorFrame on failure.
+        """
+        logger.debug(f"{self}: Generating Maya TTS [{text}]")
+
+        payload = {
+            "voice": self._voice_id,
+            "text": text,
+            "language": self._settings["language"],
+        }
+        headers = {
+            "Authorization": f"Bearer {self._api_key}",
+            "Content-Type": "application/json",
+            # A non-empty user-agent avoids a spurious 403 from the request
+            # filter reacting to some HTTP clients' default agent.
+            "User-Agent": "ringg-bot/1.0",
+        }
+
+        session = self._aiohttp_session
+        should_close_session = False
+        if not session:
+            session = aiohttp.ClientSession()
+            should_close_session = True
+
+        try:
+            await self.start_ttfb_metrics()
+
+            # Keep the response context open for the whole streaming loop so it
+            # is closed cleanly on interruption/cancel — Maya counts an
+            # abandoned, un-closed response against its concurrency cap.
+            async with session.post(
+                self._endpoint,
+                json=payload,
+                headers=headers,
+                timeout=aiohttp.ClientTimeout(total=120),
+            ) as response:
+                if response.status != 200:
+                    error_text = await response.text()
+                    error_message = (
+                        f"Maya TTS error: HTTP {response.status} - {error_text}"
+                    )
+                    logger.error(error_message)
+                    yield ErrorFrame(error=error_message)
+                    return
+
+                await self.start_tts_usage_metrics(text)
+
+                yield TTSStartedFrame()
+
+                async for frame in self._stream_audio_frames_from_iterator(
+                    response.content.iter_chunked(self.chunk_size),
+                    strip_wav_header=False,
+                ):
+                    await self.stop_ttfb_metrics()
+                    yield frame
+
+        except Exception as e:
+            logger.exception(f"Error generating Maya TTS: {e}")
+            yield ErrorFrame(error=f"Maya TTS error: {str(e)}")
+        finally:
+            await self.stop_ttfb_metrics()
+            if should_close_session:
+                await session.close()
+            yield TTSStoppedFrame()

{dv_pipecat_ai-0.0.93.dev101 → dv_pipecat_ai-0.0.93.dev103}/src/pipecat/services/openai/base_llm.py

@@ -360,6 +360,10 @@ class BaseOpenAILLMService(LLMService):
         # Capture API response headers for latency monitoring
         _api_processing_ms = None
         _x_request_id = None
+        # Completion id from the response chunks (e.g. "chatcmpl-..."); OpenAI-
+        # compatible proxies pass it through so it can be correlated with the
+        # upstream/provider request.
+        _response_id = None
         if hasattr(chunk_stream, "response") and chunk_stream.response:
             # Some OpenAI-compatible proxies return a response object whose
             # `headers` is None; guard so latency capture never raises.
@@ -369,6 +373,13 @@ class BaseOpenAILLMService(LLMService):
                 _x_request_id = _h.get("x-request-id")
 
         async for chunk in chunk_stream:
+            if not _response_id:
+                # Some proxies (e.g. SLNG/litellm) emit a leading chunk with an
+                # empty id + empty choices before the real completion chunk, so
+                # only capture a non-empty id.
+                _cid = getattr(chunk, "id", None)
+                if _cid:
+                    _response_id = _cid
             if chunk.usage:
                 cached_tokens = (
                     chunk.usage.prompt_tokens_details.cached_tokens
@@ -444,7 +455,8 @@ class BaseOpenAILLMService(LLMService):
             f"model={self.model_name} | ttft_ms={_ttft_str} | "
             f"api_processing_ms={_api_processing_ms or 'N/A'} | "
             f"overhead_ms={_overhead_str} | "
-            f"x_request_id={_x_request_id or 'N/A'}"
+            f"x_request_id={_x_request_id or 'N/A'} | "
+            f"response_id={_response_id or 'N/A'}"
         )
 
         # if we got a function name and arguments, check to see if it's a function with