update model

README.md

@@ -8,7 +8,6 @@ pinned: false
 short_description: openai api style tts engine
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
 # tts-proxy
 A simple openai api style tts server based on supertonic.
 
@@ -32,7 +31,8 @@ uv pip install -r ./requirements.txt
 
 ```bash
 export API_KEY=yourapi
-python server.py
+export MODELS="{'tts-2':'supertonic','tts-1':'kokoro'}"
+python app.py
 ```
 
 ## run client
@@ -40,7 +40,15 @@ python server.py
 ```bash
 curl http://localhost:8000/v1/audio/speech   -H "Content-Type: application/json"  -H "Authorization: Bearer yourapi"  -d '{
     "model": "tts-1",
-    "input": "Hello, this is Supertonic running locally!",
-    "voice": "F1"
+    "input": "Hello World! Come Here!",
+    "voice": "F1",
+    "format": "wav"
   }'   --output ./test.wav
+
+curl http://localhost:8000/v1/audio/speech   -H "Content-Type: application/json"  -H "Authorization: Bearer yourapi"  -d '{
+    "model": "tts-1",
+    "input": "Hello World! Come Here!",
+    "voice": "F1",
+    "format": "mp3"
+  }'   --output ./test.mp3
 ```

app.py

@@ -1,22 +1,16 @@
 import os
-import io
-import time
-import re
-import asyncio
-import numpy as np
 import argparse
 import uvicorn
 import sys
-import struct
 import secrets
+import json
 from contextlib import asynccontextmanager
 from fastapi import FastAPI, HTTPException, Security, status, Depends
 from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
-from fastapi.responses import StreamingResponse
+from fastapi.responses import StreamingResponse, Response
 from pydantic import BaseModel
 from typing import Optional, Literal
-from supertonic import TTS
-
+import supertonic_model,kokoro_model
 
 
 
@@ -56,235 +50,21 @@ async def verify_api_key(credentials: HTTPAuthorizationCredentials = Security(se
 # 2. Text & Audio Utilities
 # -----------------------------------------------------------------------------
 
-def split_text_into_sentences(text: str, min_chunk_size: int = 150):
-    """
-    Smart splitting for low-latency streaming.
-    
-    Logic:
-    1. Split text into "atomic" sentences (preserving punctuation).
-    2. ALWAYS yield the first sentence immediately (fastest time-to-first-byte).
-    3. For subsequent text, combine small sentences into larger chunks 
-       (up to min_chunk_size) to improve GPU efficiency and sentence flow.
-    """
-    if not text:
-        return []
-
-    # 1. Clean up extra whitespace (newlines become spaces for flow)
-    # We want a continuous stream of text for better merging
-    text = re.sub(r'\s+', ' ', text).strip()
-
-    # 2. Split into atomic sentences
-    # Pattern: Split by [.?!:;] but keep the delimiter.
-    # We look for punctuation followed by a space or end of string.
-    raw_parts = re.split(r'([.?!:;]+)(?=\s|$)', text)
-    
-    atomic_sentences = []
-    current_atomic = ""
-    
-    # Re-assemble the split parts (e.g. "Hello" + "." -> "Hello.")
-    for part in raw_parts:
-        if re.match(r'^[.?!:;]+$', part):
-            current_atomic += part
-            if current_atomic.strip():
-                atomic_sentences.append(current_atomic.strip())
-            current_atomic = ""
-        else:
-            current_atomic += part
-            
-    if current_atomic.strip():
-        atomic_sentences.append(current_atomic.strip())
-
-    # 3. Batching Logic
-    final_chunks = []
-    current_buffer = ""
-    first_sentence_sent = False
-
-    for sentence in atomic_sentences:
-        # CASE A: The very first sentence. 
-        # Send it immediately, no matter how short, to start audio playback.
-        if not first_sentence_sent:
-            final_chunks.append(sentence)
-            first_sentence_sent = True
-            continue
-
-        # CASE B: Subsequent sentences.
-        # Add to buffer.
-        if current_buffer:
-            current_buffer += " " + sentence
-        else:
-            current_buffer = sentence
-
-        # If buffer is long enough, flush it.
-        # This prevents generating audio for tiny fragments like "No." or "Ok."
-        if len(current_buffer) >= min_chunk_size:
-            final_chunks.append(current_buffer)
-            current_buffer = ""
-
-    # Flush any remaining text in the buffer
-    if current_buffer:
-        final_chunks.append(current_buffer)
-
-    return final_chunks
-
-
-# -----------------------------------------------------------------------------
-# 1. Utility Functions
-# -----------------------------------------------------------------------------
-
-
-def create_wav_header(sample_rate: int, channels: int = 1, bits_per_sample: int = 16):
-    """
-    Generates a generic WAV header with "unknown" file size (0xFFFFFFFF)
-    so browsers/clients treat it as a stream.
-    """
-    byte_rate = sample_rate * channels * bits_per_sample // 8
-    block_align = channels * bits_per_sample // 8
-    
-    header = b'RIFF'
-    header += struct.pack('<I', 0xFFFFFFFF) 
-    header += b'WAVE'
-    header += b'fmt '
-    header += struct.pack('<I', 16) 
-    header += struct.pack('<H', 1) 
-    header += struct.pack('<H', channels)
-    header += struct.pack('<I', sample_rate)
-    header += struct.pack('<I', byte_rate)
-    header += struct.pack('<H', block_align)
-    header += struct.pack('<H', bits_per_sample)
-    header += b'data'
-    header += struct.pack('<I', 0xFFFFFFFF)
-    
-    return header
-
-def float_to_pcm16(audio_array):
-    """Converts float32 audio to int16 bytes."""
-    audio_array = np.array(audio_array)
-    if len(audio_array.shape) > 1:
-        audio_array = audio_array.flatten()
-    audio_array = np.clip(audio_array, -1.0, 1.0)
-    audio_int16 = (audio_array * 32767).astype(np.int16)
-    return audio_int16.tobytes()
-
 # -----------------------------------------------------------------------------
 # 2. Streaming Engine with Fallback Logic
 # -----------------------------------------------------------------------------
 
-class StreamingEngine:
-    def __init__(self):
-        self.model = None
-        self.sample_rate = 441000
-        self.lock = asyncio.Lock()
-        
-        # Default fallback voice
-        self.default_voice = "F1" 
-        
-        # Mapping OpenAI voice names to Supertonic IDs
-        self.voice_mapping = {
-            "alloy": "F1",
-            "echo": "M1",
-            "fable": "M2",
-            "onyx": "M3",
-            "nova": "F2",
-            "shimmer": "F3"
-        }
-
-        print(f"Loading Supertonic model...")
-        try:
-            self.tts = TTS(auto_download=True)
-            self.text_processor = self.tts.model.text_processor
-            self.sample_rate = self.tts.sample_rate
-            print(f"Model Loaded. Rate: {self.sample_rate}")
-        except Exception as e:
-            print(f"Error initializing model: {e}")
-            sys.exit(1)
-
-    def get_style_safe(self, voice_name: str):
-        """
-        Safely retrieves a voice style. 
-        1. Checks mapping (alloy -> F1).
-        2. Tries to load.
-        3. If fails, returns default (F1).
-        """
-        # 1. Normalize and Map
-        clean_name = voice_name.lower().strip()
-        target_name = self.voice_mapping.get(clean_name, voice_name) # map or keep original
-
-        # 2. Try to get style
-        try:
-            # Note: We rely on supertonic throwing an error if name is invalid
-            style = self.tts.get_voice_style(voice_name=target_name)
-            return style, target_name
-        except Exception:
-            # 3. Fallback
-            print(f"WARNING: Voice '{voice_name}' (mapped to '{target_name}') not found. Using '{self.default_voice}'.")
-            try:
-                style = self.tts.get_voice_style(voice_name=self.default_voice)
-                return style, self.default_voice
-            except Exception as e:
-                print(f"CRITICAL: Default voice '{self.default_voice}' also failed.")
-                raise e
-
-    async def stream_generator(self, text: str, voice_name: str, speed: float):
-        # 1. Resolve Voice Style ONCE before the loop
-        # We do this here so we don't re-calculate embedding for every sentence
-        try:
-            style, resolved_name = self.get_style_safe(voice_name)
-        except Exception as e:
-            print(f"Error resolving voice: {e}")
-            return
-
-        yield create_wav_header(self.sample_rate)
-
-
-        is_valid, unsupported = self.text_processor.validate_text(text)
-
-        if not is_valid:
-            print(f"   ⚠️  Contains {len(unsupported)} unsupported character(s): {unsupported[:5]}")
-            pattern = f"[{re.escape(''.join(unsupported))}]"
-            preprocessed = re.sub(pattern, "", text) #self.text_processor._preprocess_text(text)
-            if preprocessed != text:
-                print(f"   After preprocessing: {preprocessed[:50]}...")
-                text = preprocessed
-
-        else:
-            print("   ✓ All characters supported")
-
-
-        #chunks = split_text_into_sentences(text)
-        chunks = split_text_into_sentences(text, min_chunk_size=150)
-
-
-
-
-        print(f"Streaming '{text[:20]}...' using voice: {resolved_name}")
-        
-        loop = asyncio.get_event_loop()
-        
-        for i, chunk in enumerate(chunks):
-            # async with self.lock guarantees only one heavy TTS task runs globally
-            async with self.lock:
-                audio_float, _ = await loop.run_in_executor(
-                    None, 
-                    self.tts.synthesize,
-                    chunk,
-                    style
-                    # speed # Add speed here if your supertonic version supports it
-                )
-
-            pcm_bytes = float_to_pcm16(audio_float)
-            yield pcm_bytes
-
 # -----------------------------------------------------------------------------
 # 3. API Setup
 # -----------------------------------------------------------------------------
 
-engine = None
+engine = {}
 
 class SpeechRequest(BaseModel):
     model: Optional[str] = "tts-1"
     input: str
-    voice: str = "F1" # Defaults to F1, but handles 'alloy' etc via mapping
-    response_format: Optional[str] = "wav"
+    voice: str = "alloy" # Default 'alloy'
+    format: Optional[str] = "wav"
     speed: Optional[float] = 1.0
 
 
@@ -296,8 +76,28 @@ async def lifespan(app: FastAPI):
         print("\n!!! WARNING: API_KEY not set. API is open to the public. !!!\n")
     else:
         print(f"\n*** Secure Mode: API Key protection enabled. ***\n")
-        
-    engine = StreamingEngine()
+
+    MODELS = None
+    if not os.getenv("MODELS"):
+        print(f"\n!!! WARNING: MODELS not set")
+        sys.exit(0)
+    else:
+        MODELS = os.getenv("MODELS")
+    
+    print(f"\n!!! WARNING: eval {MODELS}") 
+    try:
+        MODELS = eval(MODELS)
+    except:
+        print(f"\n!!! WARNING: eval {MODELS} failed")        
+        sys.exit(0)
+
+    print(f"\n*** Load {MODELS}. ***\n")
+    for k,v in MODELS.items():
+        print(f"Mapping {k}-->{v}")
+        if "supertonic" == v:
+            engine[k] = supertonic_model.StreamingEngine(f"{k}-->{v}")
+        if "kokoro" == v:
+            engine[k] = kokoro_model.StreamingEngine(f"{k}-->{v}")
     yield
 
 
@@ -312,9 +112,28 @@ async def text_to_speech(request: SpeechRequest):
     if not engine:
         raise HTTPException(500, "Engine not loaded")
 
+    print(f"request:{request}")
+    format = request.format
+    model = request.model
+    if format not in ["wav", "mp3"]:
+        format = "wav"
+    if model not in engine.keys():
+        print(f"!!!WARNING {model} not found")
+        
+        content = {
+            "ok": False,
+            "message": f"!!!WARNING {model} not found"
+        }
+
+        content = json.dumps(content)
+
+        return Response(content=content, status_code=404,media_type="application/json")
+        
+    
+
     return StreamingResponse(
-        engine.stream_generator(request.input, request.voice, request.speed),
-        media_type="audio/wav"
+        engine[model].stream_generator(request.input, request.voice, request.speed, format),
+        media_type=f"audio/{format}"
     )
 
 @app.get("/v1/models")

base_model.py

@@ -0,0 +1,77 @@
+import asyncio
+import utils
+
+class BaseEngine:
+    def __init__(self, name):
+        self.lock = asyncio.Lock()
+        self.name = name
+        self.tts = None
+        # Initialize with default, subclass should overwrite or load_model should update it
+        self.sample_rate = 24000 
+
+        print(f"Init model {self.name}")
+        self.load_model()
+
+    def load_model(self):
+        raise NotImplementedError("Subclass must implement abstract method")
+
+    def get_style_safe(self, voice_name: str):
+        raise NotImplementedError("Subclass must implement abstract method")
+    
+    # FIX: Changed from async to sync because it's run in an executor
+    # FIX: Fixed typo 'genetrate' -> 'generate'
+    def generate(self, chunks: str, voice_name: str, speed: float):
+        """
+        Should return (audio_float_array, sample_rate)
+        This method is CPU blocking, so it stays synchronous.
+        """
+        raise NotImplementedError("Subclass must implement abstract method")
+
+    # FIX: Added a default preprocessor in case subclass doesn't have one
+    def preprocess_text(self, text: str):
+        return text
+    async def stream_generator(self, text: str, voice_name: str, speed: float, format: str):
+        encoder = None
+
+        if format == "wav":
+            yield utils.create_wav_header(self.sample_rate)
+        elif format == "mp3":
+            encoder = utils.create_mp3_encoder(sample_rate=self.sample_rate)
+
+        # Preprocess text and voice
+        try:
+            voice_name = self.get_style_safe(voice_name)
+        except NotImplementedError:
+            pass 
+
+        text = self.preprocess_text(text)
+        chunks = utils.split_text_into_sentences(text, min_chunk_size=150)
+        
+        loop = asyncio.get_event_loop()
+        
+        for i, chunk in enumerate(chunks):
+            async with self.lock:
+                # Run synchronous generation in executor
+                audio_float = await loop.run_in_executor(
+                    None, 
+                    self.generate, 
+                    chunk,
+                    voice_name,
+                    speed 
+                )
+            for audio in audio_float:
+                if format == "wav":
+                    pcm_bytes = utils.float_to_pcm16(audio)
+                    yield pcm_bytes
+                
+                elif format == "mp3":
+                    # This now returns 'bytes', so it is safe
+                    mp3_bytes = utils.float_to_mp3(audio, encoder)
+                    if len(mp3_bytes) > 0:
+                        yield mp3_bytes
+
+        # Flush MP3 encoder to get remaining audio frames
+        if format == "mp3" and encoder is not None:
+            final_data = encoder.flush()
+            if len(final_data) > 0:
+                yield bytes(final_data) # <--- CRITICAL FIX: Cast to bytes

kokoro_model.py

@@ -0,0 +1,74 @@
+import sys
+import re
+import asyncio
+from kokoro import KPipeline
+import base_model
+
+class StreamingEngine(base_model.BaseEngine):
+    def __init__(self, name):
+        # 1. Initialize configuration variables first
+        self.default_voice = "af_heart"
+        self.voice_mapping = {
+            "alloy": "af_heart",
+            "echo": "af_bella",
+            "fable": "af_nicole",
+            "onyx": "af_aoede",
+            "nova": "af_aoede",
+            "shimmer": "af_aoede"
+        }
+        
+        # 2. Call super init (which usually calls load_model)
+        super().__init__(name)
+
+    def load_model(self):
+        try:
+            self.tts = KPipeline(lang_code='a')
+            # self.text_processor = self.tts.model.text_processor
+            self.sample_rate = 24000
+            print(f"Model Loaded. Rate: {self.sample_rate}")
+        except Exception as e:
+            # 3. CRITICAL FIX: Don't sys.exit(1). Raise exception instead.
+            print(f"Error initializing model {self.name}: {e}")
+            raise RuntimeError(f"Failed to load model {self.name}") from e
+
+    def get_style_safe(self, voice_name: str):
+        """
+        Safely retrieves a voice style. 
+        """
+        # 4. Logic optimized: Map -> Try -> Fallback
+        clean_name = voice_name.lower().strip()
+        target_name = self.voice_mapping.get(clean_name, self.default_voice)
+        print(f"Found voice {target_name}")
+        return target_name
+
+    def preprocess_text(self, text):
+        if not text:
+            return ""
+
+        is_valid, unsupported = True, []
+        if not is_valid:
+            print(f"   ⚠️  Contains {len(unsupported)} unsupported character(s): {unsupported[:5]}")
+            # Escape characters safe for regex usage
+            pattern = f"[{re.escape(''.join(unsupported))}]"
+            preprocessed = re.sub(pattern, "", text)
+            
+            if preprocessed != text:
+                print(f"   After preprocessing: {preprocessed[:50]}...")
+                text = preprocessed
+        else:
+            # Optional: Comment this out in production to reduce log spam
+            print("   ✓ All characters supported")
+            
+        return text
+
+    def generate(self, chunks: str, voice_name: str, speed: float):
+        """
+        Generates audio.
+        Returns: audio_float_array
+        """
+        
+        
+        # If supertonic DOES NOT support speed, simple generation:
+        generator = self.tts(chunks, voice=voice_name,speed=speed)
+        for i, (gs, ps, audio) in enumerate(generator):
+            yield audio.numpy()

requirements.txt

@@ -1,3 +1,6 @@
 supertonic
+kokoro
+pip
+lameenc
 uvicorn
 fastapi

supertonic_model.py

@@ -0,0 +1,89 @@
+import sys
+import re
+import asyncio
+from supertonic import TTS
+import base_model
+
+class StreamingEngine(base_model.BaseEngine):
+    def __init__(self, name):
+        # 1. Initialize configuration variables first
+        self.default_voice = "F1"
+        self.voice_mapping = {
+            "alloy": "F1",
+            "echo": "M1",
+            "fable": "M2",
+            "onyx": "M3",
+            "nova": "F2",
+            "shimmer": "F3"
+        }
+        
+        # 2. Call super init (which usually calls load_model)
+        super().__init__(name)
+
+    def load_model(self):
+        try:
+            self.tts = TTS(auto_download=True)
+            self.text_processor = self.tts.model.text_processor
+            self.sample_rate = self.tts.sample_rate
+            print(f"Model Loaded. Rate: {self.sample_rate}")
+        except Exception as e:
+            # 3. CRITICAL FIX: Don't sys.exit(1). Raise exception instead.
+            print(f"Error initializing model {self.name}: {e}")
+            raise RuntimeError(f"Failed to load model {self.name}") from e
+
+    def get_style_safe(self, voice_name: str):
+        """
+        Safely retrieves a voice style. 
+        """
+        # 4. Logic optimized: Map -> Try -> Fallback
+        clean_name = voice_name.lower().strip()
+        target_name = self.voice_mapping.get(clean_name, self.default_voice)
+        print(f"Found voice {target_name}")
+
+        try:
+            # Try specific voice
+            return self.tts.get_voice_style(voice_name=target_name)
+        except Exception:
+            print(f"WARNING: Voice '{voice_name}' (mapped to '{target_name}') not found. Using '{self.default_voice}'.")
+            
+            # Fallback to default
+            try:
+                return self.tts.get_voice_style(voice_name=self.default_voice)
+            except Exception as e:
+                # If default fails, we are in trouble
+                print(f"CRITICAL: Default voice '{self.default_voice}' also failed.")
+                raise e
+
+    def preprocess_text(self, text):
+        if not text:
+            return ""
+
+        is_valid, unsupported = self.text_processor.validate_text(text)
+
+        if not is_valid:
+            print(f"   ⚠️  Contains {len(unsupported)} unsupported character(s): {unsupported[:5]}")
+            # Escape characters safe for regex usage
+            pattern = f"[{re.escape(''.join(unsupported))}]"
+            preprocessed = re.sub(pattern, "", text)
+            
+            if preprocessed != text:
+                print(f"   After preprocessing: {preprocessed[:50]}...")
+                text = preprocessed
+        else:
+            # Optional: Comment this out in production to reduce log spam
+            print("   ✓ All characters supported")
+            
+        return text
+
+    def generate(self, chunks: str, voice_name: str, speed: float):
+        """
+        Generates audio.
+        Returns: audio_float_array
+        """
+        # 5. Handle Speed (if supported by supertonic, otherwise ignore or warn)
+        # Assuming supertonic.synthesize supports a speed or speed_ratio argument:
+        # audio = self.tts.synthesize(chunks, voice_name, speed=speed)
+        
+        # If supertonic DOES NOT support speed, simple generation:
+        audio,_ = self.tts.synthesize(chunks, voice_name)
+        yield audio

test/run_kokoro.py

@@ -0,0 +1,10 @@
+from kokoro import KPipeline
+import soundfile as sf
+pipeline = KPipeline(lang_code='a')
+text = '''
+[Kokoro](/kˈOkəɹO/) is an open-weight TTS model with 82 million parameters. Despite its lightweight architecture, it delivers comparable quality to larger models while being significantly faster and more cost-efficient. With Apache-licensed weights, [Kokoro](/kˈOkəɹO/) can be deployed anywhere from production environments to personal projects.
+'''
+generator = pipeline(text, voice='af_heart')
+for i, (gs, ps, audio) in enumerate(generator):
+    print(i, gs, ps)
+    sf.write(f'{i}.wav', audio, 24000)

test/speech.sh

@@ -0,0 +1,27 @@
+curl http://localhost:8000/v1/audio/speech   -H "Content-Type: application/json"  -H "Authorization: Bearer yourapi"  -d '{
+    "model": "tts-2",
+    "input": "Supertonic is a lightning-fast, on-device text-to-speech system designed for extreme performance with minimal computational overhead. Powered by ONNX Runtime, it runs entirely on your device—no cloud, no API calls, no privacy concerns.",
+    "voice": "alloy",
+    "format": "wav"
+  }'   --output ./v2.wav
+
+curl http://localhost:8000/v1/audio/speech   -H "Content-Type: application/json"  -H "Authorization: Bearer yourapi"  -d '{
+    "model": "tts-2",
+    "input": "Supertonic is a lightning-fast, on-device text-to-speech system designed for extreme performance with minimal computational overhead. Powered by ONNX Runtime, it runs entirely on your device—no cloud, no API calls, no privacy concerns.",
+    "voice": "alloy",
+    "format": "mp3"
+  }'   --output ./v2.mp3
+
+  curl http://localhost:8000/v1/audio/speech   -H "Content-Type: application/json"  -H "Authorization: Bearer yourapi"  -d '{
+    "model": "tts-1",
+    "input": "[Kokoro](/kˈOkəɹO/) is an open-weight TTS model with 82 million parameters. Despite its lightweight architecture, it delivers comparable quality to larger models while being significantly faster and more cost-efficient. With Apache-licensed weights, [Kokoro](/kˈOkəɹO/) can be deployed anywhere from production environments to personal projects.",
+    "voice": "alloy",
+    "format": "wav"
+  }'   --output ./v1.wav
+
+curl http://localhost:8000/v1/audio/speech   -H "Content-Type: application/json"  -H "Authorization: Bearer yourapi"  -d '{
+    "model": "tts-1",
+    "input": "[Kokoro](/kˈOkəɹO/) is an open-weight TTS model with 82 million parameters. Despite its lightweight architecture, it delivers comparable quality to larger models while being significantly faster and more cost-efficient. With Apache-licensed weights, [Kokoro](/kˈOkəɹO/) can be deployed anywhere from production environments to personal projects.",
+    "voice": "alloy",
+    "format": "mp3"
+  }'   --output ./v1.mp3

utils.py

@@ -0,0 +1,114 @@
+import numpy as np
+import re
+import struct
+import lameenc
+
+def split_text_into_sentences(text: str, min_chunk_size: int = 150):
+    if not text:
+        return []
+
+    # Clean text
+    text = re.sub(r'\s+', ' ', text).strip()
+
+    # Split atomic sentences
+    raw_parts = re.split(r'([.?!:;]+)(?=\s|$)', text)
+    
+    atomic_sentences = []
+    current_atomic = ""
+    
+    for part in raw_parts:
+        if re.match(r'^[.?!:;]+$', part):
+            current_atomic += part
+            if current_atomic.strip():
+                atomic_sentences.append(current_atomic.strip())
+            current_atomic = ""
+        else:
+            current_atomic += part
+            
+    if current_atomic.strip():
+        atomic_sentences.append(current_atomic.strip())
+
+    # Batching Logic
+    final_chunks = []
+    current_buffer = ""
+    first_sentence_sent = False
+
+    for sentence in atomic_sentences:
+        if not first_sentence_sent:
+            final_chunks.append(sentence)
+            first_sentence_sent = True
+            continue
+
+        if current_buffer:
+            current_buffer += " " + sentence
+        else:
+            current_buffer = sentence
+
+        if len(current_buffer) >= min_chunk_size:
+            final_chunks.append(current_buffer)
+            current_buffer = ""
+
+    if current_buffer:
+        final_chunks.append(current_buffer)
+
+    return final_chunks
+
+def create_wav_header(sample_rate: int, channels: int = 1, bits_per_sample: int = 16):
+    byte_rate = sample_rate * channels * bits_per_sample // 8
+    block_align = channels * bits_per_sample // 8
+    
+    header = b'RIFF'
+    header += struct.pack('<I', 0xFFFFFFFF) 
+    header += b'WAVE'
+    header += b'fmt '
+    header += struct.pack('<I', 16) 
+    header += struct.pack('<H', 1) 
+    header += struct.pack('<H', channels)
+    header += struct.pack('<I', sample_rate)
+    header += struct.pack('<I', byte_rate)
+    header += struct.pack('<H', block_align)
+    header += struct.pack('<H', bits_per_sample)
+    header += b'data'
+    header += struct.pack('<I', 0xFFFFFFFF)
+    
+    return header
+
+def float_to_pcm16(audio_array):
+    """Converts float32 audio to int16 bytes."""
+    audio_array = np.array(audio_array)
+    if len(audio_array.shape) > 1:
+        audio_array = audio_array.flatten()
+    
+    # Clip to prevent distortion
+    audio_array = np.clip(audio_array, -1.0, 1.0)
+    
+    # Convert to 16-bit PCM
+    audio_int16 = (audio_array * 32767).astype(np.int16)
+    return audio_int16.tobytes()
+
+def create_mp3_encoder(sample_rate=44100, channels=1, bit_rate=128, quality=5):
+    encoder = lameenc.Encoder()
+    encoder.set_bit_rate(bit_rate)
+    encoder.set_in_sample_rate(sample_rate)
+    encoder.set_channels(channels)
+    encoder.set_quality(quality) 
+    return encoder
+
+
+def float_to_mp3(audio_array, encoder):
+    """
+    Converts float32 audio -> Int16 -> Encoded MP3 bytes.
+    """
+    # 1. Convert Float to PCM Int16
+    audio_array = np.array(audio_array)
+    if len(audio_array.shape) > 1:
+        audio_array = audio_array.flatten()
+    
+    audio_array = np.clip(audio_array, -1.0, 1.0)
+    audio_int16 = (audio_array * 32767).astype(np.int16)
+    
+    # 2. Encode to MP3
+    # lameenc returns a bytearray, but FastAPI/Starlette requires strictly 'bytes'
+    mp3_data = encoder.encode(audio_int16.tobytes())
+    
+    return bytes(mp3_data)  # <--- CRITICAL FIX: Convert bytearray to bytes