autobyteus 1.1.5__py3-none-any.whl → 1.1.6__py3-none-any.whl

autobyteus/llm/utils/llm_config.py

@@ -55,6 +55,7 @@ class LLMConfig:
     frequency_penalty: Optional[float] = None
     presence_penalty: Optional[float] = None
     stop_sequences: Optional[List] = None
+    uses_max_completion_tokens: bool = False
     extra_params: Dict[str, Any] = field(default_factory=dict)
     pricing_config: TokenPricingConfig = field(default_factory=TokenPricingConfig)
 
@@ -102,17 +103,28 @@ class LLMConfig:
         data_copy = data.copy()
         pricing_config_data = data_copy.pop('pricing_config', {})
         
+        # Create a new dictionary for known fields to avoid passing them in twice
+        known_fields = {
+            'rate_limit', 'token_limit', 'system_message', 'temperature', 
+            'max_tokens', 'top_p', 'frequency_penalty', 'presence_penalty', 
+            'stop_sequences', 'uses_max_completion_tokens', 'extra_params', 
+            'pricing_config'
+        }
+        
+        init_kwargs = {k: v for k, v in data_copy.items() if k in known_fields}
+        
         config = cls(
-            rate_limit=data_copy.get('rate_limit'),
-            token_limit=data_copy.get('token_limit'),
-            system_message=data_copy.get('system_message', "You are a helpful assistant."),
-            temperature=data_copy.get('temperature', 0.7),
-            max_tokens=data_copy.get('max_tokens'),
-            top_p=data_copy.get('top_p'),
-            frequency_penalty=data_copy.get('frequency_penalty'),
-            presence_penalty=data_copy.get('presence_penalty'),
-            stop_sequences=data_copy.get('stop_sequences'),
-            extra_params=data_copy.get('extra_params', {}),
+            rate_limit=init_kwargs.get('rate_limit'),
+            token_limit=init_kwargs.get('token_limit'),
+            system_message=init_kwargs.get('system_message', "You are a helpful assistant."),
+            temperature=init_kwargs.get('temperature', 0.7),
+            max_tokens=init_kwargs.get('max_tokens'),
+            top_p=init_kwargs.get('top_p'),
+            frequency_penalty=init_kwargs.get('frequency_penalty'),
+            presence_penalty=init_kwargs.get('presence_penalty'),
+            stop_sequences=init_kwargs.get('stop_sequences'),
+            uses_max_completion_tokens=init_kwargs.get('uses_max_completion_tokens', False),
+            extra_params=init_kwargs.get('extra_params', {}),
             pricing_config=pricing_config_data 
         )
         return config
@@ -162,26 +174,30 @@ class LLMConfig:
         for f_info in fields(override_config):
             override_value = getattr(override_config, f_info.name)
             
+            # Special handling for booleans where we want to merge if it's not the default
+            # For `uses_max_completion_tokens`, the default is False, so `if override_value:` is fine
+            is_boolean_field = f_info.type == bool
+            
+            # Standard check for None, but also merge if it's a non-default boolean
             if override_value is not None:
-                if f_info.name == 'pricing_config':
-                    # Ensure self.pricing_config is an object (should be by __post_init__)
+                # For uses_max_completion_tokens, `False` is a valid override value, but `None` is not
+                if is_boolean_field and override_value is False and getattr(self, f_info.name) is True:
+                     setattr(self, f_info.name, override_value)
+                elif f_info.name == 'pricing_config':
                     if not isinstance(self.pricing_config, TokenPricingConfig):
-                        self.pricing_config = TokenPricingConfig() # Should not be needed
+                        self.pricing_config = TokenPricingConfig()
                     
-                    # override_value here is override_config.pricing_config, which is TokenPricingConfig
                     if isinstance(override_value, TokenPricingConfig):
                          self.pricing_config.merge_with(override_value)
-                    elif isinstance(override_value, dict): # Should not happen if override_config is LLMConfig
+                    elif isinstance(override_value, dict):
                         self.pricing_config.merge_with(TokenPricingConfig.from_dict(override_value))
                     else:
                         logger.warning(f"Skipping merge for pricing_config due to unexpected override type: {type(override_value)}")
                 elif f_info.name == 'extra_params':
-                    # For extra_params (dict), merge dictionaries
                     if isinstance(override_value, dict) and isinstance(self.extra_params, dict):
                         self.extra_params.update(override_value)
                     else:
-                        setattr(self, f_info.name, override_value) # Fallback to direct set if types mismatch
+                        setattr(self, f_info.name, override_value)
                 else:
                     setattr(self, f_info.name, override_value)
         logger.debug(f"LLMConfig merged. Current state after merge: rate_limit={self.rate_limit}, temp={self.temperature}, system_message='{self.system_message}'")
-

autobyteus/llm/utils/media_payload_formatter.py

@@ -0,0 +1,99 @@
+import base64
+import mimetypes
+from typing import Dict, Union
+from pathlib import Path
+import httpx
+import logging
+
+logger = logging.getLogger(__name__)
+
+# FIX: Instantiate the client with verify=False to allow for self-signed certificates
+# in local development environments, which is a common use case.
+_http_client = httpx.AsyncClient(verify=False)
+
+# Add a prominent security warning to inform developers about the disabled SSL verification.
+logger.warning(
+    "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n"
+    "SECURITY WARNING: SSL certificate verification is DISABLED for the image "
+    "downloader (httpx client in media_payload_formatter.py).\n"
+    "This is intended for development and testing with local servers using "
+    "self-signed certificates. In a production environment, this could expose "
+    "the system to Man-in-the-Middle (MitM) attacks when downloading images from "
+    "the public internet.\n"
+    "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"
+)
+
+
+def get_mime_type(file_path: str) -> str:
+    """Determine MIME type of file."""
+    mime_type, _ = mimetypes.guess_type(file_path)
+    if not mime_type or not mime_type.startswith('image/'):
+        return 'image/jpeg'  # default fallback
+    return mime_type
+
+
+def is_base64(s: str) -> bool:
+    """Check if a string is a valid base64 encoded string."""
+    try:
+        # Check if the string has valid base64 characters and padding
+        if not isinstance(s, str) or len(s) % 4 != 0:
+            return False
+        base64.b64decode(s, validate=True)
+        return True
+    except (ValueError, TypeError):
+        return False
+
+
+def is_valid_image_path(path: str) -> bool:
+    """Check if path exists and has a valid image extension."""
+    valid_extensions = {".jpg", ".jpeg", ".png", ".gif", ".webp"}
+    try:
+        file_path = Path(path)
+        return file_path.is_file() and file_path.suffix.lower() in valid_extensions
+    except (TypeError, ValueError):
+        return False
+
+
+def create_data_uri(mime_type: str, base64_data: str) -> Dict:
+    """Create properly structured data URI object for API."""
+    return {
+        "type": "image_url",
+        "image_url": {
+            "url": f"data:{mime_type};base64,{base64_data}"
+        }
+    }
+
+def file_to_base64(path: str) -> str:
+    """Reads an image file from a local path and returns it as a base64 encoded string."""
+    try:
+        with open(path, "rb") as img_file:
+            return base64.b64encode(img_file.read()).decode("utf-8")
+    except Exception as e:
+        logger.error(f"Failed to read and encode image file at {path}: {e}")
+        raise
+
+async def url_to_base64(url: str) -> str:
+    """Downloads an image from a URL and returns it as a base64 encoded string."""
+    try:
+        response = await _http_client.get(url)
+        response.raise_for_status()
+        return base64.b64encode(response.content).decode("utf-8")
+    except httpx.HTTPError as e:
+        logger.error(f"Failed to download image from URL {url}: {e}")
+        raise
+
+async def image_source_to_base64(image_source: str) -> str:
+    """
+    Orchestrator function that converts an image source (file path, URL, or existing base64)
+    into a base64 encoded string by delegating to specialized functions.
+    """
+    if is_valid_image_path(image_source):
+        return file_to_base64(image_source)
+    
+    if image_source.startswith(("http://", "https://")):
+        return await url_to_base64(image_source)
+
+    if is_base64(image_source):
+        return image_source
+
+    raise ValueError(f"Invalid image source: not a valid file path, URL, or base64 string.")

autobyteus/llm/utils/messages.py

@@ -7,34 +7,41 @@ class MessageRole(Enum):
     ASSISTANT = "assistant"
 
 class Message:
-    def __init__(self, role: MessageRole, content: Union[str, List[Dict]], reasoning_content: Optional[str] = None):
+    def __init__(self,
+                 role: MessageRole,
+                 content: Optional[str] = None,
+                 reasoning_content: Optional[str] = None,
+                 image_urls: Optional[List[str]] = None,
+                 audio_urls: Optional[List[str]] = None,
+                 video_urls: Optional[List[str]] = None):
         """
-        Initializes a Message.
-        
+        Initializes a rich Message object for conversation history.
+
         Args:
-            role (MessageRole): The role of the message.
-            content (Union[str, List[Dict]]): The content of the message.
-            reasoning_content (Optional[str]): Optional reasoning content for reasoning models.
+            role: The role of the message originator.
+            content: The textual content of the message.
+            reasoning_content: Optional reasoning/thought process from an assistant.
+            image_urls: Optional list of image URIs.
+            audio_urls: Optional list of audio URIs.
+            video_urls: Optional list of video URIs.
         """
         self.role = role
         self.content = content
-        self.reasoning_content = reasoning_content  # Optional field for reasoning content
-
-    def to_dict(self) -> Dict[str, Union[str, List[Dict]]]:
-        result: Dict[str, Union[str, List[Dict]]] = {"role": self.role.value, "content": self.content}
-        if self.reasoning_content:
-            result["reasoning_content"] = self.reasoning_content
-        return result
+        self.reasoning_content = reasoning_content
+        self.image_urls = image_urls or []
+        self.audio_urls = audio_urls or []
+        self.video_urls = video_urls or []
 
-    def to_mistral_message(self):
-        if self.role == MessageRole.USER:
-            from mistralai import UserMessage
-            return UserMessage(content=self.content)
-        elif self.role == MessageRole.ASSISTANT:
-            from mistralai import AssistantMessage
-            return AssistantMessage(content=self.content)
-        elif self.role == MessageRole.SYSTEM:
-            from mistralai import SystemMessage
-            return SystemMessage(content=self.content)
-        else:
-            raise ValueError(f"Unsupported message role: {self.role}")
+    def to_dict(self) -> Dict[str, Union[str, List[str], None]]:
+        """
+        Returns a simple dictionary representation of the Message object.
+        This is for internal use and does not format for any specific API.
+        """
+        return {
+            "role": self.role.value,
+            "content": self.content,
+            "reasoning_content": self.reasoning_content,
+            "image_urls": self.image_urls,
+            "audio_urls": self.audio_urls,
+            "video_urls": self.video_urls,
+        }

autobyteus/llm/utils/response_types.py

@@ -1,5 +1,5 @@
-from dataclasses import dataclass
-from typing import Optional
+from dataclasses import dataclass, field
+from typing import Optional, List
 from autobyteus.llm.utils.token_usage import TokenUsage
 
 @dataclass
@@ -7,6 +7,9 @@ class CompleteResponse:
     content: str
     reasoning: Optional[str] = None
     usage: Optional[TokenUsage] = None
+    image_urls: List[str] = field(default_factory=list)
+    audio_urls: List[str] = field(default_factory=list)
+    video_urls: List[str] = field(default_factory=list)
 
     @classmethod
     def from_content(cls, content: str) -> 'CompleteResponse':
@@ -17,4 +20,7 @@ class ChunkResponse:
     content: str  # The actual content/text of the chunk
     reasoning: Optional[str] = None
     is_complete: bool = False  # Indicates if this is the final chunk
-    usage: Optional[TokenUsage] = None  # Token usage stats, typically available in final chunk
+    usage: Optional[TokenUsage] = None  # Token usage stats, typically available in final chunk
+    image_urls: List[str] = field(default_factory=list)
+    audio_urls: List[str] = field(default_factory=list)
+    video_urls: List[str] = field(default_factory=list)

autobyteus/llm/utils/token_usage.py

@@ -1,8 +1,8 @@
 # file: autobyteus/autobyteus/llm/utils/token_usage.py
 from typing import Optional
-from pydantic import BaseModel # MODIFIED: Import BaseModel
+from pydantic import BaseModel, ConfigDict # MODIFIED: Import ConfigDict
 
-# MODIFIED: Change from dataclass to Pydantic BaseModel
+# MODIFIED: Change from dataclass to Pydantic BaseModel and use model_config
 class TokenUsage(BaseModel):
     prompt_tokens: int
     completion_tokens: int
@@ -11,6 +11,7 @@ class TokenUsage(BaseModel):
     completion_cost: Optional[float] = None
     total_cost: Optional[float] = None
 
-    class Config:
-        populate_by_name = True # If you use aliases, or for general Pydantic v2 compatibility
-        # or model_config = ConfigDict(populate_by_name=True) for Pydantic v2
+    # FIX: Use model_config with ConfigDict for Pydantic v2 compatibility
+    model_config = ConfigDict(
+        populate_by_name=True,
+    )

autobyteus/multimedia/__init__.py

@@ -0,0 +1,31 @@
+from .providers import MultimediaProvider
+from .runtimes import MultimediaRuntime
+from .utils import *
+from .image import *
+from .audio import *
+
+
+__all__ = [
+    # Factories
+    "image_client_factory",
+    "ImageClientFactory",
+    "audio_client_factory",
+    "AudioClientFactory",
+
+    # Models
+    "ImageModel",
+    "AudioModel",
+    
+    # Base Clients
+    "BaseImageClient",
+    "BaseAudioClient",
+
+    # Enums
+    "MultimediaProvider",
+    "MultimediaRuntime",
+
+    # Response Types and Config
+    "ImageGenerationResponse",
+    "SpeechGenerationResponse",
+    "MultimediaConfig",
+]

autobyteus/multimedia/audio/__init__.py

@@ -0,0 +1,11 @@
+from .audio_client_factory import audio_client_factory, AudioClientFactory
+from .audio_model import AudioModel
+from .base_audio_client import BaseAudioClient
+from .api import *
+
+__all__ = [
+    "audio_client_factory",
+    "AudioClientFactory",
+    "AudioModel",
+    "BaseAudioClient",
+]

autobyteus/multimedia/audio/api/__init__.py

@@ -0,0 +1,4 @@
+from .gemini_audio_client import GeminiAudioClient
+from .autobyteus_audio_client import AutobyteusAudioClient
+
+__all__ = ["GeminiAudioClient", "AutobyteusAudioClient"]

autobyteus/multimedia/audio/api/autobyteus_audio_client.py

@@ -0,0 +1,59 @@
+import logging
+from typing import Optional, List, Dict, Any, TYPE_CHECKING
+from autobyteus_llm_client import AutobyteusClient
+from autobyteus.multimedia.audio.base_audio_client import BaseAudioClient
+from autobyteus.multimedia.utils.response_types import SpeechGenerationResponse
+
+if TYPE_CHECKING:
+    from autobyteus.multimedia.audio.audio_model import AudioModel
+    from autobyteus.multimedia.utils.multimedia_config import MultimediaConfig
+
+logger = logging.getLogger(__name__)
+
+class AutobyteusAudioClient(BaseAudioClient):
+    """
+    An audio client that connects to an Autobyteus server instance for audio tasks.
+    """
+
+    def __init__(self, model: "AudioModel", config: "MultimediaConfig"):
+        super().__init__(model, config)
+        if not model.host_url:
+            raise ValueError("AutobyteusAudioClient requires a host_url in its AudioModel.")
+        
+        self.autobyteus_client = AutobyteusClient(server_url=model.host_url)
+        logger.info(f"AutobyteusAudioClient initialized for model '{model.name}' on host '{model.host_url}'.")
+
+    async def generate_speech(
+        self,
+        prompt: str,
+        generation_config: Optional[Dict[str, Any]] = None
+    ) -> SpeechGenerationResponse:
+        """
+        Generates speech by calling the generate_speech endpoint on the remote Autobyteus server.
+        """
+        try:
+            logger.info(f"Sending speech generation request for model '{self.model.name}' to {self.model.host_url}")
+            
+            model_name_for_server = self.model.name
+
+            response_data = await self.autobyteus_client.generate_speech(
+                model_name=model_name_for_server,
+                prompt=prompt,
+                generation_config=generation_config
+            )
+            
+            audio_urls = response_data.get("audio_urls", [])
+            if not audio_urls:
+                raise ValueError("Remote Autobyteus server did not return any audio URLs.")
+                
+            return SpeechGenerationResponse(audio_urls=audio_urls)
+            
+        except Exception as e:
+            logger.error(f"Error calling Autobyteus server for speech generation: {e}", exc_info=True)
+            raise
+
+    async def cleanup(self):
+        """Closes the underlying AutobyteusClient."""
+        if self.autobyteus_client:
+            await self.autobyteus_client.close()
+        logger.debug("AutobyteusAudioClient cleaned up.")

autobyteus/multimedia/audio/api/gemini_audio_client.py

@@ -0,0 +1,219 @@
+import asyncio
+import base64
+import logging
+import os
+import uuid
+import wave
+from typing import Optional, Dict, Any, TYPE_CHECKING, List
+
+# Old/legacy Gemini SDK (as requested)
+import google.generativeai as genai
+
+from autobyteus.multimedia.audio.base_audio_client import BaseAudioClient
+from autobyteus.multimedia.utils.response_types import SpeechGenerationResponse
+
+if TYPE_CHECKING:
+    from autobyteus.multimedia.audio.audio_model import AudioModel
+    from autobyteus.multimedia.utils.multimedia_config import MultimediaConfig
+
+logger = logging.getLogger(__name__)
+
+
+def _save_audio_bytes_to_wav(
+    pcm_bytes: bytes,
+    channels: int = 1,
+    rate: int = 24000,
+    sample_width: int = 2,
+) -> str:
+    """
+    Save raw PCM (s16le) audio bytes to a temporary WAV file and return the file path.
+
+    Gemini TTS models output mono, 24 kHz, 16-bit PCM by default.
+    """
+    temp_dir = "/tmp/autobyteus_audio"
+    os.makedirs(temp_dir, exist_ok=True)
+    file_path = os.path.join(temp_dir, f"{uuid.uuid4()}.wav")
+
+    try:
+        with wave.open(file_path, "wb") as wf:
+            wf.setnchannels(channels)
+            wf.setsampwidth(sample_width)  # 2 bytes => 16-bit
+            wf.setframerate(rate)
+            wf.writeframes(pcm_bytes)
+        logger.info("Successfully saved generated audio to %s", file_path)
+        return file_path
+    except Exception as e:
+        logger.error("Failed to save audio to WAV file at %s: %s", file_path, e)
+        raise
+
+
+def _extract_inline_audio_bytes(response) -> bytes:
+    """
+    Extract inline audio bytes from a google.generativeai response.
+
+    The legacy SDK returns a Response object with candidates -> content -> parts[0].inline_data.data.
+    Depending on version, `.data` can be bytes or base64-encoded str.
+    """
+    try:
+        # Access the first candidate's first part's inline_data
+        part = response.candidates[0].content.parts[0]
+        inline = getattr(part, "inline_data", None)
+        if not inline or not hasattr(inline, "data"):
+            raise ValueError("No inline audio data found in response.")
+        data = inline.data
+        if isinstance(data, bytes):
+            return data
+        if isinstance(data, str):
+            return base64.b64decode(data)
+        raise TypeError(f"Unexpected inline_data.data type: {type(data)}")
+    except Exception as e:
+        logger.error("Failed to extract audio from response: %s", e)
+        raise
+
+
+class GeminiAudioClient(BaseAudioClient):
+    """
+    An audio client that uses Google's Gemini models for TTS via the *legacy* SDK
+    (`google.generativeai`).
+
+    Usage notes:
+      - Ensure your model value is a TTS-capable model (e.g. "gemini-2.5-flash-preview-tts"
+        or "gemini-2.5-pro-preview-tts").
+      - Single-speaker is default. For simple usage, provide `voice_name` (e.g. "Kore", "Puck")
+        in MultimediaConfig or generation_config.
+      - Multi-speaker preview exists in the API; if you want it, pass:
+          generation_config = {
+              "mode": "multi-speaker",
+              "speakers": [
+                  {"speaker": "Alice", "voice_name": "Kore"},
+                  {"speaker": "Bob",   "voice_name": "Puck"},
+              ]
+          }
+        and make sure your prompt contains lines for each named speaker.
+    """
+
+    def __init__(self, model: "AudioModel", config: "MultimediaConfig"):
+        super().__init__(model, config)
+        api_key = os.getenv("GEMINI_API_KEY")
+        if not api_key:
+            raise ValueError("Please set the GEMINI_API_KEY environment variable.")
+
+        try:
+            # Legacy library uses a global configure call
+            genai.configure(api_key=api_key)
+            # Create a GenerativeModel handle
+            self._model = genai.GenerativeModel(self.model.value or "gemini-2.5-flash-preview-tts")
+            logger.info("GeminiAudioClient (legacy SDK) configured for model '%s'.", self.model.value)
+        except Exception as e:
+            logger.error("Failed to configure Gemini client: %s", e)
+            raise RuntimeError(f"Failed to configure Gemini client: {e}")
+
+    @staticmethod
+    def _build_single_speaker_generation_config(voice_name: str) -> Dict[str, Any]:
+        """
+        Build generation_config for single-speaker TTS in the legacy SDK.
+        Key bits:
+          - response_mime_type => request audio
+          - speech_config.voice_config.prebuilt_voice_config.voice_name => set the voice
+        """
+        return {
+            "response_mime_type": "audio/pcm",
+            "speech_config": {
+                "voice_config": {
+                    "prebuilt_voice_config": {
+                        "voice_name": voice_name,
+                    }
+                }
+            },
+        }
+
+    @staticmethod
+    def _build_multi_speaker_generation_config(speakers: List[Dict[str, str]]) -> Dict[str, Any]:
+        """
+        Build generation_config for multi-speaker TTS (preview).
+        `speakers` = [{"speaker": "...", "voice_name": "..."}, ...]
+        """
+        speaker_voice_configs = []
+        for s in speakers:
+            spk = s.get("speaker")
+            vname = s.get("voice_name")
+            if not spk or not vname:
+                raise ValueError("Each speaker must include 'speaker' and 'voice_name'.")
+            speaker_voice_configs.append(
+                {
+                    "speaker": spk,
+                    "voice_config": {
+                        "prebuilt_voice_config": {
+                            "voice_name": vname,
+                        }
+                    },
+                }
+            )
+        return {
+            "response_mime_type": "audio/pcm",
+            "speech_config": {
+                "multi_speaker_voice_config": {
+                    "speaker_voice_configs": speaker_voice_configs
+                }
+            },
+        }
+
+    async def generate_speech(
+        self,
+        prompt: str,
+        generation_config: Optional[Dict[str, Any]] = None
+    ) -> SpeechGenerationResponse:
+        """
+        Generates spoken audio from text using a Gemini TTS model through the legacy SDK.
+
+        Implementation details:
+          - We call `GenerativeModel.generate_content(...)` with a `generation_config`
+            that asks for AUDIO and sets the voice settings.
+          - The legacy SDK call is synchronous; we offload to a worker thread.
+        """
+        try:
+            logger.info("Generating speech with Gemini TTS (legacy SDK) model '%s'...", self.model.value)
+
+            # Merge base config with per-call overrides
+            final_cfg = self.config.to_dict().copy()
+            if generation_config:
+                final_cfg.update(generation_config or {})
+
+            # Style instructions: prepend if provided
+            style_instructions = final_cfg.get("style_instructions")
+            final_prompt = f"{style_instructions}: {prompt}" if style_instructions else prompt
+            logger.debug("Final prompt for TTS (truncated): '%s...'", final_prompt[:160])
+
+            # Mode & voice
+            mode = final_cfg.get("mode", "single-speaker")
+            default_voice = final_cfg.get("voice_name", "Kore")
+
+            if mode == "multi-speaker":
+                speakers = final_cfg.get("speakers")
+                if not speakers or not isinstance(speakers, list):
+                    raise ValueError(
+                        "For multi-speaker mode, provide generation_config['speakers'] "
+                        "as a list of {'speaker': <name>, 'voice_name': <prebuilt voice>}."
+                    )
+                gen_config = self._build_multi_speaker_generation_config(speakers)
+            else:
+                gen_config = self._build_single_speaker_generation_config(default_voice)
+
+            # Run the blocking gen call in a thread so this coroutine stays non-blocking
+            response = await asyncio.to_thread(
+                self._model.generate_content,
+                final_prompt,
+                generation_config=gen_config,
+            )
+
+            audio_pcm = _extract_inline_audio_bytes(response)
+            audio_path = _save_audio_bytes_to_wav(audio_pcm)
+
+            return SpeechGenerationResponse(audio_urls=[audio_path])
+
+        except Exception as e:
+            logger.error("Error during Google Gemini speech generation (legacy SDK): %s", str(e))
+            raise ValueError(f"Google Gemini speech generation failed: {str(e)}")
+
+    async def cleanup(self):
+        logger.debug("GeminiAudioClient cleanup called (legacy SDK; nothing to release).")