api updated

.gitignore

@@ -45,3 +45,5 @@ wheels/
 .installed.cfg
 *.egg
 MANIFEST
+
+**/output/

api/README.md

@@ -1,6 +1,15 @@
-# API Package
+# Enhanced Chatterbox TTS API
 
-This package contains the modular components of the Chatterbox TTS API.
+This package contains the modular components of the Enhanced Chatterbox TTS API with GPU-accelerated processing, intelligent text chunking, and server-side audio concatenation.
+
+## Features
+
+- **GPU-Accelerated Processing**: Leverage server GPU for parallel chunk processing
+- **Intelligent Text Chunking**: Smart text splitting that respects sentence and paragraph boundaries
+- **Server-Side Concatenation**: Seamless audio merging with fade effects and silence control
+- **Voice Cloning**: Optional voice prompt for personalized speech generation
+- **Multiple Response Formats**: Streaming audio, complete files, or JSON with base64 encoding
+- **Scalable Architecture**: Handles texts of any length efficiently
 
 ## Structure
 
@@ -8,9 +17,11 @@ This package contains the modular components of the Chatterbox TTS API.
 api/
 ├── __init__.py          # Package initialization and exports
 ├── config.py            # Modal app configuration and container image setup
-├── models.py            # Pydantic request/response models
+├── models.py            # Pydantic request/response models (enhanced with full-text support)
 ├── audio_utils.py       # Audio processing utilities and helper functions
+├── text_processing.py   # Server-side text chunking and audio concatenation
 ├── tts_service.py       # Main TTS service class with all API endpoints
+├── test_api.py          # Comprehensive API testing suite
 └── README.md           # This file
 ```
 
@@ -18,16 +29,25 @@ api/
 
 ### config.py
 
-- Modal app configuration
+- Modal app configuration with GPU support (A10G)
 - Container image setup with required dependencies
 - Centralized configuration management
+- Memory snapshot and scaling configuration
 
 ### models.py
 
-- `TTSRequest`: Request model for TTS generation
-- `TTSResponse`: Response model for JSON endpoints
+- `TTSRequest`: Standard request model for TTS generation
+- `FullTextTTSRequest`: Enhanced request model for full-text processing with chunking parameters
+- `TTSResponse`: Standard response model for JSON endpoints
+- `FullTextTTSResponse`: Enhanced response with processing information
 - `HealthResponse`: Response model for health checks
-- All models include proper type hints and documentation
+- All models include proper type hints, validation, and documentation
+
+### text_processing.py
+
+- `TextChunker`: Intelligent server-side text chunking with configurable parameters
+- `AudioConcatenator`: Server-side audio concatenation with fade effects and silence control
+- Optimized for GPU processing and large text handling
 
 ### audio_utils.py
 
@@ -42,6 +62,120 @@ api/
 - GPU-accelerated TTS model loading and inference
 - Multiple API endpoints for different use cases
 - Comprehensive error handling and validation
+- New full-text processing endpoints with parallel chunk processing
+
+### test_api.py
+
+- Comprehensive testing suite for all API endpoints
+- Tests for basic generation, voice cloning, file uploads, and full-text processing
+- Performance benchmarking and validation scripts
+
+## API Endpoints
+
+### Standard Endpoints
+
+#### `GET /health`
+
+Health check endpoint to verify model status and service availability.
+
+```bash
+curl -X GET "YOUR-ENDPOINT/health"
+```
+
+#### `POST /generate_audio`
+
+Generate speech audio from text with optional voice cloning (streaming response).
+
+```bash
+curl -X POST "YOUR-ENDPOINT/generate_audio" \
+  -H "Content-Type: application/json" \
+  -d '{"text": "Hello world!"}' \
+  --output output.wav
+```
+
+#### `POST /generate_json`
+
+Generate speech and return JSON with base64 encoded audio.
+
+```bash
+curl -X POST "YOUR-ENDPOINT/generate_json" \
+  -H "Content-Type: application/json" \
+  -d '{"text": "Hello world!"}'
+```
+
+#### `POST /generate_with_file`
+
+Generate speech with file upload for voice cloning.
+
+```bash
+curl -X POST "YOUR-ENDPOINT/generate_with_file" \
+  -F "text=Hello world!" \
+  -F "voice_prompt=@voice_sample.wav" \
+  --output output.wav
+```
+
+### Enhanced Full-Text Endpoints
+
+#### `POST /generate_full_text_audio`
+
+🆕 Generate speech from full text with server-side chunking and parallel processing.
+
+```bash
+curl -X POST "YOUR-ENDPOINT/generate_full_text_audio" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "text": "Your very long text here...",
+    "max_chunk_size": 800,
+    "silence_duration": 0.5,
+    "fade_duration": 0.1,
+    "overlap_sentences": 0
+  }' \
+  --output full_text_output.wav
+```
+
+#### `POST /generate_full_text_json`
+
+🆕 Generate speech from full text and return JSON with processing information.
+
+```bash
+curl -X POST "YOUR-ENDPOINT/generate_full_text_json" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "text": "Your very long text here...",
+    "max_chunk_size": 800,
+    "silence_duration": 0.5
+  }'
+```
+
+### Legacy Endpoints
+
+#### `POST /generate`
+
+Legacy endpoint for backward compatibility.
+
+```bash
+curl -X POST "YOUR-ENDPOINT/generate?prompt=Hello%20world!" \
+  --output legacy_output.wav
+```
+
+## Request Parameters
+
+### FullTextTTSRequest Parameters
+
+- **`text`** (required): The text to convert to speech (any length)
+- **`voice_prompt_base64`** (optional): Base64 encoded voice prompt for cloning
+- **`max_chunk_size`** (optional, default: 800): Maximum characters per chunk
+- **`silence_duration`** (optional, default: 0.5): Silence between chunks in seconds
+- **`fade_duration`** (optional, default: 0.1): Fade in/out duration in seconds
+- **`overlap_sentences`** (optional, default: 0): Sentences to overlap between chunks
+
+## Response Headers
+
+Enhanced endpoints include additional headers with processing information:
+
+- **`X-Audio-Duration`**: Duration of generated audio in seconds
+- **`X-Chunks-Processed`**: Number of text chunks processed
+- **`X-Total-Characters`**: Total characters in the input text
 
 ## Usage
 
@@ -52,10 +186,95 @@ from api import app, ChatterboxTTSService
 # The service class contains all the endpoints
 ```
 
-## Benefits of Modular Architecture
+### Python Client Example
+
+```python
+import requests
+
+# Generate audio from long text
+response = requests.post(
+    "YOUR-ENDPOINT/generate_full_text_audio",
+    json={
+        "text": "Your long document text here...",
+        "max_chunk_size": 800,
+        "silence_duration": 0.5
+    }
+)
+
+if response.status_code == 200:
+    with open("output.wav", "wb") as f:
+        f.write(response.content)
+    print("Audio generated successfully!")
+```
+
+## Performance Characteristics
+
+### Standard Processing
+
+- **Text Length**: Up to ~1000 characters optimal
+- **Processing Time**: ~2-5 seconds per request
+- **Use Case**: Short texts, real-time applications
+
+### Full-Text Processing
+
+- **Text Length**: Unlimited (automatically chunked)
+- **Processing Time**: ~5-15 seconds for long documents
+- **Parallelization**: Up to 4 concurrent chunks
+- **Use Case**: Documents, articles, books
+
+## Deployment
+
+```bash
+# Deploy the enhanced API
+modal deploy tts_service.py
+
+# Test the deployment
+python test_api.py
+```
+
+````
+
+## Benefits of Enhanced Architecture
+
+1. **GPU Acceleration**: Server-side processing leverages GPU resources for faster inference
+2. **Intelligent Chunking**: Smart text splitting that preserves sentence integrity
+3. **Parallel Processing**: Multiple chunks processed simultaneously for better performance
+4. **Scalability**: Handles texts of any length without client-side limitations
+5. **Separation of Concerns**: Each file has a specific responsibility
+6. **Maintainability**: Easier to update and modify individual components
+7. **Testability**: Components can be tested in isolation
+8. **Reusability**: Components can be imported and used in other projects
+9. **Readability**: Smaller files are easier to understand and navigate
 
-1. **Separation of Concerns**: Each file has a specific responsibility
-2. **Maintainability**: Easier to update and modify individual components
-3. **Testability**: Components can be tested in isolation
-4. **Reusability**: Components can be imported and used in other projects
-5. **Readability**: Smaller files are easier to understand and navigate
+## Testing
+
+Run the comprehensive test suite:
+
+```bash
+cd api/
+python test_api.py
+````
+
+The test suite includes:
+
+- Health check validation
+- Basic text-to-speech generation
+- JSON response testing
+- Voice cloning functionality
+- File upload testing
+- Full-text processing validation
+- Performance benchmarking
+
+## Environment Variables
+
+Set these environment variables for testing:
+
+```bash
+HEALTH_ENDPOINT=https://your-modal-endpoint.modal.run/health
+GENERATE_AUDIO_ENDPOINT=https://your-modal-endpoint.modal.run/generate_audio
+GENERATE_JSON_ENDPOINT=https://your-modal-endpoint.modal.run/generate_json
+GENERATE_WITH_FILE_ENDPOINT=https://your-modal-endpoint.modal.run/generate_with_file
+GENERATE_ENDPOINT=https://your-modal-endpoint.modal.run/generate
+FULL_TEXT_TTS_ENDPOINT=https://your-modal-endpoint.modal.run/generate_full_text_audio
+FULL_TEXT_JSON_ENDPOINT=https://your-modal-endpoint.modal.run/generate_full_text_json
+```

api/audio_concatenator.py

@@ -0,0 +1,196 @@
+"""Audio processing utilities for the TTS API."""
+
+import re
+from typing import List
+
+
+class AudioConcatenator:
+    """Server-side audio concatenation with GPU acceleration."""
+    
+    def __init__(self, silence_duration: float = 0.5, fade_duration: float = 0.1):
+        """
+        Initialize the audio concatenator.
+        
+        Args:
+            silence_duration: Duration of silence between chunks (seconds)
+            fade_duration: Duration of fade in/out effects (seconds)
+        """
+        self.silence_duration = silence_duration
+        self.fade_duration = fade_duration
+    
+    def concatenate_audio_chunks(self, audio_chunks: List, sample_rate: int):
+        """
+        Concatenate multiple audio chunks into a single audio file.
+        
+        Args:
+            audio_chunks: List of audio arrays
+            sample_rate: Sample rate for the audio
+            
+        Returns:
+            Concatenated audio array
+        """
+        if not audio_chunks:
+            raise ValueError("No audio chunks to concatenate")
+        
+        if len(audio_chunks) == 1:
+            # Handle single chunk case
+            audio = audio_chunks[0]
+            if isinstance(audio, tuple):
+                return audio[0]  # Extract audio data from tuple
+            return audio
+        
+        import numpy as np
+        import torch
+        
+        # Normalize and prepare audio data
+        normalized_chunks = []
+        for i, audio_data in enumerate(audio_chunks):
+            print(f"Processing chunk {i}: type={type(audio_data)}")
+            
+            # Handle tuple format (common from TTS models)
+            if isinstance(audio_data, tuple):
+                audio_data = audio_data[0]  # Extract audio array from tuple
+                print(f"  Extracted from tuple: type={type(audio_data)}")
+            
+            # Convert torch tensor to numpy if needed
+            if hasattr(audio_data, 'cpu'):  # It's a torch tensor
+                audio_data = audio_data.cpu().numpy()
+                print(f"  Converted from torch: shape={audio_data.shape}")
+            
+            # Convert to numpy array if needed
+            if not isinstance(audio_data, np.ndarray):
+                audio_data = np.array(audio_data)
+            
+            print(f"  Final shape before processing: {audio_data.shape}")
+            
+            # Handle different audio shapes
+            if audio_data.ndim == 1:
+                # Already 1D, perfect
+                normalized_audio = audio_data
+            elif audio_data.ndim == 2:
+                # Handle 2D audio - could be (channels, samples) or (samples, channels)
+                if audio_data.shape[0] < audio_data.shape[1]:
+                    # Likely (channels, samples) - take first channel
+                    normalized_audio = audio_data[0, :]
+                    print(f"  Used first channel from (C, L) format: {normalized_audio.shape}")
+                else:
+                    # Likely (samples, channels) - take first channel
+                    normalized_audio = audio_data[:, 0]
+                    print(f"  Used first channel from (L, C) format: {normalized_audio.shape}")
+            else:
+                # Flatten higher dimensional arrays
+                normalized_audio = audio_data.flatten()
+                print(f"  Flattened {audio_data.ndim}D array: {normalized_audio.shape}")
+            
+            # Ensure we have valid audio data
+            if len(normalized_audio) == 0:
+                print(f"  Warning: Empty audio chunk {i}")
+                continue
+            
+            print(f"  Chunk {i} final length: {len(normalized_audio)} samples ({len(normalized_audio)/sample_rate:.2f}s)")
+            
+            # Normalize audio levels
+            normalized_audio = self._normalize_audio(normalized_audio)
+            
+            # Apply fade effects
+            normalized_audio = self._apply_fade_effects(normalized_audio, sample_rate)
+            
+            normalized_chunks.append(normalized_audio)
+        
+        if not normalized_chunks:
+            raise ValueError("No valid audio chunks after processing")
+        
+        print(f"Successfully processed {len(normalized_chunks)} chunks")
+        
+        # Create silence segments
+        silence_samples = int(self.silence_duration * sample_rate)
+        silence = np.zeros(silence_samples, dtype=np.float32)
+        print(f"Adding {silence_samples} silence samples ({self.silence_duration}s) between chunks")
+        
+        # Concatenate all chunks with silence in between
+        concatenated_segments = []
+        total_audio_length = 0
+        
+        for i, chunk in enumerate(normalized_chunks):
+            concatenated_segments.append(chunk)
+            total_audio_length += len(chunk)
+            print(f"Added chunk {i}: {len(chunk)} samples")
+            
+            # Add silence between chunks (but not after the last chunk)
+            if i < len(normalized_chunks) - 1:
+                concatenated_segments.append(silence)
+                total_audio_length += len(silence)
+                print(f"Added silence: {len(silence)} samples")
+        
+        # Combine all segments
+        final_audio = np.concatenate(concatenated_segments)
+        print(f"Final concatenated audio: {len(final_audio)} samples ({len(final_audio)/sample_rate:.2f}s)")
+        
+        # Final normalization and cleanup
+        final_audio = self._normalize_audio(final_audio)
+        final_audio = self._remove_clicks_and_pops(final_audio)
+        
+        return final_audio
+
+    def _normalize_audio(self, audio_data):
+        """Normalize audio to prevent clipping."""
+        import numpy as np
+        
+        # Convert to numpy array if it's not already
+        if not isinstance(audio_data, np.ndarray):
+            audio_data = np.array(audio_data)
+        
+        # Ensure it's a 1D array
+        if audio_data.ndim > 1:
+            audio_data = audio_data.flatten()
+        
+        # Find the maximum absolute value
+        max_val = np.max(np.abs(audio_data))
+        
+        if max_val == 0:
+            return audio_data
+        
+        # Normalize to 95% of maximum to leave some headroom
+        normalized = audio_data * (0.95 / max_val)
+        
+        return normalized.astype(np.float32)
+    
+    def _apply_fade_effects(self, audio_data, sample_rate: int):
+        """Apply fade in and fade out effects to reduce pops and clicks."""
+        import numpy as np
+        
+        fade_samples = int(self.fade_duration * sample_rate)
+        
+        if len(audio_data) < 2 * fade_samples:
+            # If audio is too short for fade effects, return as-is
+            return audio_data
+        
+        audio_with_fades = audio_data.copy()
+        
+        # Apply fade in
+        fade_in = np.linspace(0, 1, fade_samples)
+        audio_with_fades[:fade_samples] *= fade_in
+        
+        # Apply fade out
+        fade_out = np.linspace(1, 0, fade_samples)
+        audio_with_fades[-fade_samples:] *= fade_out
+        
+        return audio_with_fades
+    
+    def _remove_clicks_and_pops(self, audio_data):
+        """Apply basic filtering to remove clicks and pops."""
+        try:
+            # Simple high-pass filter to remove DC offset and low-frequency artifacts
+            from scipy import signal
+            import numpy as np
+            
+            # Design a high-pass filter (removes frequencies below 80 Hz)
+            # This helps remove some pops and clicks while preserving speech
+            nyquist = 22050 / 2  # Assuming common sample rate
+            low = 80 / nyquist
+            b, a = signal.butter(4, low, btype='high')
+            filtered_audio = signal.filtfilt(b, a, audio_data)
+            return filtered_audio.astype(np.float32)
+        except ImportError:
+            # If scipy is not available, return original audio
+            return audio_data

api/demo.py

@@ -0,0 +1,177 @@
+#!/usr/bin/env python3
+"""
+Quick demonstration script for the Enhanced Chatterbox TTS API
+Shows how to use the new full-text endpoints for processing long documents
+"""
+
+import requests
+import os
+from pathlib import Path
+from dotenv import load_dotenv
+
+# Load environment variables
+load_dotenv()
+
+def demo_full_text_processing():
+    """Demonstrate full-text processing with a sample document"""
+    
+    # Sample long text (like from a PDF)
+    sample_document = """
+    Artificial Intelligence has revolutionized numerous industries and continues to shape our world in unprecedented ways. From healthcare to transportation, AI systems are becoming increasingly sophisticated and capable of performing complex tasks that were once thought to be exclusively human domains.
+
+    In healthcare, AI-powered diagnostic systems can now identify diseases with remarkable accuracy, sometimes surpassing human doctors in specific areas. Machine learning algorithms analyze medical images, predict patient outcomes, and assist in drug discovery processes. This technological advancement has the potential to make healthcare more accessible and effective globally.
+
+    The transportation sector has also witnessed significant AI integration. Autonomous vehicles use computer vision, sensor fusion, and deep learning to navigate complex environments safely. These systems process vast amounts of real-time data to make split-second decisions, potentially reducing traffic accidents and improving transportation efficiency.
+
+    However, with these advancements come important ethical considerations. Issues of privacy, job displacement, and algorithmic bias must be carefully addressed as AI systems become more prevalent in society. It is crucial that we develop AI responsibly, ensuring that these powerful technologies benefit humanity while minimizing potential risks.
+
+    The future of AI holds immense promise, but it requires thoughtful implementation and continuous oversight to ensure that its development aligns with human values and societal needs.
+    """
+    
+    endpoint = os.getenv("FULL_TEXT_TTS_ENDPOINT")
+    if not endpoint:
+        print("❌ FULL_TEXT_TTS_ENDPOINT not configured")
+        print("Please set the environment variable or update your .env file")
+        return False
+    
+    print("🎙️ Enhanced Chatterbox TTS API Demo")
+    print("=" * 50)
+    print(f"Processing document ({len(sample_document)} characters)...")
+    
+    try:
+        # Send request to full-text endpoint
+        response = requests.post(
+            endpoint,
+            json={
+                "text": sample_document.strip(),
+                "max_chunk_size": 600,  # Smaller chunks for better processing
+                "silence_duration": 0.6,  # Slightly longer pause between chunks
+                "fade_duration": 0.2,  # Smooth transitions
+                "overlap_sentences": 1  # Overlap for better continuity
+            },
+            timeout=180  # Allow time for processing
+        )
+        
+        if response.status_code == 200:
+            # Save the generated audio
+            Path("demo_output").mkdir(exist_ok=True)
+            output_file = "demo_output/ai_document_speech.wav"
+            
+            with open(output_file, "wb") as f:
+                f.write(response.content)
+            
+            # Extract processing information from headers
+            duration = response.headers.get('X-Audio-Duration', 'unknown')
+            chunks = response.headers.get('X-Chunks-Processed', 'unknown')
+            characters = response.headers.get('X-Total-Characters', 'unknown')
+            
+            print("✅ Success! Audio generated and saved")
+            print(f"📁 File: {output_file}")
+            print(f"⏱️  Duration: {duration} seconds")
+            print(f"🧩 Chunks processed: {chunks}")
+            print(f"📝 Characters: {characters}")
+            print(f"💾 File size: {Path(output_file).stat().st_size / 1024:.1f} KB")
+            
+            return True
+        else:
+            print(f"❌ Request failed with status {response.status_code}")
+            print(f"Response: {response.text}")
+            return False
+            
+    except requests.exceptions.Timeout:
+        print("⏰ Request timed out - the document might be too long")
+        return False
+    except Exception as e:
+        print(f"❌ Error: {e}")
+        return False
+
+
+def demo_comparison():
+    """Compare standard vs full-text processing"""
+    
+    short_text = "This is a short text for comparison."
+    medium_text = """
+    This is a medium-length text that demonstrates the difference between 
+    standard and full-text processing endpoints. The full-text endpoint 
+    provides better handling for longer content with intelligent chunking 
+    and server-side concatenation.
+    """
+    
+    standard_endpoint = os.getenv("GENERATE_AUDIO_ENDPOINT")
+    fulltext_endpoint = os.getenv("FULL_TEXT_TTS_ENDPOINT")
+    
+    if not (standard_endpoint and fulltext_endpoint):
+        print("⚠️ Missing endpoint configuration for comparison")
+        return False
+    
+    print("\n🔍 Comparison Demo")
+    print("=" * 30)
+    
+    try:
+        import time
+        
+        # Test standard endpoint
+        print("Testing standard endpoint...")
+        start_time = time.time()
+        response1 = requests.post(
+            standard_endpoint,
+            json={"text": short_text},
+            timeout=30
+        )
+        standard_time = time.time() - start_time
+        
+        # Test full-text endpoint
+        print("Testing full-text endpoint...")
+        start_time = time.time()
+        response2 = requests.post(
+            fulltext_endpoint,
+            json={"text": medium_text.strip(), "max_chunk_size": 400},
+            timeout=60
+        )
+        fulltext_time = time.time() - start_time
+        
+        print(f"\n📊 Results:")
+        print(f"Standard endpoint: {standard_time:.2f}s (short text)")
+        print(f"Full-text endpoint: {fulltext_time:.2f}s (medium text)")
+        
+        if response2.status_code == 200:
+            chunks = response2.headers.get('X-Chunks-Processed', 'unknown')
+            print(f"Full-text chunks processed: {chunks}")
+        
+        return True
+        
+    except Exception as e:
+        print(f"❌ Comparison error: {e}")
+        return False
+
+
+def main():
+    """Run the demonstration"""
+    print("🚀 Enhanced Chatterbox TTS API Demonstration")
+    print("This demo showcases the new full-text processing capabilities")
+    print()
+    
+    # Check if .env file exists
+    if not Path(".env").exists():
+        print("📝 Creating sample .env file...")
+        print("Please update it with your actual Modal endpoint URLs")
+        
+        env_content = """# Enhanced Chatterbox TTS API Endpoints
+FULL_TEXT_TTS_ENDPOINT=https://YOUR-MODAL-ENDPOINT.modal.run/generate_full_text_audio
+GENERATE_AUDIO_ENDPOINT=https://YOUR-MODAL-ENDPOINT.modal.run/generate_audio
+"""
+        with open(".env", "w") as f:
+            f.write(env_content)
+        print("✅ Sample .env file created")
+        return
+    
+    # Run demonstrations
+    demo_full_text_processing()
+    demo_comparison()
+    
+    print("\n🎉 Demo complete!")
+    print("Check the demo_output/ directory for generated audio files")
+
+
+if __name__ == "__main__":
+    main()

api/models.py

@@ -4,24 +4,43 @@ Pydantic models for request/response validation and API documentation.
 """
 
 from typing import Optional
-from pydantic import BaseModel
+from pydantic import BaseModel, Field
 
 
 class TTSRequest(BaseModel):
     """Request model for TTS generation with optional voice cloning."""
-    text: str
-    voice_prompt_base64: Optional[str] = None  # Base64 encoded audio file
+    text: str = Field(..., description="Text to convert to speech", max_length=5000)
+    voice_prompt_base64: Optional[str] = Field(None, description="Base64 encoded voice prompt audio")
+
+
+class FullTextTTSRequest(BaseModel):
+    """Request model for full-text TTS generation with server-side processing."""
+    text: str = Field(..., description="Full text to convert to speech (any length)")
+    voice_prompt_base64: Optional[str] = Field(None, description="Base64 encoded voice prompt audio")
+    max_chunk_size: Optional[int] = Field(800, description="Maximum characters per chunk")
+    silence_duration: Optional[float] = Field(0.5, description="Silence duration between chunks (seconds)")
+    fade_duration: Optional[float] = Field(0.1, description="Fade in/out duration (seconds)")
+    overlap_sentences: Optional[int] = Field(0, description="Number of sentences to overlap between chunks")
     
 
 class TTSResponse(BaseModel):
     """Response model for TTS generation with JSON output."""
-    success: bool
-    message: str
-    audio_base64: Optional[str] = None  # Base64 encoded audio response
-    duration_seconds: Optional[float] = None
+    success: bool = Field(..., description="Whether the request was successful")
+    message: str = Field(..., description="Status message")
+    audio_base64: Optional[str] = Field(None, description="Base64 encoded audio data")
+    duration_seconds: Optional[float] = Field(None, description="Duration of generated audio in seconds")
+
+
+class FullTextTTSResponse(BaseModel):
+    """Response model for full-text TTS generation."""
+    success: bool = Field(..., description="Whether the request was successful")
+    message: str = Field(..., description="Status message")
+    audio_base64: Optional[str] = Field(None, description="Base64 encoded audio data")
+    duration_seconds: Optional[float] = Field(None, description="Duration of generated audio in seconds")
+    processing_info: Optional[dict] = Field(None, description="Information about the processing (chunks, etc.)")
 
 
 class HealthResponse(BaseModel):
     """Response model for health check endpoint."""
-    status: str
-    model_loaded: bool
+    status: str = Field(..., description="Service status")
+    model_loaded: bool = Field(..., description="Whether the TTS model is loaded")

api/test_api.py

@@ -0,0 +1,455 @@
+#!/usr/bin/env python3
+"""
+Test script for the enhanced Chatterbox TTS Modal API
+This script demonstrates how to interact with all the new endpoints
+"""
+
+import requests
+import base64
+import json
+import os
+from pathlib import Path
+from dotenv import load_dotenv
+
+# Load environment variables from .env file
+load_dotenv()
+
+# Base URLs for the deployed endpoints
+ENDPOINTS = {
+    "health": os.getenv("HEALTH_ENDPOINT"),
+    "generate_audio": os.getenv("GENERATE_AUDIO_ENDPOINT"),
+    "generate_json": os.getenv("GENERATE_JSON_ENDPOINT"),
+    "generate_with_file": os.getenv("GENERATE_WITH_FILE_ENDPOINT"),
+    "generate": os.getenv("GENERATE_ENDPOINT"),
+    "generate_full_text_audio": os.getenv("GENERATE_FULL_TEXT_AUDIO_ENDPOINT"),
+    "generate_full_text_json": os.getenv("GENERATE_FULL_TEXT_JSON_ENDPOINT")
+}
+
+def test_health_check():
+    """Test the health check endpoint"""
+    print("Testing health check...")
+    try:
+        response = requests.get(ENDPOINTS["health"])
+        print(f"Status: {response.status_code}")
+        print(f"Response: {response.json()}")
+        return response.status_code == 200
+    except Exception as e:
+        print(f"Health check failed: {e}")
+        return False
+
+def test_basic_generation():
+    """Test basic text-to-speech generation"""
+    print("\nTesting basic audio generation...")
+    try:
+        response = requests.post(
+            ENDPOINTS["generate_audio"],
+            json={"text": "Hello, this is Chatterbox TTS running on Modal!"}
+        )
+        if response.status_code == 200:
+            Path("output").mkdir(exist_ok=True)
+            with open("output/basic_output.wav", "wb") as f:
+                f.write(response.content)
+            print("✓ Basic generation successful - saved as output/basic_output.wav")
+            return True
+        else:
+            print(f"✗ Basic generation failed: {response.status_code}")
+            print(f"Response: {response.text}")
+            return False
+    except Exception as e:
+        print(f"✗ Basic generation error: {e}")
+        return False
+
+def test_json_generation():
+    """Test JSON response with base64 audio"""
+    print("\nTesting JSON audio generation...")
+    try:
+        response = requests.post(
+            ENDPOINTS["generate_json"],
+            json={"text": "This returns JSON with base64 audio data"}
+        )
+        if response.status_code == 200:
+            data = response.json()
+            if data['success'] and data['audio_base64']:
+                # Decode base64 audio and save
+                Path("output").mkdir(exist_ok=True)
+                audio_data = base64.b64decode(data['audio_base64'])
+                with open("output/json_output.wav", "wb") as f:
+                    f.write(audio_data)
+                print(f"✓ JSON generation successful - Duration: {data['duration_seconds']:.2f}s")
+                print("  Saved as output/json_output.wav")
+                return True
+            else:
+                print(f"✗ JSON generation failed: {data['message']}")
+                return False
+        else:
+            print(f"✗ JSON generation failed: {response.status_code}")
+            print(f"Response: {response.text}")
+            return False
+    except Exception as e:
+        print(f"✗ JSON generation error: {e}")
+        return False
+
+def test_voice_cloning():
+    """Test voice cloning with audio prompt"""
+    print("\nTesting voice cloning...")
+    
+    # First, check if we have a sample audio file
+    sample_file = Path("voice_sample.wav")
+    if not sample_file.exists():
+        print("⚠ No voice_sample.wav found - skipping voice cloning test")
+        print("  To test voice cloning, add a voice_sample.wav file")
+        return True
+    
+    try:
+        # Read the voice sample and encode as base64
+        with open(sample_file, "rb") as f:
+            voice_data = base64.b64encode(f.read()).decode()
+        
+        response = requests.post(
+            ENDPOINTS["generate_audio"],
+            json={
+                "text": "This should sound like the provided voice sample!",
+                "voice_prompt_base64": voice_data
+            }
+        )
+        
+        if response.status_code == 200:
+            Path("output").mkdir(exist_ok=True)
+            with open("output/cloned_output.wav", "wb") as f:
+                f.write(response.content)
+            print("✓ Voice cloning successful - saved as output/cloned_output.wav")
+            return True
+        else:
+            print(f"✗ Voice cloning failed: {response.status_code}")
+            print(f"Response: {response.text}")
+            return False
+    except Exception as e:
+        print(f"✗ Voice cloning error: {e}")
+        return False
+
+def test_file_upload():
+    """Test file upload endpoint"""
+    print("\nTesting file upload...")
+    
+    sample_file = Path("voice_sample.wav")
+    if not sample_file.exists():
+        print("⚠ No voice_sample.wav found - testing without voice prompt")
+        files = None
+    else:
+        files = {"voice_prompt": open(sample_file, "rb")}
+    
+    try:
+        data = {"text": "Testing the file upload endpoint!"}
+        response = requests.post(ENDPOINTS["generate_with_file"], data=data, files=files)
+        
+        if files:
+            files["voice_prompt"].close()
+        
+        if response.status_code == 200:
+            Path("output").mkdir(exist_ok=True)
+            with open("output/upload_output.wav", "wb") as f:
+                f.write(response.content)
+            print("✓ File upload successful - saved as output/upload_output.wav")
+            return True
+        else:
+            print(f"✗ File upload failed: {response.status_code}")
+            print(f"Response: {response.text}")
+            return False
+    except Exception as e:
+        print(f"✗ File upload error: {e}")
+        return False
+
+def test_legacy_endpoint():
+    """Test backward compatibility with legacy endpoint"""
+    print("\nTesting legacy endpoint...")
+    try:
+        # Legacy endpoint expects query parameters, not form data
+        response = requests.post(
+            ENDPOINTS["generate"],
+            params={"prompt": "Testing the legacy endpoint for backward compatibility"}
+        )
+        if response.status_code == 200:
+            Path("output").mkdir(exist_ok=True)
+            with open("output/legacy_output.wav", "wb") as f:
+                f.write(response.content)
+            print("✓ Legacy endpoint successful - saved as output/legacy_output.wav")
+            return True
+        else:
+            print(f"✗ Legacy endpoint failed: {response.status_code}")
+            print(f"Response: {response.text}")
+            return False
+    except Exception as e:
+        print(f"✗ Legacy endpoint error: {e}")
+        return False
+
+def test_full_text_generation():
+    """Test full-text audio generation with server-side chunking"""
+    print("\nTesting full-text audio generation...")
+    
+    # Create a long text that will require chunking
+    long_text = """
+    This is a comprehensive test of the full-text audio generation endpoint. 
+    The text is intentionally long to demonstrate the server-side chunking capabilities.
+    
+    The enhanced API will automatically split this text into appropriate chunks,
+    process them in parallel using GPU acceleration, and then concatenate the
+    resulting audio segments with proper transitions and fade effects.
+    
+    This approach significantly improves performance for long documents while
+    maintaining high audio quality and natural speech flow. The server handles
+    all the complex processing, allowing the client to simply send the full text
+    and receive the final audio file.
+    
+    The chunking algorithm respects sentence and paragraph boundaries to ensure
+    natural speech patterns and maintains proper context across chunk boundaries.
+    This results in more natural-sounding speech for long-form content.
+    """
+    
+    try:
+        if not ENDPOINTS["generate_full_text_audio"]:
+            print("⚠ FULL_TEXT_TTS_ENDPOINT not configured - skipping full-text test")
+            return True
+            
+        response = requests.post(
+            ENDPOINTS["generate_full_text_audio"],
+            json={
+                "text": long_text.strip(),
+                "max_chunk_size": 400,  # Smaller chunks for testing
+                "silence_duration": 0.3,
+                "fade_duration": 0.1,
+                "overlap_sentences": 0
+            },
+            timeout=120  # Longer timeout for processing
+        )
+        
+        if response.status_code == 200:
+            Path("output").mkdir(exist_ok=True)
+            with open("output/full_text_output.wav", "wb") as f:
+                f.write(response.content)
+            
+            # Check response headers for processing info
+            duration = response.headers.get('X-Audio-Duration', 'unknown')
+            chunks = response.headers.get('X-Chunks-Processed', 'unknown')
+            characters = response.headers.get('X-Total-Characters', len(long_text))
+            
+            print(f"✓ Full-text generation successful")
+            print(f"  Duration: {duration}s")
+            print(f"  Chunks processed: {chunks}")
+            print(f"  Characters: {characters}")
+            print("  Saved as output/full_text_output.wav")
+            return True
+        else:
+            print(f"✗ Full-text generation failed: {response.status_code}")
+            print(f"Response: {response.text}")
+            return False
+    except requests.exceptions.Timeout:
+        print("✗ Full-text generation timed out (this may be normal for very long texts)")
+        return False
+    except Exception as e:
+        print(f"✗ Full-text generation error: {e}")
+        return False
+
+
+def test_full_text_json():
+    """Test full-text JSON response with processing information"""
+    print("\nTesting full-text JSON response...")
+    
+    test_text = """
+    This is a test of the full-text JSON endpoint that returns detailed
+    processing information along with the base64 encoded audio data.
+    
+    The response includes chunk information, processing parameters,
+    and timing details that can be useful for monitoring and debugging.
+    """
+    
+    try:
+        if not ENDPOINTS["generate_full_text_json"]:
+            print("⚠ FULL_TEXT_JSON_ENDPOINT not configured - skipping test")
+            return True
+            
+        response = requests.post(
+            ENDPOINTS["generate_full_text_json"],
+            json={
+                "text": test_text.strip(),
+                "max_chunk_size": 300,
+                "silence_duration": 0.4,
+                "fade_duration": 0.15
+            },
+            timeout=60
+        )
+        
+        if response.status_code == 200:
+            data = response.json()
+            if data['success'] and data['audio_base64']:
+                # Decode and save audio
+                Path("output").mkdir(exist_ok=True)
+                audio_data = base64.b64decode(data['audio_base64'])
+                with open("output/full_text_json_output.wav", "wb") as f:
+                    f.write(audio_data)
+                
+                # Display processing information
+                print(f"✓ Full-text JSON generation successful")
+                print(f"  Duration: {data['duration_seconds']:.2f}s")
+                
+                if 'processing_info' in data:
+                    info = data['processing_info']
+                    if 'chunk_info' in info:
+                        chunk_info = info['chunk_info']
+                        print(f"  Chunks: {chunk_info.get('total_chunks', 'unknown')}")
+                        print(f"  Characters: {chunk_info.get('total_characters', 'unknown')}")
+                        print(f"  Avg chunk size: {chunk_info.get('avg_chunk_size', 'unknown'):.0f}")
+                
+                print("  Saved as output/full_text_json_output.wav")
+                return True
+            else:
+                print(f"✗ Full-text JSON generation failed: {data['message']}")
+                return False
+        else:
+            print(f"✗ Full-text JSON generation failed: {response.status_code}")
+            print(f"Response: {response.text}")
+            return False
+    except Exception as e:
+        print(f"✗ Full-text JSON generation error: {e}")
+        return False
+
+
+def test_performance_comparison():
+    """Compare performance between standard and full-text endpoints"""
+    print("\nTesting performance comparison...")
+    
+    # Short text for standard endpoint
+    short_text = "This is a short text for performance comparison testing."
+    
+    # Medium text that benefits from chunking
+    medium_text = """
+    This is a medium-length text designed to test the performance differences
+    between the standard endpoint and the enhanced full-text endpoint.
+    
+    The full-text endpoint should show its advantages when processing longer
+    texts that require intelligent chunking and parallel processing.
+    
+    This text is long enough to require multiple chunks but not so long
+    that it becomes unwieldy for testing purposes.
+    """
+    
+    results = {}
+    
+    try:
+        # Test standard endpoint with short text
+        import time
+        start_time = time.time()
+        response = requests.post(
+            ENDPOINTS["generate_audio"],
+            json={"text": short_text},
+            timeout=30
+        )
+        if response.status_code == 200:
+            results['standard_short'] = time.time() - start_time
+            print(f"✓ Standard endpoint (short): {results['standard_short']:.2f}s")
+        
+        # Test full-text endpoint with medium text
+        if ENDPOINTS["generate_full_text_audio"]:
+            start_time = time.time()
+            response = requests.post(
+                ENDPOINTS["generate_full_text_audio"],
+                json={
+                    "text": medium_text.strip(),
+                    "max_chunk_size": 300
+                },
+                timeout=60
+            )
+            if response.status_code == 200:
+                results['fulltext_medium'] = time.time() - start_time
+                chunks = response.headers.get('X-Chunks-Processed', 'unknown')
+                print(f"✓ Full-text endpoint (medium, {chunks} chunks): {results['fulltext_medium']:.2f}s")
+        
+        # Summary
+        if results:
+            print("  Performance comparison complete!")
+            return True
+        else:
+            print("  Could not complete performance comparison")
+            return False
+            
+    except Exception as e:
+        print(f"✗ Performance comparison error: {e}")
+        return False
+
+def main():
+    """Run all tests"""
+    print("Enhanced Chatterbox TTS API Test Suite")
+    print("=" * 50)
+    
+    # Check if required endpoints are configured
+    missing_endpoints = [name for name, url in ENDPOINTS.items() if not url]
+    if missing_endpoints:
+        print("⚠ Warning: Some endpoints not configured:")
+        for endpoint in missing_endpoints:
+            print(f"   {endpoint}")
+        print("   Set environment variables in .env file")
+        print()
+    
+    tests = [
+        test_health_check,
+        test_basic_generation,
+        test_json_generation,
+        test_voice_cloning,
+        test_file_upload,
+        test_legacy_endpoint,
+        test_full_text_generation,
+        test_performance_comparison
+    ]
+    
+    results = []
+    for test in tests:
+        results.append(test())
+    
+    print("\n" + "=" * 50)
+    print("Test Results:")
+    passed = sum(results)
+    total = len(results)
+    print(f"✓ {passed}/{total} tests passed")
+    
+    if passed == total:
+        print("🎉 All tests passed!")
+        print("\nGenerated files in output/ directory:")
+        output_dir = Path("output")
+        if output_dir.exists():
+            for file in output_dir.glob("*.wav"):
+                size_kb = file.stat().st_size / 1024
+                print(f"   {file.name} ({size_kb:.1f} KB)")
+    else:
+        print("⚠ Some tests failed - check your Modal deployment")
+        
+    print(f"\nAPI Endpoints tested:")
+    for name, url in ENDPOINTS.items():
+        status = "✓" if url else "✗"
+        print(f"   {status} {name}: {url or 'Not configured'}")
+
+
+def create_sample_env_file():
+    """Create a sample .env file with endpoint placeholders"""
+    env_content = """# Enhanced Chatterbox TTS API Endpoints
+# Replace YOUR-MODAL-ENDPOINT with your actual Modal deployment URL
+
+HEALTH_ENDPOINT=https://YOUR-MODAL-ENDPOINT.modal.run/health
+GENERATE_AUDIO_ENDPOINT=https://YOUR-MODAL-ENDPOINT.modal.run/generate_audio
+GENERATE_JSON_ENDPOINT=https://YOUR-MODAL-ENDPOINT.modal.run/generate_json
+GENERATE_WITH_FILE_ENDPOINT=https://YOUR-MODAL-ENDPOINT.modal.run/generate_with_file
+GENERATE_ENDPOINT=https://YOUR-MODAL-ENDPOINT.modal.run/generate
+
+# New enhanced endpoints
+FULL_TEXT_TTS_ENDPOINT=https://YOUR-MODAL-ENDPOINT.modal.run/generate_full_text_audio
+FULL_TEXT_JSON_ENDPOINT=https://YOUR-MODAL-ENDPOINT.modal.run/generate_full_text_json
+"""
+    
+    if not Path(".env").exists():
+        with open(".env", "w") as f:
+            f.write(env_content)
+        print("Created sample .env file - please update with your actual endpoints")
+
+
+if __name__ == "__main__":
+    # Create sample .env if it doesn't exist
+    create_sample_env_file()
+    main()

api/text_processing.py

@@ -0,0 +1,174 @@
+"""Text processing utilities for the TTS API."""
+
+import re
+from typing import List
+
+
+class TextChunker:
+    """Server-side text chunking for optimal GPU processing."""
+    
+    def __init__(self, max_chunk_size: int = 800, overlap_sentences: int = 0):
+        """
+        Initialize the text chunker.
+        
+        Args:
+            max_chunk_size: Maximum number of characters per chunk
+            overlap_sentences: Number of sentences to overlap between chunks for continuity
+        """
+        self.max_chunk_size = max_chunk_size
+        self.overlap_sentences = overlap_sentences
+    
+    def chunk_text(self, text: str) -> List[str]:
+        """
+        Break text into smaller chunks based on paragraphs and sentence boundaries.
+        
+        Args:
+            text: The input text to chunk
+            
+        Returns:
+            List of text chunks
+        """
+        if not text or not text.strip():
+            return []
+        
+        # Clean the text
+        text = text.strip()
+        
+        # If text is within the limit, return as single chunk
+        if len(text) <= self.max_chunk_size:
+            return [text]
+        
+        chunks = []
+        
+        # First, try to split by paragraphs
+        paragraphs = self._split_into_paragraphs(text)
+        
+        current_chunk = ""
+        
+        for paragraph in paragraphs:
+            # If adding this paragraph would exceed the limit
+            if len(current_chunk) + len(paragraph) + 1 > self.max_chunk_size:
+                # If we have content in current chunk, save it
+                if current_chunk.strip():
+                    chunks.append(current_chunk.strip())
+                    current_chunk = ""
+                
+                # If the paragraph itself is too long, split it by sentences
+                if len(paragraph) > self.max_chunk_size:
+                    sentence_chunks = self._split_paragraph_into_sentences(paragraph)
+                    for sentence_chunk in sentence_chunks:
+                        if len(current_chunk) + len(sentence_chunk) + 1 > self.max_chunk_size:
+                            if current_chunk.strip():
+                                chunks.append(current_chunk.strip())
+                            current_chunk = sentence_chunk
+                        else:
+                            if current_chunk:
+                                current_chunk += " " + sentence_chunk
+                            else:
+                                current_chunk = sentence_chunk
+                else:
+                    current_chunk = paragraph
+            else:
+                # Add paragraph to current chunk
+                if current_chunk:
+                    current_chunk += "\n\n" + paragraph
+                else:
+                    current_chunk = paragraph
+        
+        # Add any remaining content
+        if current_chunk.strip():
+            chunks.append(current_chunk.strip())
+        
+        # Apply overlap if specified
+        if self.overlap_sentences > 0 and len(chunks) > 1:
+            chunks = self._add_overlap(chunks)
+        
+        return chunks
+    
+    def _split_into_paragraphs(self, text: str) -> List[str]:
+        """Split text into paragraphs."""
+        # Split by double newlines or multiple spaces
+        paragraphs = re.split(r'\n\s*\n|(?:\n\s*){2,}', text)
+        # Filter out empty paragraphs and strip whitespace
+        return [p.strip() for p in paragraphs if p.strip()]
+    
+    def _split_paragraph_into_sentences(self, paragraph: str) -> List[str]:
+        """Split a long paragraph into sentence-based chunks."""
+        # Split by sentence boundaries
+        sentences = re.split(r'(?<=[.!?])\s+', paragraph)
+        
+        chunks = []
+        current_chunk = ""
+        
+        for sentence in sentences:
+            # If a single sentence is longer than max_chunk_size, we need to force-split it
+            if len(sentence) > self.max_chunk_size:
+                # Save current chunk if it has content
+                if current_chunk.strip():
+                    chunks.append(current_chunk.strip())
+                    current_chunk = ""
+                
+                # Force-split the long sentence into smaller pieces
+                while len(sentence) > self.max_chunk_size:
+                    # Find a good breaking point (prefer spaces)
+                    break_point = self.max_chunk_size
+                    if ' ' in sentence[:self.max_chunk_size]:
+                        # Find the last space within the limit
+                        break_point = sentence[:self.max_chunk_size].rfind(' ')
+                    
+                    chunk_part = sentence[:break_point]
+                    chunks.append(chunk_part)
+                    sentence = sentence[break_point:].strip()
+                
+                # Add the remaining part of the sentence
+                if sentence:
+                    current_chunk = sentence
+                    
+            elif len(current_chunk) + len(sentence) + 1 > self.max_chunk_size:
+                if current_chunk.strip():
+                    chunks.append(current_chunk.strip())
+                current_chunk = sentence
+            else:
+                if current_chunk:
+                    current_chunk += " " + sentence
+                else:
+                    current_chunk = sentence
+        
+        if current_chunk.strip():
+            chunks.append(current_chunk.strip())
+        
+        return chunks
+    
+    def _add_overlap(self, chunks: List[str]) -> List[str]:
+        """Add sentence overlap between chunks for better continuity."""
+        if len(chunks) <= 1:
+            return chunks
+        
+        overlapped_chunks = [chunks[0]]  # First chunk stays the same
+        
+        for i in range(1, len(chunks)):
+            # Get last few sentences from previous chunk
+            prev_chunk = chunks[i - 1]
+            current_chunk = chunks[i]
+            
+            prev_sentences = re.split(r'(?<=[.!?])\s+', prev_chunk)
+            overlap_text = " ".join(prev_sentences[-self.overlap_sentences:]) if len(prev_sentences) > self.overlap_sentences else ""
+            
+            if overlap_text:
+                overlapped_chunk = overlap_text + " " + current_chunk
+            else:
+                overlapped_chunk = current_chunk
+            
+            overlapped_chunks.append(overlapped_chunk)
+        
+        return overlapped_chunks
+    
+    def get_chunk_info(self, chunks: List[str]) -> dict:
+        """Get information about the chunks."""
+        return {
+            "total_chunks": len(chunks),
+            "total_characters": sum(len(chunk) for chunk in chunks),
+            "avg_chunk_size": sum(len(chunk) for chunk in chunks) / len(chunks) if chunks else 0,
+            "max_chunk_size": max(len(chunk) for chunk in chunks) if chunks else 0,
+            "min_chunk_size": min(len(chunk) for chunk in chunks) if chunks else 0
+        }

api/tts_service.py

@@ -12,11 +12,14 @@ from fastapi.responses import StreamingResponse, Response
 from fastapi import HTTPException, File, UploadFile, Form
 
 from .config import app, image
-from .models import TTSRequest, TTSResponse, HealthResponse
+from .models import TTSRequest, TTSResponse, HealthResponse, FullTextTTSRequest, FullTextTTSResponse
 from .audio_utils import AudioUtils
+from .text_processing import TextChunker
+from .audio_concatenator import AudioConcatenator
 
 with image.imports():
     from chatterbox.tts import ChatterboxTTS
+    import torch # Add torch import here
     # Suppress specific transformers deprecation warnings
     warnings.filterwarnings("ignore", message=".*past_key_values.*", category=FutureWarning)
 
@@ -276,3 +279,153 @@ class ChatterboxTTSService:
         except Exception as e:
             print(f"Error generating audio: {str(e)}")
             raise HTTPException(status_code=500, detail=f"Audio generation failed: {str(e)}")
+
+    @modal.fastapi_endpoint(docs=True, method="POST")
+    def generate_full_text_audio(self, request: FullTextTTSRequest) -> StreamingResponse:
+        """
+        Generate speech audio from full text with server-side chunking and parallel processing.
+        
+        This endpoint handles texts of any length by:
+        1. Chunking the text intelligently (respecting sentence/paragraph boundaries)
+        2. Processing chunks in parallel using GPU resources
+        3. Concatenating audio chunks with proper transitions
+        4. Returning the final audio file
+        
+        Args:
+            request: FullTextTTSRequest containing text and processing parameters
+            
+        Returns:
+            StreamingResponse with final concatenated audio as WAV file
+        """
+        try:
+            self._validate_text_input(request.text)
+            audio_prompt_path = self._process_voice_prompt(request.voice_prompt_base64)
+            
+            print(f"Processing full text ({len(request.text)} chars) with server-side chunking...")
+            
+            # Initialize text chunker with request parameters
+            chunker = TextChunker(
+                max_chunk_size=request.max_chunk_size,
+                overlap_sentences=request.overlap_sentences
+            )
+            
+            # Chunk the text
+            text_chunks = chunker.chunk_text(request.text)
+            chunk_info = chunker.get_chunk_info(text_chunks)
+            print(f"Split text into {len(text_chunks)} chunks for processing")
+            
+            # Initialize audio_chunks variable for processing info
+            audio_chunks = []
+              # If only one chunk, process directly
+            if len(text_chunks) == 1:
+                wav = self._generate_audio(text_chunks[0], audio_prompt_path)
+                # For single chunk, pass the full wav object to maintain consistency
+                final_audio = wav
+                audio_chunks = [wav]  # For consistent processing info
+            else:
+                # Process chunks in parallel
+                import concurrent.futures
+                import numpy as np
+                
+                def process_chunk(chunk_text: str):
+                    """Process a single chunk."""
+                    wav_result = self._generate_audio(chunk_text, audio_prompt_path)
+                    # Return the full wav result, not just wav[0]
+                    return wav_result
+                
+                # Use ThreadPoolExecutor for parallel processing
+                with concurrent.futures.ThreadPoolExecutor(max_workers=4) as executor:
+                    # Submit all chunks for processing
+                    future_to_chunk = {
+                        executor.submit(process_chunk, chunk): i 
+                        for i, chunk in enumerate(text_chunks)
+                    }
+                    
+                    # Collect results in order
+                    results = [None] * len(text_chunks)
+                    for future in concurrent.futures.as_completed(future_to_chunk):
+                        chunk_index = future_to_chunk[future]
+                        try:
+                            audio_result = future.result()
+                            results[chunk_index] = audio_result
+                        except Exception as exc:
+                            print(f'Chunk {chunk_index} generated an exception: {exc}')
+                            raise HTTPException(status_code=500, detail=f"Failed to process chunk {chunk_index}: {str(exc)}")
+                
+                # Filter out None results
+                audio_chunks = [result for result in results if result is not None]
+                
+                if len(audio_chunks) != len(text_chunks):
+                    raise HTTPException(status_code=500, detail=f"Only {len(audio_chunks)} out of {len(text_chunks)} chunks processed successfully")
+                
+                # Concatenate audio chunks
+                print("Concatenating audio chunks...")
+                concatenator = AudioConcatenator(
+                    silence_duration=request.silence_duration,
+                    fade_duration=request.fade_duration
+                )
+                
+                final_audio = concatenator.concatenate_audio_chunks(audio_chunks, self.model.sr)
+            
+            # --- Start of new audio processing logic ---
+            import torch
+            import numpy as np
+
+            processed_tensor = final_audio
+            # Unwrap if it's a single-element tuple repeatedly
+            while isinstance(processed_tensor, tuple) and len(processed_tensor) == 1:
+                processed_tensor = processed_tensor[0]
+
+            # Convert to PyTorch tensor if it's a NumPy array
+            if isinstance(processed_tensor, np.ndarray):
+                processed_tensor = torch.from_numpy(processed_tensor.astype(np.float32))
+
+            if not isinstance(processed_tensor, torch.Tensor): # Check if it's a tensor now
+                raise TypeError(f"Audio data after concatenation is not a tensor. Got type: {type(processed_tensor)}")
+
+            # Ensure correct shape (C, L) for torchaudio.save
+            if processed_tensor.ndim == 1:  # Shape (L,)
+                audio_to_save = processed_tensor.unsqueeze(0)  # Convert to (1, L)
+            elif processed_tensor.ndim == 2: # Shape (C, L)
+                if processed_tensor.shape[0] == 0:
+                    raise ValueError(f"Audio tensor has 0 channels: {processed_tensor.shape}")
+                if processed_tensor.shape[0] > 1: # If C > 1 (stereo/multi-channel)
+                    print(f"Multi-channel audio (shape {processed_tensor.shape}) detected. Taking the first channel.")
+                    audio_to_save = processed_tensor[0, :].unsqueeze(0) # Result is (1, L)
+                else: # Already (1, L)
+                    audio_to_save = processed_tensor
+            else:
+                raise ValueError(f"Unexpected audio tensor dimensions: {processed_tensor.ndim}, shape: {processed_tensor.shape}")
+            buffer = AudioUtils.save_audio_to_buffer(audio_to_save, self.model.sr)
+            duration = audio_to_save.shape[1] / self.model.sr # Use shape[1] for length
+            
+            # Reset buffer position for reading
+            buffer.seek(0)
+            # --- End of new audio processing logic ---            # Prepare processing info
+            processing_info = {
+                "total_chunks": len(text_chunks),
+                "processed_chunks": len(audio_chunks),
+                "failed_chunks": len(text_chunks) - len(audio_chunks),
+                "sample_rate": self.model.sr,
+                "duration": duration
+            }
+
+            print(f"Full text processing complete! Final audio duration: {duration:.2f} seconds")
+            return StreamingResponse(
+                buffer,
+                media_type="audio/wav",
+                headers={
+                    "Content-Disposition": "attachment; filename=generated_full_text_speech.wav",
+                    "X-Audio-Duration": str(duration),
+                    "X-Chunks-Processed": str(len(audio_chunks)),
+                    "X-Total-Characters": str(len(request.text))
+                }
+            )
+
+        except HTTPException as http_exc:
+            print(f"HTTP exception in full text generation: {http_exc.detail}")
+            raise http_exc
+        except Exception as e:
+            error_msg = f"Full text audio generation failed: {str(e)}"
+            print(f"Exception in full text generation: {error_msg}")
+            raise HTTPException(status_code=500, detail=error_msg)