agentle 0.9.4__py3-none-any.whl → 0.9.28__py3-none-any.whl

agentle/tts/elevenlabs_tts_provider.py

@@ -0,0 +1,108 @@
+from __future__ import annotations
+
+import base64
+import os
+from collections.abc import AsyncIterator
+from typing import TYPE_CHECKING, override
+
+from agentle.tts.audio_format import AudioFormat
+from agentle.tts.output_format_type import OutputFormatType
+from agentle.tts.speech_config import SpeechConfig
+from agentle.tts.speech_result import SpeechResult
+from agentle.tts.tts_provider import TtsProvider
+from agentle.tts.voice_settings import VoiceSettings
+from agentle.utils.needs import check_modules
+
+if TYPE_CHECKING:
+    from elevenlabs import AsyncElevenLabs
+
+
+class ElevenLabsTtsProvider(TtsProvider):
+    _client: AsyncElevenLabs
+
+    def __init__(self, api_key: str | None = None) -> None:
+        super().__init__()
+        check_modules("elevenlabs")
+        from elevenlabs import AsyncElevenLabs
+
+        self._client = AsyncElevenLabs(
+            api_key=api_key or os.getenv("ELEVENLABS_API_KEY")
+        )
+
+    @override
+    async def synthesize_async(self, text: str, config: SpeechConfig) -> SpeechResult:
+        from elevenlabs import AsyncElevenLabs
+        from elevenlabs.types.voice_settings import (
+            VoiceSettings as ElevenLabsVoiceSettings,
+        )
+
+        elevenlabs = AsyncElevenLabs()
+        audio_stream: AsyncIterator[bytes] = elevenlabs.text_to_speech.convert(
+            text=text,
+            voice_id=config.voice_id,
+            model_id=config.model_id,
+            output_format=config.output_format,
+            voice_settings=ElevenLabsVoiceSettings(
+                stability=config.voice_settings.stability,
+                use_speaker_boost=config.voice_settings.use_speaker_boost,
+                similarity_boost=config.voice_settings.similarity_boost,
+                style=config.voice_settings.style,
+                speed=config.voice_settings.speed,
+            )
+            if config.voice_settings
+            else None,
+            language_code=config.language_code,
+        )
+
+        # Collect all chunks into bytes
+        chunks: list[bytes] = []
+        async for chunk in audio_stream:
+            chunks.append(chunk)
+        audio_bytes = b"".join(chunks)
+
+        audio_base64 = base64.b64encode(audio_bytes).decode("utf-8")
+
+        return SpeechResult(
+            audio=audio_base64,
+            mime_type=self._get_mime_type(config.output_format),
+            format=config.output_format,
+        )
+
+    def _get_mime_type(self, output_format: OutputFormatType) -> AudioFormat:
+        """Convert ElevenLabs output format to MIME type."""
+        if output_format.startswith("mp3_"):
+            return "audio/mpeg"
+        elif output_format.startswith("pcm_"):
+            return "audio/wav"  # or "audio/pcm" depending on your use case
+        elif output_format.startswith("ulaw_"):
+            return "audio/basic"
+        elif output_format.startswith("alaw_"):
+            return "audio/basic"
+        elif output_format.startswith("opus_"):
+            return "audio/opus"
+        else:
+            return "application/octet-stream"  # fallback
+
+
+if __name__ == "__main__":
+    from dotenv import load_dotenv
+
+    load_dotenv(override=True)
+    tts_provider = ElevenLabsTtsProvider()
+    audio = tts_provider.synthesize(
+        "Oi, eu sou a Júlia. Assistente pessoal da Dany Braga do estúdio de fotografia. Em que posso ajudar você hoje?",
+        config=SpeechConfig(
+            voice_id="lWq4KDY8znfkV0DrK8Vb",
+            model_id="eleven_v3",
+            language_code="pt",
+            voice_settings=VoiceSettings(
+                stability=0.0,
+                use_speaker_boost=None,
+                similarity_boost=None,
+                style=None,
+                speed=None,
+            ),
+        ),
+    )
+    with open("audio.mp3", "wb") as file:
+        file.write(base64.b64decode(audio.audio))

agentle/tts/output_format_type.py

@@ -0,0 +1,26 @@
+from typing import Literal
+
+
+OutputFormatType = Literal[
+    "mp3_22050_32",
+    "mp3_24000_48",
+    "mp3_44100_32",
+    "mp3_44100_64",
+    "mp3_44100_96",
+    "mp3_44100_128",
+    "mp3_44100_192",
+    "pcm_8000",
+    "pcm_16000",
+    "pcm_22050",
+    "pcm_24000",
+    "pcm_32000",
+    "pcm_44100",
+    "pcm_48000",
+    "ulaw_8000",
+    "alaw_8000",
+    "opus_48000_32",
+    "opus_48000_64",
+    "opus_48000_96",
+    "opus_48000_128",
+    "opus_48000_192",
+]

agentle/tts/speech_config.py

@@ -0,0 +1,14 @@
+from typing import Optional
+
+from rsb.models import BaseModel, Field
+
+from agentle.tts.output_format_type import OutputFormatType
+from agentle.tts.voice_settings import VoiceSettings
+
+
+class SpeechConfig(BaseModel):
+    voice_id: str
+    model_id: Optional[str] = Field(default=None)
+    output_format: OutputFormatType = Field(default="mp3_22050_32")
+    language_code: Optional[str] = Field(default=None)
+    voice_settings: Optional[VoiceSettings] = Field(default=None)

agentle/tts/speech_result.py

@@ -0,0 +1,15 @@
+from rsb.models import BaseModel, Field
+
+from agentle.tts.audio_format import AudioFormat
+from agentle.tts.output_format_type import OutputFormatType
+
+
+class SpeechResult(BaseModel):
+    audio: str = Field(...)
+    """The speech in base-64 format"""
+
+    mime_type: AudioFormat = Field(...)
+    """`audio/mpeg`, `audio/wav`, `audio/opus`"""
+
+    format: OutputFormatType = Field(...)
+    """The original format string like "mp3_44100_128"""

agentle/tts/tts_provider.py

@@ -0,0 +1,16 @@
+import abc
+
+from rsb.coroutines.run_sync import run_sync
+
+from agentle.tts.speech_config import SpeechConfig
+from agentle.tts.speech_result import SpeechResult
+
+
+class TtsProvider(abc.ABC):
+    def synthesize(self, text: str, config: SpeechConfig) -> SpeechResult:
+        return run_sync(self.synthesize_async, text=text, config=config)
+
+    @abc.abstractmethod
+    async def synthesize_async(
+        self, text: str, config: SpeechConfig
+    ) -> SpeechResult: ...

agentle/tts/voice_settings.py

@@ -0,0 +1,30 @@
+from typing import Optional
+
+from rsb.models import BaseModel, Field
+
+
+class VoiceSettings(BaseModel):
+    stability: Optional[float] = Field(default=None)
+    """
+    Determines how stable the voice is and the randomness between each generation. Lower values introduce broader emotional range for the voice. Higher values can result in a monotonous voice with limited emotion.
+    """
+
+    use_speaker_boost: Optional[bool] = Field(default=None)
+    """
+    This setting boosts the similarity to the original speaker. Using this setting requires a slightly higher computational load, which in turn increases latency.
+    """
+
+    similarity_boost: Optional[float] = Field(default=None)
+    """
+    Determines how closely the AI should adhere to the original voice when attempting to replicate it.
+    """
+
+    style: Optional[float] = Field(default=None)
+    """
+    Determines the style exaggeration of the voice. This setting attempts to amplify the style of the original speaker. It does consume additional computational resources and might increase latency if set to anything other than 0.
+    """
+
+    speed: Optional[float] = Field(default=None)
+    """
+    Adjusts the speed of the voice. A value of 1.0 is the default speed, while values less than 1.0 slow down the speech, and values greater than 1.0 speed it up.
+    """

agentle/utils/parse_streaming_json.py

@@ -21,8 +21,6 @@ def parse_streaming_json[T: BaseModel](potential_json: str | None, model: type[T
     if potential_json is None:
         return model()
 
-    # print(f"parsing: {potential_json}")
-
     def find_json_boundaries(text: str) -> tuple[int, int]:
         """Find the start and potential end of JSON in the text."""
 
@@ -95,17 +93,32 @@ def parse_streaming_json[T: BaseModel](potential_json: str | None, model: type[T
         # Remove any leading/trailing whitespace
         json_str = json_str.strip()
 
-        # Fix missing closing quotes on string values (at the end)
-        # Look for patterns like: "key": "value without closing quote
-        json_str = re.sub(r':\s*"([^"]*?)(?:\s*[,}]|$)', r': "\1"', json_str)
-
-        # Fix missing closing quotes for keys
-        # Look for patterns like: "key without quotes:
-        json_str = re.sub(r'"([^"]*?)(?=\s*:)', r'"\1"', json_str)
-
         # Remove trailing commas before closing braces/brackets
         json_str = re.sub(r",\s*([}\]])", r"\1", json_str)
 
+        # For streaming JSON, we need to handle incomplete strings carefully
+        # Check if we have an unclosed string at the end
+        in_string = False
+        escape_next = False
+        last_quote_pos = -1
+        
+        for i, char in enumerate(json_str):
+            if escape_next:
+                escape_next = False
+                continue
+            if char == '\\':
+                escape_next = True
+                continue
+            if char == '"':
+                in_string = not in_string
+                if in_string:
+                    last_quote_pos = i
+
+        # If we're in a string at the end (incomplete), close it properly
+        if in_string and last_quote_pos != -1:
+            # Add closing quote for the incomplete string
+            json_str += '"'
+
         # Ensure the JSON has proper closing braces if it appears incomplete
         open_braces = json_str.count("{") - json_str.count("}")
         open_brackets = json_str.count("[") - json_str.count("]")
@@ -124,12 +137,25 @@ def parse_streaming_json[T: BaseModel](potential_json: str | None, model: type[T
         data = {}
 
         # Extract string key-value pairs with quoted keys
-        # Pattern: "key": "value" or 'key': 'value'
-        string_pattern = r'["\']([^"\']+)["\']:\s*["\']([^"\']*)["\']?'
-        string_matches = re.findall(string_pattern, json_str)
+        # IMPROVED: Handle long strings that may contain newlines, special chars, etc.
+        # Pattern: "key": "value..." - capture everything until the next unescaped quote or EOF
+        string_pattern = r'["\']([\w]+)["\']:\s*["\']([^"\']*?)(?:["\']|$)'
+        string_matches = re.findall(string_pattern, json_str, re.DOTALL)
+        
+        # Also try to capture very long strings that span multiple lines
+        # This catches incomplete strings during streaming
+        long_string_pattern = r'["\']([\w_]+)["\']:\s*["\'](.+?)(?:["\'],?\s*["}]|$)'
+        long_matches = re.findall(long_string_pattern, json_str, re.DOTALL)
 
         for key, value in string_matches:
             data[key] = value
+        
+        # Prefer long_matches for fields that might be truncated in string_matches
+        for key, value in long_matches:
+            # Only override if the long match has more content
+            existing = data.get(key, "")
+            if key not in data or (isinstance(existing, str) and len(value) > len(existing)):
+                data[key] = value
 
         # Extract string key-value pairs with unquoted keys
         # Pattern: key: "value" (no quotes around key)