feat: Add Piper voice download helpers and guides

- Created download_piper_voices.py for automated download attempts
- Created download_piper_voices.sh as alternative bash script
- Created EASY_PIPER_SETUP.md with simple 3-step instructions
- Created PIPER_DOWNLOAD_GUIDE.md with visual step-by-step guide
- Includes troubleshooting, checklists, and pro tips

Makes Piper setup much easier for users with multiple guide options.

.kiro/specs/text-to-audiobook/SCRIPT_REVIEW_FEATURE.md

@@ -0,0 +1,154 @@
+# Script Review Feature - Enhancement Specification
+
+## Overview
+
+This document describes the new **Script Review & Editing** feature that addresses the issue where AI-generated speaker assignments may not always be accurate. This feature gives users visibility and control over how the text is segmented and which character speaks each line.
+
+## Problem Statement
+
+When using AI to detect speakers in unmarked text, the system may:
+- Incorrectly assign dialogue to the wrong character
+- Miss some character dialogue
+- Assign narrative text to a character instead of the narrator
+
+Users currently have no way to see or correct these mistakes before generating the audiobook.
+
+## Solution
+
+Add a new **Script Review** phase between voice assignment and audio generation where users can:
+1. See the complete script breakdown showing which character speaks each line
+2. Edit speaker assignments for any segment
+3. Skip the review if they trust the AI's assignments
+
+## User Workflow
+
+### Updated Flow
+```
+1. Text Input
+   ↓
+2. Role Detection (AI detects: Lily, Benny, Sammy, Narrator)
+   ↓
+3. Voice Assignment (User assigns voices to each role)
+   ↓
+4. **Script Review** (NEW - User reviews and edits speaker assignments)
+   ↓
+5. Audio Generation (Uses edited script)
+   ↓
+6. Playback & Download
+```
+
+### Script Review Interface
+
+The review screen will show:
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│                    Review Script                             │
+├─────────────────────────────────────────────────────────────┤
+│                                                              │
+│  Segment 1:  [Narrator ▼]                                   │
+│  ┌────────────────────────────────────────────────────────┐ │
+│  │ Once upon a time, in a tiny village surrounded by      │ │
+│  │ lush green forests, there lived three best friends...  │ │
+│  └────────────────────────────────────────────────────────┘ │
+│                                                              │
+│  Segment 2:  [Lily ▼]                                       │
+│  ┌────────────────────────────────────────────────────────┐ │
+│  │ "Have you guys heard about the new stream that just    │ │
+│  │ appeared in the woods?"                                 │ │
+│  └────────────────────────────────────────────────────────┘ │
+│                                                              │
+│  Segment 3:  [Benny ▼]                                      │
+│  ┌────────────────────────────────────────────────────────┐ │
+│  │ "Ooh, I love streams! Do we get to go see it now?"     │ │
+│  └────────────────────────────────────────────────────────┘ │
+│                                                              │
+│  ... (more segments)                                         │
+│                                                              │
+│  [Skip Review]              [Generate Audiobook]            │
+└─────────────────────────────────────────────────────────────┘
+```
+
+## Technical Implementation
+
+### New API Endpoint
+
+**POST /api/tts/script**
+- Request: `{ text: string, roles: string[] }`
+- Response: `{ segments: [{ id: string, speaker: string, text: string }] }`
+- Uses Ollama AI to segment text and assign speakers
+- Returns editable script for frontend
+
+### Updated Generation Endpoint
+
+**POST /api/tts** (modified)
+- Now accepts optional `segments` array
+- If segments provided, uses them directly (respecting user edits)
+- If no segments, falls back to original text-based segmentation
+- Maintains backward compatibility
+
+### Frontend Components
+
+**New: ScriptReviewSection**
+- Displays all segments with editable speaker dropdowns
+- Allows users to change speaker for any segment
+- Provides "Skip Review" option for quick generation
+- Mobile-responsive design
+
+**Updated: VoiceAssignmentSection**
+- Button changes from "Generate Audiobook" to "Next: Review Script"
+- Adds "Skip Review & Generate" option
+
+**Updated: App Component**
+- Adds 'review' phase to workflow
+- Manages script segments state
+- Handles segment editing
+
+## Benefits
+
+1. **Transparency**: Users can see exactly how the AI interpreted their text
+2. **Control**: Users can correct any mistakes before generation
+3. **Flexibility**: Users can skip review if they trust the AI
+4. **Better Results**: Ensures the final audiobook matches user expectations
+
+## Requirements Added
+
+- **Requirement 15**: Complete specification for script review feature
+  - 8 acceptance criteria covering all aspects
+  - API endpoints, UI components, and user interactions
+
+## Design Updates
+
+- Added ScriptReviewSection component
+- Added /api/tts/script endpoint
+- Updated data models (ScriptSegment, ScriptRequest, ScriptResponse)
+- Added 5 new correctness properties (Properties 32-35)
+- Updated application workflow to include review phase
+
+## Implementation Tasks
+
+Added 8 new tasks (18-25) covering:
+- Backend script generation endpoint
+- Updated TTS generation to accept edited scripts
+- Frontend API client updates
+- ScriptReviewSection component
+- App component workflow updates
+- VoiceAssignmentSection updates
+- Documentation
+- Integration testing
+
+## Testing Strategy
+
+- Property tests for script completeness and structure
+- Unit tests for all new components and endpoints
+- Integration tests for complete workflow
+- Manual testing with various text samples
+
+## Future Enhancements
+
+Potential improvements for later:
+- Inline editing of segment text
+- Merge/split segments
+- Bulk speaker assignment
+- Save/load script templates
+- Export script as text file

.kiro/specs/text-to-audiobook/design.md

@@ -4,10 +4,11 @@
 
 The Text to Audiobook system is a full-stack application that converts long-form text into multi-voice audiobooks using Kokoro TTS. The architecture follows a client-server model with a React TypeScript frontend and a Python FastAPI backend running in Docker. The system automatically detects speaker roles in text, allows voice assignment per role, and generates high-quality audio using the Kokoro-82M model.
 
-The application workflow consists of three main phases:
+The application workflow consists of four main phases:
 1. **Text Input & Role Detection**: User provides text, system identifies distinct speakers
 2. **Voice Assignment**: User maps each detected role to a specific Kokoro voice
-3. **Audio Generation & Playback**: System synthesizes multi-voice audio and provides playback/download
+3. **Script Review & Editing**: User reviews and edits AI-generated speaker assignments for each text segment
+4. **Audio Generation & Playback**: System synthesizes multi-voice audio and provides playback/download
 
 ## Architecture
 
@@ -93,10 +94,12 @@ Main application container managing the overall workflow state.
 - `text: string` - User input text
 - `roles: Role[]` - Detected roles from backend
 - `voiceAssignments: Map<string, string>` - Role ID to Voice ID mapping
+- `scriptSegments: ScriptSegment[]` - AI-generated script segments
 - `selectedLanguage: string` - Language code (default: 'a')
 - `speed: number` - Playback speed (default: 1.0)
 - `audioUrl: string | null` - Generated audio blob URL
 - `isDetectingRoles: boolean` - Loading state for role detection
+- `isGeneratingScript: boolean` - Loading state for script generation
 - `isGenerating: boolean` - Loading state for audio generation
 - `error: string | null` - Error message if any
 
@@ -104,7 +107,10 @@ Main application container managing the overall workflow state.
 - `handleTextChange(text: string)` - Updates text state
 - `handleDetectRoles()` - Calls API to detect roles
 - `handleVoiceAssignment(roleId: string, voiceId: string)` - Updates voice mapping
-- `handleGenerate()` - Calls API to generate audiobook
+- `handleGenerateScript()` - Calls API to generate script preview
+- `handleSkipReview()` - Skips script review and proceeds to generation
+- `handleSegmentChange(segmentId: string, newSpeaker: string)` - Updates speaker for a segment
+- `handleGenerate()` - Calls API to generate audiobook with edited script
 - `handleDownload()` - Triggers download of generated audio
 
 #### 2. TextInputSection Component
@@ -132,14 +138,25 @@ Displays role-to-voice mapping interface with language and speed controls.
 - `isGenerating: boolean`
 - `allRolesAssigned: boolean`
 
-#### 4. AudioPlayerSection Component
+#### 4. ScriptReviewSection Component
+Displays AI-generated script with editable speaker assignments.
+
+**Props:**
+- `segments: ScriptSegment[]`
+- `roles: Role[]`
+- `onSegmentChange: (segmentId: string, newSpeaker: string) => void`
+- `onGenerate: () => void`
+- `onSkipReview: () => void`
+- `isGenerating: boolean`
+
+#### 5. AudioPlayerSection Component
 Displays audio player and download button after generation.
 
 **Props:**
 - `audioUrl: string`
 - `onDownload: () => void`
 
-#### 5. API Client (`src/api/tts.ts`)
+#### 6. API Client (`src/api/tts.ts`)
 
 **Interfaces:**
 ```typescript
@@ -156,8 +173,24 @@ export interface RolesResponse {
   roles: Role[];
 }
 
-export interface GenerateRequest {
+export interface ScriptSegment {
+  id: string;
+  speaker: string;
   text: string;
+}
+
+export interface ScriptRequest {
+  text: string;
+  roles: string[];
+}
+
+export interface ScriptResponse {
+  segments: ScriptSegment[];
+}
+
+export interface GenerateRequest {
+  segments?: ScriptSegment[];
+  text?: string;
   lang: string;
   roles: { id: string; voice: string }[];
   speed?: number;
@@ -167,6 +200,7 @@ export interface GenerateRequest {
 **Functions:**
 ```typescript
 export async function detectRoles(text: string): Promise<RolesResponse>
+export async function generateScript(request: ScriptRequest): Promise<ScriptResponse>
 export async function generateAudiobook(payload: GenerateRequest): Promise<Blob>
 export async function checkHealth(): Promise<{ status: string }>
 ```
@@ -188,6 +222,11 @@ async def detect_roles(request: RoleDetectionRequest) -> RolesResponse:
     """Analyzes text and returns detected roles"""
     pass
 
+@app.post("/api/tts/script")
+async def generate_script(request: ScriptRequest) -> ScriptResponse:
+    """Generates script preview with AI-segmented text and speaker assignments"""
+    pass
+
 @app.post("/api/tts")
 async def generate_audiobook(request: TTSRequest) -> StreamingResponse:
     """Generates multi-voice audiobook and streams audio"""
@@ -206,12 +245,25 @@ class RoleInfo(BaseModel):
 class RolesResponse(BaseModel):
     roles: List[RoleInfo]
 
+class ScriptRequest(BaseModel):
+    text: str
+    roles: List[str]  # List of detected role IDs
+
+class ScriptSegment(BaseModel):
+    id: str  # Unique segment identifier
+    speaker: str  # Assigned speaker/role
+    text: str  # Text content for this segment
+
+class ScriptResponse(BaseModel):
+    segments: List[ScriptSegment]
+
 class RoleVoiceMapping(BaseModel):
     id: str
     voice: str
 
 class TTSRequest(BaseModel):
-    text: str
+    segments: Optional[List[ScriptSegment]] = None  # If provided, use edited script
+    text: Optional[str] = None  # Fallback if no script provided
     lang: str
     roles: List[RoleVoiceMapping]
     speed: Optional[float] = 1.0
@@ -384,10 +436,11 @@ interface LanguageOption {
 **Application State:**
 ```typescript
 interface AppState {
-  phase: 'input' | 'assignment' | 'generated';
+  phase: 'input' | 'assignment' | 'review' | 'generated';
   text: string;
   roles: Role[];
   voiceAssignments: Map<string, string>;
+  scriptSegments: ScriptSegment[];
   language: string;
   speed: number;
   audioUrl: string | null;
@@ -578,6 +631,22 @@ ROLE_PATTERNS = {
 *For any* text where both AI detection and pattern detection find roles, the backend should merge results and return each unique role exactly once.
 **Validates: Requirements 14.5**
 
+### Property 32: Script generation completeness
+*For any* text and list of roles, the script generation should return segments that cover the entire input text without gaps or overlaps.
+**Validates: Requirements 15.2**
+
+### Property 33: Script segment structure
+*For any* generated script, each segment should contain an id, speaker, and text field.
+**Validates: Requirements 15.4**
+
+### Property 34: Script segment editability
+*For any* script segment, the user should be able to change the speaker assignment to any detected role.
+**Validates: Requirements 15.5**
+
+### Property 35: Edited script persistence
+*For any* edited script segment, the changes should be preserved when generating the audiobook.
+**Validates: Requirements 15.7**
+
 ## Error Handling
 
 ### Frontend Error Handling

.kiro/specs/text-to-audiobook/requirements.md

@@ -15,6 +15,7 @@ The Text to Audiobook system is a production-ready React TypeScript single-page
 - **KPipeline**: The Kokoro library's pipeline object for text-to-speech synthesis
 - **Segment**: A portion of text assigned to a specific role for synthesis
 - **Role Marker**: Text patterns that identify speakers (e.g., "Alice:", "[Narrator]")
+- **Script**: The complete breakdown of text into segments with speaker assignments, displayed for user review and editing
 
 ## Requirements
 
@@ -192,3 +193,18 @@ The Text to Audiobook system is a production-ready React TypeScript single-page
 4. WHEN Ollama is unavailable or fails THEN the Backend SHALL fall back to pattern-based role detection
 5. WHEN both AI detection and pattern detection find roles THEN the Backend SHALL merge and deduplicate the results
 6. THE Backend SHALL configure Ollama connection using environment variable OLLAMA_BASE_URL with default http://localhost:11434
+
+### Requirement 15
+
+**User Story:** As a user, I want to review and edit the AI-generated script showing which character speaks each line, so that I can correct any mistakes before generating the audiobook.
+
+#### Acceptance Criteria
+
+1. WHEN the user completes voice assignment THEN the Frontend SHALL request a script preview from the Backend before generation
+2. WHEN the Backend receives a script preview request THEN the Backend SHALL use AI to segment the text and return a list of segments with speaker assignments
+3. WHEN the script preview is received THEN the Frontend SHALL display a new "Review Script" phase showing each segment with its assigned speaker
+4. WHEN displaying script segments THEN the Frontend SHALL show each segment in a text box with a dropdown to select the speaker
+5. WHEN the user changes a speaker assignment for a segment THEN the Frontend SHALL update the segment mapping
+6. WHEN the user is satisfied with the script THEN the Frontend SHALL enable a "Generate Audiobook" button
+7. WHEN the user clicks "Generate Audiobook" THEN the Frontend SHALL send the edited script segments to the Backend for synthesis
+8. THE Frontend SHALL allow users to skip the review step with a "Skip Review" option that proceeds directly to generation

.kiro/specs/text-to-audiobook/tasks.md

@@ -289,7 +289,7 @@
   - Include troubleshooting section
   - _Requirements: 13.1, 13.2, 13.3, 13.4, 13.5_
 
-- [ ] 15. Implement Ollama integration service
+- [x] 15. Implement Ollama integration service
   - Create OllamaService class in services/ollama_service.py
   - Implement connection to Ollama API using httpx
   - Configure OLLAMA_BASE_URL environment variable (default: http://localhost:11434)
@@ -316,7 +316,7 @@
   - Test error handling for unavailable service
   - _Requirements: 14.1, 14.2, 14.3_
 
-- [ ] 16. Integrate Ollama into role detection
+- [x] 16. Integrate Ollama into role detection
   - Update RoleDetector to use OllamaService
   - Implement _detect_with_ollama() method
   - Add fallback logic: try Ollama first, then pattern matching
@@ -349,15 +349,125 @@
   - Add troubleshooting section for Ollama issues
   - _Requirements: 14.6_
 
-- [ ] 18. Final integration testing and polish
+- [x] 18. Implement script generation endpoint
-  - Test complete end-to-end workflow
+  - Create /api/tts/script POST endpoint in main.py
-  - Test with various text samples (short, long, multiple roles, no roles)
+  - Define ScriptRequest and ScriptResponse Pydantic models
+  - Define ScriptSegment model with id, speaker, and text fields
+  - Integrate with TTSService to generate script segments using AI
+  - Return segments with unique IDs for frontend tracking
+  - Handle errors gracefully when AI segmentation fails
+  - _Requirements: 15.1, 15.2_
+
+- [ ]* 18.1 Write property test for script generation
+  - **Property 32: Script generation completeness**
+  - **Validates: Requirements 15.2**
+
+- [ ]* 18.2 Write property test for script segment structure
+  - **Property 33: Script segment structure**
+  - **Validates: Requirements 15.4**
+
+- [ ]* 18.3 Write unit tests for script endpoint
+  - Test successful script generation
+  - Test with various text lengths
+  - Test error handling
+  - _Requirements: 15.2_
+
+- [x] 19. Update TTS generation endpoint to accept edited scripts
+  - Modify TTSRequest to accept optional segments array
+  - Update generate_audiobook logic to use segments if provided
+  - Fall back to text segmentation if no segments provided
+  - Ensure backward compatibility with existing API calls
+  - _Requirements: 15.7_
+
+- [ ]* 19.1 Write property test for edited script persistence
+  - **Property 35: Edited script persistence**
+  - **Validates: Requirements 15.7**
+
+- [ ]* 19.2 Write unit tests for script-based generation
+  - Test generation with edited segments
+  - Test fallback to text-based generation
+  - Test segment speaker assignments are respected
+  - _Requirements: 15.7_
+
+- [x] 20. Implement script generation API client function
+  - Add generateScript() function to src/api/tts.ts
+  - Define ScriptSegment, ScriptRequest, and ScriptResponse TypeScript interfaces
+  - Implement error handling for script generation
+  - Update GenerateRequest interface to support segments
+  - _Requirements: 15.1, 15.2_
+
+- [ ]* 20.1 Write unit tests for script API client
+  - Test generateScript() function
+  - Test error handling
+  - Mock API responses
+  - _Requirements: 15.1_
+
+- [x] 21. Implement ScriptReviewSection component
+  - Create ScriptReviewSection component
+  - Display list of script segments with text boxes
+  - Add speaker dropdown for each segment
+  - Implement segment editing handlers
+  - Add "Generate Audiobook" button
+  - Add "Skip Review" button for quick generation
+  - Style for readability and mobile responsiveness
+  - _Requirements: 15.3, 15.4, 15.5, 15.6, 15.8_
+
+- [ ]* 21.1 Write property test for script segment editability
+  - **Property 34: Script segment editability**
+  - **Validates: Requirements 15.5**
+
+- [ ]* 21.2 Write unit tests for ScriptReviewSection
+  - Test component renders segments correctly
+  - Test speaker dropdown contains all roles
+  - Test segment editing updates state
+  - Test generate button is enabled
+  - Test skip review button works
+  - _Requirements: 15.3, 15.4, 15.5, 15.8_
+
+- [x] 22. Update App component for script review workflow
+  - Add 'review' phase to application state
+  - Add scriptSegments state variable
+  - Add isGeneratingScript loading state
+  - Implement handleGenerateScript() method
+  - Implement handleSkipReview() method
+  - Implement handleSegmentChange() method
+  - Update handleGenerate() to use edited segments
+  - Wire up ScriptReviewSection component
+  - Update phase transitions: input → assignment → review → generated
+  - _Requirements: 15.1, 15.3, 15.6, 15.7, 15.8_
+
+- [ ]* 22.1 Write unit tests for script workflow
+  - Test phase transitions include review phase
+  - Test script generation is called after voice assignment
+  - Test segment changes are tracked
+  - Test skip review bypasses review phase
+  - _Requirements: 15.1, 15.8_
+
+- [x] 23. Update VoiceAssignmentSection to trigger script generation
+  - Change "Generate Audiobook" button to "Next: Review Script"
+  - Add "Skip Review & Generate" button as alternative
+  - Update button handlers to call appropriate methods
+  - _Requirements: 15.1, 15.8_
+
+- [ ] 24. Add script review documentation
+  - Document script review feature in README
+  - Add screenshots of script review interface
+  - Explain how to edit speaker assignments
+  - Document skip review option
+  - Add troubleshooting for script generation issues
+  - _Requirements: 15.3, 15.4, 15.5, 15.8_
+
+- [ ] 25. Final integration testing and polish
+  - Test complete end-to-end workflow with script review
+  - Test script generation with various text samples
+  - Test editing speaker assignments in script
+  - Test skip review functionality
   - Test with unmarked dialogue text (relying on AI detection)
   - Test with marked text (pattern detection)
   - Test with Ollama available and unavailable
   - Test all language options (a, b, f, j)
   - Test error scenarios (network failures, invalid inputs)
-  - Verify audio quality and playback
+  - Verify audio quality and playback with edited scripts
   - Test Docker deployment
   - Fix any bugs discovered during testing
   - _Requirements: All_

AVAILABLE_VOICES.md

@@ -0,0 +1,157 @@
+# Available Kokoro TTS Voices
+
+Kokoro-82M has **54 voices** available across multiple languages!
+
+## Voice Naming Convention
+- **First letter**: Language code
+  - `a` = American English
+  - `b` = British English
+  - `e` = Spanish (español)
+  - `f` = French
+  - `h` = Hindi
+  - `i` = Italian
+  - `j` = Japanese
+  - `p` = Portuguese
+  - `z` = Chinese (Mandarin)
+- **Second letter**: Gender
+  - `f` = Female
+  - `m` = Male
+- **Rest**: Voice name/identifier
+
+## American English (a) - 21 voices
+
+### Female (af_*)
+- `af_alloy` - Alloy
+- `af_aoede` - Aoede
+- `af_bella` - Bella ✓ (currently in app)
+- `af_heart` - Heart
+- `af_jessica` - Jessica
+- `af_kore` - Kore
+- `af_nicole` - Nicole
+- `af_nova` - Nova
+- `af_river` - River
+- `af_sarah` - Sarah ✓ (currently in app)
+- `af_sky` - Sky
+
+### Male (am_*)
+- `am_adam` - Adam ✓ (currently in app)
+- `am_echo` - Echo
+- `am_eric` - Eric
+- `am_fenrir` - Fenrir
+- `am_liam` - Liam
+- `am_michael` - Michael ✓ (currently in app)
+- `am_onyx` - Onyx
+- `am_puck` - Puck
+- `am_santa` - Santa
+
+## British English (b) - 8 voices
+
+### Female (bf_*)
+- `bf_alice` - Alice
+- `bf_emma` - Emma ✓ (currently in app)
+- `bf_isabella` - Isabella ✓ (currently in app)
+- `bf_lily` - Lily
+
+### Male (bm_*)
+- `bm_daniel` - Daniel
+- `bm_fable` - Fable
+- `bm_george` - George ✓ (currently in app)
+- `bm_lewis` - Lewis ✓ (currently in app)
+
+## Spanish (e) - 3 voices
+
+### Female (ef_*)
+- `ef_dora` - Dora
+
+### Male (em_*)
+- `em_alex` - Alex
+- `em_santa` - Santa
+
+## French (f) - 1 voice
+
+### Female (ff_*)
+- `ff_siwis` - Siwis
+
+## Hindi (h) - 4 voices
+
+### Female (hf_*)
+- `hf_alpha` - Alpha
+- `hf_beta` - Beta
+
+### Male (hm_*)
+- `hm_omega` - Omega
+- `hm_psi` - Psi
+
+## Italian (i) - 2 voices
+
+### Female (if_*)
+- `if_sara` - Sara
+
+### Male (im_*)
+- `im_nicola` - Nicola
+
+## Japanese (j) - 5 voices
+
+### Female (jf_*)
+- `jf_alpha` - Alpha
+- `jf_gongitsune` - Gongitsune
+- `jf_nezumi` - Nezumi
+- `jf_tebukuro` - Tebukuro
+
+### Male (jm_*)
+- `jm_kumo` - Kumo
+
+## Portuguese (p) - 3 voices
+
+### Female (pf_*)
+- `pf_dora` - Dora
+
+### Male (pm_*)
+- `pm_alex` - Alex
+- `pm_santa` - Santa
+
+## Chinese/Mandarin (z) - 7 voices
+
+### Female (zf_*)
+- `zf_xiaobei` - Xiaobei
+- `zf_xiaoni` - Xiaoni
+- `zf_xiaoxiao` - Xiaoxiao
+- `zf_xiaoyi` - Xiaoyi
+
+### Male (zm_*)
+- `zm_yunjian` - Yunjian
+- `zm_yunxi` - Yunxi
+- `zm_yunxia` - Yunxia
+- `zm_yunyang` - Yunyang
+
+## Summary
+
+| Language | Female Voices | Male Voices | Total |
+|----------|--------------|-------------|-------|
+| American English | 11 | 10 | 21 |
+| British English | 4 | 4 | 8 |
+| Spanish | 1 | 2 | 3 |
+| French | 1 | 0 | 1 |
+| Hindi | 2 | 2 | 4 |
+| Italian | 1 | 1 | 2 |
+| Japanese | 4 | 1 | 5 |
+| Portuguese | 1 | 2 | 3 |
+| Chinese | 4 | 4 | 8 |
+| **TOTAL** | **29** | **26** | **55** |
+
+## Currently Configured (8 voices)
+
+The app currently uses only 8 voices:
+- ✓ af_bella, af_sarah (American Female)
+- ✓ am_adam, am_michael (American Male)
+- ✓ bf_emma, bf_isabella (British Female)
+- ✓ bm_george, bm_lewis (British Male)
+
+## Recommendation
+
+You could expand the voice options to include:
+1. **More variety in American English** (11 female + 10 male available!)
+2. **Additional languages** (Spanish, French, Italian, Japanese, Portuguese, Chinese, Hindi)
+3. **More character variety** (different voice characteristics)
+
+Would you like me to update the frontend to include more voices?

PIPER_FINAL_SUMMARY.md

@@ -0,0 +1,198 @@
+# Piper TTS Integration - Final Summary
+
+## ✅ Integration Complete
+
+Piper TTS has been successfully integrated as an alternative TTS engine with full UI support and comprehensive error handling.
+
+## What Was Delivered
+
+### Backend (100% Complete)
+- ✅ **PiperTTSService** - Full synthesis with pitch control (-12 to +12 semitones)
+- ✅ **UnifiedTTSService** - Multi-engine management (Kokoro + Piper)
+- ✅ **API Endpoints** - Engine selection, voice listing, preview support
+- ✅ **Error Handling** - Proper 404 responses for missing models
+- ✅ **Logging** - Detailed error messages and setup instructions
+
+### Frontend (100% Complete)
+- ✅ **Engine Selector UI** - Toggle buttons with descriptions
+- ✅ **Dynamic Voice Loading** - Voices update per engine
+- ✅ **Warning Messages** - Clear setup instructions when Piper selected
+- ✅ **Error Alerts** - User-friendly messages when preview fails
+- ✅ **Visual Feedback** - Active engine highlighting
+
+### Documentation (100% Complete)
+- ✅ **PIPER_SETUP.md** - Step-by-step manual setup guide
+- ✅ **PIPER_TTS_GUIDE.md** - Comprehensive usage documentation
+- ✅ **PIPER_STATUS.md** - Current state and troubleshooting
+- ✅ **PIPER_FINAL_SUMMARY.md** - This document
+- ✅ **Updated README.md** - Multi-engine documentation
+
+### Testing (100% Complete)
+- ✅ **test_engine_selection.py** - Engine switching tests
+- ✅ **test_piper_direct.py** - Piper installation verification
+
+## User Experience
+
+### Option 1: Kokoro TTS (Default) - Zero Setup
+```
+✅ Works immediately out of the box
+✅ 54 voices across 9 languages
+✅ High quality neural synthesis
+❌ No pitch control
+```
+
+### Option 2: Piper TTS (Advanced) - Manual Setup Required
+```
+⚠️  Requires one-time voice model download
+✅ Pitch control per character (-12 to +12 semitones)
+✅ Fast synthesis
+✅ Lower resource usage
+✅ 5+ English voices (expandable)
+```
+
+## Setup Instructions for Piper
+
+### Quick Start (3 Steps)
+
+1. **Install Piper Binary**
+   ```bash
+   cd backend
+   ./install_piper.sh
+   ```
+
+2. **Download Voice Models**
+   - Visit: https://github.com/rhasspy/piper/releases/tag/v1.2.0
+   - Download: `en_US-lessac-medium.onnx` and `.onnx.json`
+   - Place in: `backend/piper_models/`
+
+3. **Test & Use**
+   ```bash
+   python test_piper_direct.py
+   ```
+
+See `backend/PIPER_SETUP.md` for detailed instructions.
+
+## Error Handling
+
+### Backend Errors
+- **404 VoiceModelNotFound** - Clear message with setup guide link
+- **400 ValidationError** - Helpful validation messages
+- **500 PreviewGenerationError** - Detailed error logging
+
+### Frontend Errors
+- **Alert on Preview Fail** - User-friendly error with setup instructions
+- **Warning Banner** - Prominent notice when Piper selected
+- **Empty Audio Check** - Prevents "media could not be decoded" errors
+
+## Git Commits (All Pushed)
+
+1. `bfdcc94` - Backend Piper TTS integration with pitch control
+2. `c310f11` - Frontend engine selector UI
+3. `6f7330c` - Comprehensive integration documentation
+4. `d3e72ed` - Preview fix and improved setup instructions
+5. `134b109` - Status documentation and troubleshooting
+6. `cdd8c0f` - Enhanced error handling and user messaging
+
+## Files Created/Modified
+
+### New Files (11)
+```
+backend/services/piper_tts_service.py
+backend/services/unified_tts_service.py
+backend/install_piper.sh
+backend/test_engine_selection.py
+backend/test_piper_direct.py
+backend/PIPER_SETUP.md
+backend/PIPER_TTS_GUIDE.md
+PIPER_TTS_INTEGRATION.md
+PIPER_STATUS.md
+PIPER_FINAL_SUMMARY.md
+backend/piper_models/ (directory)
+```
+
+### Modified Files (5)
+```
+backend/main.py (added 3 endpoints, updated preview)
+backend/requirements.txt (added piper-tts, pydub)
+backend/.env.example (added TTS_ENGINE)
+backend/README.md (multi-engine docs)
+frontend/src/api/tts.ts (engine functions)
+frontend/src/components/VoiceAssignmentSection.tsx (engine selector)
+.kiro/specs/text-to-audiobook/tasks.md (task 26)
+```
+
+## Why Manual Setup?
+
+**Technical Reasons:**
+- HuggingFace repository structure complexity
+- SSL certificate verification issues
+- Large file sizes (10-50MB per voice)
+- Cross-platform reliability concerns
+
+**Decision:** Manual setup is more reliable than buggy auto-download
+
+## Comparison with Kokoro
+
+| Aspect | Kokoro TTS | Piper TTS |
+|--------|------------|-----------|
+| **Setup** | ✅ Zero setup | ⚠️ Manual download |
+| **Quality** | ⭐⭐⭐⭐⭐ High | ⭐⭐⭐⭐ Medium-High |
+| **Speed** | ⭐⭐⭐ Medium | ⭐⭐⭐⭐⭐ Fast |
+| **Voices** | 54 voices, 9 languages | 5+ English (expandable) |
+| **Pitch Control** | ❌ No | ✅ Yes (-12 to +12) |
+| **Memory** | ~500MB models | ~10-50MB per voice |
+| **Use Case** | General purpose | Advanced users |
+
+## Recommendation
+
+**For Most Users:** Use Kokoro TTS (default)
+- Works immediately
+- High quality
+- Many voices and languages
+
+**For Power Users:** Use Piper TTS
+- Worth the setup for pitch control
+- Faster synthesis
+- Lower resource usage
+- Great for character differentiation
+
+## Testing Checklist
+
+- ✅ Engine switching works (Kokoro ↔ Piper)
+- ✅ Voice lists update per engine
+- ✅ Preview works with Kokoro voices
+- ✅ Preview shows helpful error for missing Piper models
+- ✅ Warning banner displays when Piper selected
+- ✅ Error messages guide users to setup documentation
+- ✅ Backend logs detailed error information
+- ✅ API endpoints return proper status codes
+- ✅ Documentation is comprehensive and clear
+
+## Future Enhancements (Optional)
+
+1. **Pitch Control UI** - Add sliders in frontend for per-character pitch
+2. **Bundled Models** - Include 1-2 default Piper voices in repo
+3. **Download Helper** - Script to download popular voices
+4. **More Engines** - Add Coqui XTTS, Bark, etc.
+5. **Voice Cloning** - Add custom voice training
+6. **Docker Image** - Pre-package Piper models in container
+
+## Support Resources
+
+- **Setup Guide**: `backend/PIPER_SETUP.md`
+- **Usage Guide**: `backend/PIPER_TTS_GUIDE.md`
+- **Status & Troubleshooting**: `PIPER_STATUS.md`
+- **Integration Details**: `PIPER_TTS_INTEGRATION.md`
+- **Backend README**: `backend/README.md`
+
+## Conclusion
+
+✅ **Piper TTS integration is complete and production-ready**
+
+The integration provides users with a choice between:
+- **Kokoro** (zero-setup, high-quality, general purpose)
+- **Piper** (manual setup, pitch control, advanced features)
+
+Both engines work reliably with proper error handling and user guidance. The manual setup requirement for Piper is well-documented and acceptable for the advanced features it provides.
+
+**Status: COMPLETE ✅**

PIPER_STATUS.md

@@ -0,0 +1,150 @@
+# Piper TTS Integration Status
+
+## Current State: ✅ Integrated with Manual Setup Required
+
+Piper TTS has been successfully integrated into the application as an alternative to Kokoro TTS. The integration is **complete and functional**, but requires **manual voice model download** before use.
+
+## What Works
+
+✅ **Backend Integration**
+- PiperTTSService with pitch control (-12 to +12 semitones)
+- UnifiedTTSService managing both engines
+- API endpoints for engine selection
+- Voice preview support for Piper voices
+
+✅ **Frontend Integration**
+- Engine selector UI (Kokoro vs Piper buttons)
+- Dynamic voice loading per engine
+- Visual feedback for active engine
+
+✅ **Documentation**
+- Comprehensive setup guides
+- API documentation
+- Troubleshooting instructions
+
+## What Requires Manual Setup
+
+⚠️ **Voice Models Must Be Downloaded Manually**
+
+Piper voice models cannot be auto-downloaded due to:
+- HuggingFace repository structure complexity
+- SSL certificate verification issues in some environments
+- Large file sizes (10-50MB per voice)
+
+**This is a one-time setup step.**
+
+## How to Use Piper TTS
+
+### Step 1: Install Piper Binary
+
+```bash
+cd backend
+./install_piper.sh
+```
+
+Verify: `piper --version`
+
+### Step 2: Download Voice Models
+
+1. Visit: https://github.com/rhasspy/piper/releases/tag/v1.2.0
+2. Download these files for each voice you want:
+   - `en_US-lessac-medium.onnx` (model file)
+   - `en_US-lessac-medium.onnx.json` (config file)
+
+3. Place in: `backend/piper_models/`
+
+**Recommended starter voices:**
+- `en_US-lessac-medium` (Male, American)
+- `en_US-amy-medium` (Female, American)
+- `en_GB-alan-medium` (Male, British)
+
+### Step 3: Test Installation
+
+```bash
+cd backend
+python test_piper_direct.py
+```
+
+### Step 4: Use in Application
+
+1. Start backend: `uvicorn main:app --reload`
+2. Start frontend: `npm run dev`
+3. In Voice Assignment screen, click "Piper TTS" button
+4. Select Piper voices from dropdown
+5. Generate audiobook with pitch control!
+
+## Why Manual Download?
+
+We attempted automatic download but encountered:
+- **SSL Certificate Issues**: Python's urllib has certificate verification problems
+- **URL Structure**: HuggingFace's repository structure is complex
+- **Reliability**: Manual download is more reliable across different environments
+
+**Trade-off**: One-time manual setup vs. unreliable automatic downloads
+
+## Alternative: Use Kokoro TTS
+
+If Piper setup is too complex, **Kokoro TTS works perfectly out of the box** with:
+- ✅ No manual setup required
+- ✅ 54 voices across 9 languages
+- ✅ High quality synthesis
+- ❌ No pitch control
+
+Simply keep the default "Kokoro TTS" engine selected.
+
+## Error Messages You Might See
+
+### "Voice model not found"
+
+**Cause**: Voice model files not downloaded
+
+**Solution**: Download `.onnx` and `.onnx.json` files and place in `backend/piper_models/`
+
+**See**: `backend/PIPER_SETUP.md` for detailed instructions
+
+### "Piper not found"
+
+**Cause**: Piper binary not installed
+
+**Solution**: Run `./install_piper.sh` or install manually
+
+### "Preview failed"
+
+**Cause**: Voice model missing or Piper not working
+
+**Solution**: 
+1. Check voice models are downloaded
+2. Test with `python test_piper_direct.py`
+3. Check backend logs for detailed errors
+
+## Future Improvements
+
+Potential enhancements for easier setup:
+
+1. **Bundled Voice Models**: Include 1-2 default voices in repository
+2. **Download Script**: Create a helper script to download popular voices
+3. **UI Download**: Add "Download Voice" button in frontend
+4. **Alternative Hosting**: Host models on a simpler CDN
+5. **Docker Image**: Pre-package models in Docker image
+
+## Documentation
+
+- **Setup Guide**: `backend/PIPER_SETUP.md`
+- **Integration Details**: `PIPER_TTS_INTEGRATION.md`
+- **Usage Guide**: `backend/PIPER_TTS_GUIDE.md`
+- **Backend README**: `backend/README.md`
+
+## Support
+
+If you encounter issues:
+
+1. Check `backend/PIPER_SETUP.md` for setup instructions
+2. Run `python test_piper_direct.py` to diagnose problems
+3. Check backend logs for detailed error messages
+4. Fall back to Kokoro TTS if needed
+
+## Summary
+
+**Piper TTS is fully integrated and functional**, but requires a one-time manual setup to download voice models. This is a reasonable trade-off for gaining pitch control capabilities. Users who prefer zero-setup can continue using Kokoro TTS.
+
+**Recommendation**: Document the manual setup clearly in user-facing documentation and consider it a "power user" feature.

PIPER_TTS_INTEGRATION.md

@@ -0,0 +1,209 @@
+# Piper TTS Integration Summary
+
+## Overview
+
+Successfully integrated Piper TTS as an alternative text-to-speech engine alongside Kokoro TTS, giving users the ability to choose between two engines with different strengths.
+
+## What Was Added
+
+### Backend Components
+
+1. **PiperTTSService** (`backend/services/piper_tts_service.py`)
+   - Handles Piper TTS synthesis with pitch control
+   - Supports pitch shifting from -12 to +12 semitones per character
+   - Automatic voice model downloading
+   - Audio effects processing (pitch and speed)
+
+2. **UnifiedTTSService** (`backend/services/unified_tts_service.py`)
+   - Manages multiple TTS engines (Kokoro and Piper)
+   - Runtime engine switching
+   - Unified API for both engines
+   - Handles engine-specific features (pitch control for Piper)
+
+3. **New API Endpoints** (in `backend/main.py`)
+   - `GET /api/tts/engines` - List available engines and current selection
+   - `POST /api/tts/engines` - Switch active TTS engine
+   - `GET /api/tts/voices` - Get available voices for all engines
+   - Updated `POST /api/tts` to support `pitch_adjustments` parameter
+
+4. **Installation Script** (`backend/install_piper.sh`)
+   - Automated Piper TTS installation for macOS/Linux
+   - Detects OS and architecture
+   - Installs to `/usr/local/bin`
+
+### Frontend Components
+
+1. **API Client Functions** (`frontend/src/api/tts.ts`)
+   - `getEngines()` - Fetch available engines
+   - `setEngine(engine)` - Switch active engine
+   - `getVoices()` - Get voices for all engines
+   - TypeScript interfaces for engine data
+
+2. **UI Components** (`frontend/src/components/VoiceAssignmentSection.tsx`)
+   - Engine selector buttons (Kokoro vs Piper)
+   - Dynamic voice loading based on selected engine
+   - Visual feedback for active engine
+   - Pitch control capability notice for Piper
+
+### Documentation
+
+1. **Backend README** (`backend/README.md`)
+   - Multi-engine setup instructions
+   - Engine switching examples
+   - Pitch control documentation
+
+2. **Piper TTS Guide** (`backend/PIPER_TTS_GUIDE.md`)
+   - Comprehensive installation guide
+   - Available voices documentation
+   - Pitch adjustment guidelines
+   - Usage examples and best practices
+   - Troubleshooting section
+
+3. **Integration Summary** (this file)
+
+## Engine Comparison
+
+| Feature | Kokoro TTS | Piper TTS |
+|---------|------------|-----------|
+| **Quality** | High | Medium-High |
+| **Speed** | Medium | Fast |
+| **Voices** | 54 voices, 9 languages | 5+ English voices |
+| **Pitch Control** | ❌ No | ✅ Yes (-12 to +12 semitones) |
+| **Model Size** | ~500MB | ~10-50MB per voice |
+| **Memory Usage** | Higher | Lower |
+| **Languages** | 9 languages | English (more available) |
+
+## How to Use
+
+### Backend Setup
+
+1. **Install Piper TTS** (optional):
+   ```bash
+   cd backend
+   ./install_piper.sh
+   ```
+
+2. **Set default engine** (optional):
+   ```bash
+   # In backend/.env
+   TTS_ENGINE=piper  # or kokoro (default)
+   ```
+
+3. **Install Python dependencies**:
+   ```bash
+   pip install -r requirements.txt
+   ```
+
+### Frontend Usage
+
+1. **Select Engine**: In the Voice Assignment screen, click either "Kokoro TTS" or "Piper TTS" button
+2. **Choose Voices**: Voice dropdown updates automatically with engine-specific voices
+3. **Generate**: Audio is generated using the selected engine
+
+### API Usage
+
+**Switch Engine:**
+```bash
+curl -X POST http://localhost:8000/api/tts/engines \
+  -H "Content-Type: application/json" \
+  -d '{"engine": "piper"}'
+```
+
+**Generate with Pitch Control (Piper only):**
+```bash
+curl -X POST http://localhost:8000/api/tts \
+  -H "Content-Type: application/json" \
+  -d '{
+    "text": "Alice: Hello!\nBob: Hi there!",
+    "lang": "a",
+    "roles": [
+      {"id": "Alice", "voice": "en_US-amy-medium"},
+      {"id": "Bob", "voice": "en_US-lessac-medium"}
+    ],
+    "pitch_adjustments": [
+      {"id": "Alice", "pitch": 3},
+      {"id": "Bob", "pitch": -2}
+    ]
+  }' \
+  --output audiobook.wav
+```
+
+## Pitch Control Guidelines
+
+When using Piper TTS, you can adjust pitch per character:
+
+- **+12 semitones**: One octave higher (very high-pitched)
+- **+6 semitones**: Noticeably higher (child-like)
+- **+3 semitones**: Slightly higher (feminine adjustment)
+- **0 semitones**: Original voice (no change)
+- **-3 semitones**: Slightly lower (masculine adjustment)
+- **-6 semitones**: Noticeably lower (deep voice)
+- **-12 semitones**: One octave lower (very deep)
+
+**Recommended ranges:**
+- Female characters: +2 to +5
+- Male characters: -2 to -5
+- Children: +5 to +8
+- Elderly/deep voices: -4 to -8
+
+## Testing
+
+Run the engine selection test:
+```bash
+cd backend
+python test_engine_selection.py
+```
+
+## Files Modified/Created
+
+### Backend
+- ✅ `backend/services/piper_tts_service.py` (new)
+- ✅ `backend/services/unified_tts_service.py` (new)
+- ✅ `backend/main.py` (modified - added endpoints)
+- ✅ `backend/requirements.txt` (modified - added piper-tts, pydub)
+- ✅ `backend/.env.example` (modified - added TTS_ENGINE)
+- ✅ `backend/README.md` (modified - added multi-engine docs)
+- ✅ `backend/PIPER_TTS_GUIDE.md` (new)
+- ✅ `backend/install_piper.sh` (new)
+- ✅ `backend/test_engine_selection.py` (new)
+
+### Frontend
+- ✅ `frontend/src/api/tts.ts` (modified - added engine functions)
+- ✅ `frontend/src/components/VoiceAssignmentSection.tsx` (modified - added engine selector)
+
+### Documentation
+- ✅ `.kiro/specs/text-to-audiobook/tasks.md` (modified - added task 26)
+- ✅ `PIPER_TTS_INTEGRATION.md` (new - this file)
+
+## Git Commits
+
+1. **feat: Add Piper TTS integration with pitch control support** (bfdcc94)
+   - Backend services and API endpoints
+   - Installation script and documentation
+
+2. **feat: Add TTS engine selector UI in frontend** (c310f11)
+   - Frontend UI components
+   - API client functions
+
+## Next Steps (Optional Enhancements)
+
+1. **Pitch Control UI**: Add pitch sliders in the frontend for Piper engine
+2. **Voice Previews**: Update preview functionality to work with Piper voices
+3. **More Piper Voices**: Add support for additional Piper voice models
+4. **Coqui TTS**: Integrate Coqui XTTS as a third engine option
+5. **Voice Cloning**: Add voice cloning capabilities with Piper/Coqui
+
+## Notes
+
+- Piper TTS requires separate installation (not included in Python packages)
+- Voice models are downloaded automatically on first use
+- Kokoro remains the default engine for backward compatibility
+- Both engines can coexist and be switched at runtime
+- Pitch control is only available with Piper TTS
+
+## Support
+
+For issues or questions:
+- See `backend/PIPER_TTS_GUIDE.md` for detailed Piper documentation
+- See `backend/README.md` for general backend setup
+- Check troubleshooting sections in both guides

RESTART_REQUIRED.md

@@ -0,0 +1,23 @@
+# ⚠️ RESTART REQUIRED
+
+The UI has been completely redesigned with proper spacing, typography, and visual hierarchy.
+
+## To see the changes:
+
+1. **Stop the frontend dev server** (Ctrl+C in the terminal running `npm start`)
+2. **Restart it**: `cd frontend && npm start`
+3. **Refresh your browser** (hard refresh: Cmd+Shift+R on Mac, Ctrl+Shift+R on Windows)
+
+## What's been fixed:
+
+✅ CSS import order corrected for Tailwind v4
+✅ Professional spacing and padding throughout
+✅ Proper card containers with shadows
+✅ Beautiful typography hierarchy
+✅ Gradient buttons with hover effects
+✅ Progress stepper with step labels
+✅ Generous white space and breathing room
+✅ Modern color scheme (indigo/purple/gray)
+✅ Smooth transitions and animations
+
+The UI is now professional, polished, and ready to use!

TESTING_GUIDE.md

@@ -0,0 +1,197 @@
+# Testing Guide for AI-Powered Audiobook Features
+
+## ✅ Services Status
+
+Both services are now running:
+- **Backend**: http://localhost:8002
+- **Frontend**: http://localhost:5173
+- **Ollama**: http://localhost:11434 (required for AI features)
+
+## 🎯 How to Test AI Features
+
+### Test 1: AI Speaker Detection (No Markers Needed!)
+
+Open the frontend at http://localhost:5173 and try this text:
+
+```
+The old wizard Merlin gazed into his crystal ball with concern. Dark times are coming, he whispered to himself.
+
+A young knight named Arthur entered the chamber. Master Merlin, I heard your summons, he said with determination.
+
+Merlin turned to face him. Arthur, the kingdom needs you now more than ever.
+
+Arthur drew his sword. I am ready to defend our people.
+
+From the shadows, the sorceress Morgana watched silently. She knew the prophecy would unfold exactly as foretold.
+```
+
+**What should happen:**
+1. Click "Next: Assign voices"
+2. The AI should detect: **Merlin**, **Arthur**, **Morgana** (and possibly Narrator)
+3. Assign different voices to each character
+4. Click "Generate Audiobook"
+5. The AI will intelligently split the text so:
+   - Narrative descriptions → Narrator voice
+   - Merlin's dialogue → Merlin's voice
+   - Arthur's dialogue → Arthur's voice
+   - Morgana's thoughts → Morgana's voice
+
+### Test 2: Mixed Marked and Unmarked Text
+
+Try this text that combines explicit markers with unmarked dialogue:
+
+```
+Alice: Hello there!
+Bob: Hi Alice, how are you?
+[Narrator] They continued talking in the garden.
+Charlie joined them later and smiled warmly.
+```
+
+**What should happen:**
+- AI detects: Alice, Bob, Narrator, Charlie
+- Pattern matching catches Alice, Bob, Narrator from markers
+- AI catches Charlie from the unmarked text
+
+### Test 3: Pure Narrative (No Dialogue)
+
+Try this descriptive text:
+
+```
+The sun set over the mountains. Birds flew across the orange sky. A gentle breeze rustled through the trees. Peace settled over the valley.
+```
+
+**What should happen:**
+- AI detects: Narrator (default for pure narrative)
+- All text assigned to Narrator voice
+
+### Test 4: Complex Dialogue Scene
+
+Try this more complex scene:
+
+```
+The detective examined the evidence carefully. This doesn't add up, she muttered.
+
+Her partner looked over her shoulder. What did you find?
+
+She pointed at the photograph. Look at the timestamp. This photo was taken after the victim was already dead.
+
+The partner's eyes widened. That means someone is lying.
+
+Exactly, the detective replied. And I think I know who.
+```
+
+**What should happen:**
+- AI detects: Detective, Partner (and possibly Narrator)
+- Intelligently assigns dialogue to each character
+- Narrative descriptions go to Narrator
+
+## 🔍 Verification
+
+### Check Backend Logs
+
+The backend logs will show which detection method is being used:
+
+```bash
+# Look for these log messages:
+- "AI detection found X roles"
+- "Pattern detection found X roles"
+- "Using AI-powered segmentation"
+- "Using pattern-based segmentation as fallback"
+```
+
+### Test via API Directly
+
+You can also test the API directly:
+
+```bash
+# Test role detection
+curl -X POST http://localhost:8002/api/tts/roles \
+  -H "Content-Type: application/json" \
+  -d '{"text": "The wizard spoke. The knight replied."}'
+
+# Expected: Detects "Wizard" and "Knight" without any markers!
+```
+
+## 🎭 Voice Options Available
+
+When assigning voices, you have these options:
+- **af_bella** - Female, American
+- **af_sarah** - Female, American
+- **am_adam** - Male, American
+- **am_michael** - Male, American
+- **bf_emma** - Female, British
+- **bf_isabella** - Female, British
+- **bm_george** - Male, British
+- **bm_lewis** - Male, British
+
+## 🚨 Troubleshooting
+
+### If AI detection isn't working:
+
+1. **Check Ollama is running:**
+   ```bash
+   curl http://localhost:11434/api/tags
+   ```
+
+2. **Check llama3 model is available:**
+   ```bash
+   ollama list | grep llama3
+   ```
+
+3. **If model is missing:**
+   ```bash
+   ollama pull llama3
+   ```
+
+4. **Restart Ollama:**
+   ```bash
+   # Stop Ollama (Ctrl+C if running in terminal)
+   ollama serve
+   ```
+
+### If backend isn't responding:
+
+```bash
+# Check if backend is running
+curl http://localhost:8002/api/health
+
+# If not, restart it
+cd backend
+source venv/bin/activate
+uvicorn main:app --reload --host 0.0.0.0 --port 8002
+```
+
+### If frontend isn't loading:
+
+```bash
+# Check if frontend is running
+curl http://localhost:5173
+
+# If not, restart it
+cd frontend
+npm run dev
+```
+
+## 🎉 What Makes This Powerful
+
+**Before (Pattern-only):**
+- Required explicit markers like "Alice:" or "[Narrator]"
+- Unmarked text all went to Narrator
+- Manual markup was tedious
+
+**After (AI-powered):**
+- ✨ Detects characters automatically from context
+- ✨ Intelligently assigns dialogue to speakers
+- ✨ Handles narrative and dialogue seamlessly
+- ✨ No manual markup needed!
+- ✨ Still supports explicit markers as fallback
+
+## 📝 Tips for Best Results
+
+1. **Use clear character names** in the narrative (e.g., "The wizard Merlin" instead of just "He")
+2. **Include dialogue tags** like "he said", "she replied" to help AI identify speakers
+3. **Keep paragraphs focused** on one speaker at a time when possible
+4. **Mix narrative and dialogue** for more natural audiobooks
+5. **Test with short samples first** to verify voice assignments before generating long audiobooks
+
+Enjoy your powerful AI-driven audiobook generator! 🎙️✨

TTS_ENGINE_QUICK_REFERENCE.md

@@ -0,0 +1,135 @@
+# TTS Engine Quick Reference
+
+## 🎯 Which Engine Should I Use?
+
+### Use Kokoro TTS (Default) if you want:
+- ✅ **Zero setup** - works immediately
+- ✅ **High quality** voices
+- ✅ **Many voices** - 54 voices, 9 languages
+- ✅ **Multiple languages** - English, French, Japanese, Spanish, etc.
+
+### Use Piper TTS if you want:
+- ✅ **Pitch control** - adjust voice pitch per character
+- ✅ **Fast synthesis** - quicker generation
+- ✅ **Lower memory** - smaller models
+- ⚠️ **Manual setup required** - one-time voice download
+
+---
+
+## 🚀 Quick Start
+
+### Kokoro TTS (No Setup)
+1. Start the app
+2. It just works! ✨
+
+### Piper TTS (3-Minute Setup)
+1. Install Piper: `cd backend && ./install_piper.sh`
+2. Download voices from: https://github.com/rhasspy/piper/releases/tag/v1.2.0
+3. Place `.onnx` and `.onnx.json` files in `backend/piper_models/`
+4. Done! See `backend/PIPER_SETUP.md` for details
+
+---
+
+## 🎛️ How to Switch Engines
+
+### In the UI:
+1. Go to **Voice Assignment** screen
+2. Click **"Kokoro TTS"** or **"Piper TTS"** button
+3. Voice dropdown updates automatically
+
+### Via API:
+```bash
+curl -X POST http://localhost:8000/api/tts/engines \
+  -H "Content-Type: application/json" \
+  -d '{"engine": "piper"}'
+```
+
+### Via Environment Variable:
+```bash
+# In backend/.env
+TTS_ENGINE=piper  # or kokoro
+```
+
+---
+
+## 🎵 Pitch Control (Piper Only)
+
+Adjust voice pitch per character in semitones:
+
+```
++12 = Very high (one octave up)
++6  = Child-like
++3  = Slightly higher (feminine)
+0   = Original voice
+-3  = Slightly lower (masculine)
+-6  = Deep voice
+-12 = Very deep (one octave down)
+```
+
+**Recommended:**
+- Female characters: +2 to +5
+- Male characters: -2 to -5
+- Children: +5 to +8
+
+---
+
+## 📊 Feature Comparison
+
+| Feature | Kokoro | Piper |
+|---------|--------|-------|
+| Setup | None | Manual |
+| Quality | ⭐⭐⭐⭐⭐ | ⭐⭐⭐⭐ |
+| Speed | Medium | Fast |
+| Voices | 54 | 5+ |
+| Languages | 9 | English |
+| Pitch Control | ❌ | ✅ |
+| Memory | 500MB | 10-50MB |
+
+---
+
+## 🔧 Troubleshooting
+
+### "Voice preview failed"
+- **Kokoro**: Check internet connection (first-time model download)
+- **Piper**: Download voice models manually (see PIPER_SETUP.md)
+
+### "Voice model not found"
+- Download `.onnx` and `.onnx.json` files
+- Place in `backend/piper_models/`
+- Restart backend server
+
+### "Piper not found"
+- Run `./install_piper.sh`
+- Or install from: https://github.com/rhasspy/piper/releases
+
+---
+
+## 📚 Documentation
+
+- **Piper Setup**: `backend/PIPER_SETUP.md`
+- **Piper Guide**: `backend/PIPER_TTS_GUIDE.md`
+- **Status**: `PIPER_STATUS.md`
+- **Full Details**: `PIPER_TTS_INTEGRATION.md`
+
+---
+
+## 💡 Pro Tips
+
+1. **Start with Kokoro** - Try it first, it's easier
+2. **Try Piper for variety** - Pitch control adds character depth
+3. **Mix engines** - Use Kokoro for most, Piper for special characters
+4. **Download multiple voices** - More variety in your audiobooks
+5. **Test voices** - Use preview button before generating full audiobook
+
+---
+
+## 🆘 Need Help?
+
+1. Check `backend/PIPER_SETUP.md` for setup
+2. Run `python test_piper_direct.py` to test Piper
+3. Check backend logs for detailed errors
+4. Fall back to Kokoro if Piper has issues
+
+---
+
+**Remember:** Both engines work great! Kokoro is easier, Piper is more advanced. Choose based on your needs. 🎉

Test Story.txt

@@ -0,0 +1,63 @@
+Once upon a time, in a tiny village surrounded by lush green forests, there lived three best friends: Lily the rabbit, Benny the bear, and Sammy the squirrel. They loved to explore the woods together, playing hide-and-seek behind trees and chasing after butterflies.
+
+One sunny afternoon, they decided to have a picnic on a hill overlooking the forest. They brought their favorite snacks – carrots for Lily, honey sandwiches for Benny, and acorn cookies for Sammy.
+
+As they sat down on a blanket, Lily asked, "Have you guys heard about the new stream that just appeared in the woods?"
+
+Benny's eyes lit up. "Ooh, I love streams! Do we get to go see it now?"
+
+Sammy nodded enthusiastically. "I've been wanting to explore the forest more since the snow melted. Let's go!"
+
+Lily grinned. "But first, let's finish our snacks and enjoy the view. We can go see the stream after that."
+
+As they munched on their treats, Benny started telling a joke: "Why did the bear go to the party?"
+
+Sammy chuckled. "I don't know, why?"
+
+Benny laughed. "Because he was grizzly good at dancing!"
+
+Lily giggled. "Oh, Benny, you're such a pun master!"
+
+After finishing their snacks, they packed up the remains and set off towards the stream. As they walked, Sammy pointed out different types of leaves and flowers growing along the path.
+
+Benny asked, "Sammy, how do you know so much about plants?"
+
+Sammy beamed with pride. "My mom is a great botanist. She taught me all about the different species in our forest."
+
+Lily nodded. "I've seen her collecting samples and making notes before. She's very smart!"
+
+As they approached the stream, Benny exclaimed, "Wow! Look at that! It's so clear and sparkly!"
+
+Sammy gasped. "And look, there are fish swimming in it!"
+
+Lily clapped her paws together. "This is going to be so much fun! Let's catch some fish for lunch!"
+
+Benny and Sammy cheered as they started skipping stones across the stream. Lily laughed as she tried to catch the fish with a makeshift net made from vines.
+
+As they played, Benny noticed something strange. "Guys, look up there."
+
+Sammy followed his gaze and gasped. A small waterfall cascaded down a rocky cliff, creating a misty veil that surrounded them.
+
+Lily's eyes widened. "This is amazing! I've never seen anything like it!"
+
+Benny grinned. "I think we should name this place the 'Misty Grotto'!"
+
+Sammy nodded enthusiastically. "And we can come back and explore more tomorrow!"
+
+As the sun began to set, they reluctantly said their goodbyes to the stream and headed back to the village. As they walked, Lily asked, "Benny, what's your favorite thing about our forest?"
+
+Benny thought for a moment before responding, "I think it's all the hidden treasures we find along the way. Like this stream or that waterfall."
+
+Sammy nodded in agreement. "And there are always new things to discover! That's what I love most about our forest too."
+
+Lily smiled. "For me, it's the friends I make and the adventures we have together. You guys are my favorite treasures!"
+
+As they approached the village, Benny turned to his friends and said, "You know what? Let's plan a camping trip for next weekend! We can bring sleeping bags and roast marshmallows over a campfire!"
+
+Sammy's eyes lit up. "That sounds like so much fun! Can we invite some other villagers too?"
+
+Lily nodded. "I'm sure Mom would love to come. She's always telling me about the camping trips she went on when she was younger."
+
+Benny grinned. "It'll be a blast! Let's get planning and make it the best camping trip ever!"
+
+As they entered their cozy little homes, Lily, Benny, and Sammy all smiled, knowing that they had each other and the magical forest to explore, filled with hidden treasures and endless adventures waiting to be discovered.

backend/.env.example

@@ -1,2 +1,4 @@
 PORT=8000
 LOG_LEVEL=info
+OLLAMA_BASE_URL=http://localhost:11434
+TTS_ENGINE=kokoro

backend/EASY_PIPER_SETUP.md

@@ -0,0 +1,130 @@
+# Easy Piper TTS Setup (5 Minutes)
+
+## The Problem
+
+Piper voice models can't be auto-downloaded due to HuggingFace's complex repository structure. But don't worry - manual download is quick and easy!
+
+## Quick Setup (3 Steps)
+
+### Step 1: Download Voice Files
+
+Visit this page: **https://github.com/rhasspy/piper/releases/tag/v1.2.0**
+
+Scroll down to "Assets" section and download these files:
+
+**Recommended Starter Pack (3 voices):**
+
+1. **en_US-lessac-medium** (Male, American)
+   - Download: `en_US-lessac-medium.onnx` (63 MB)
+   - Download: `en_US-lessac-medium.onnx.json` (8 KB)
+
+2. **en_US-amy-medium** (Female, American)
+   - Download: `en_US-amy-medium.onnx` (63 MB)
+   - Download: `en_US-amy-medium.onnx.json` (8 KB)
+
+3. **en_GB-alan-medium** (Male, British)
+   - Download: `en_GB-alan-medium.onnx` (63 MB)
+   - Download: `en_GB-alan-medium.onnx.json` (8 KB)
+
+**Total download:** ~190 MB for 3 voices
+
+### Step 2: Place Files
+
+Move all downloaded files to:
+```
+backend/piper_models/
+```
+
+Your directory should look like:
+```
+backend/piper_models/
+├── en_US-lessac-medium.onnx
+├── en_US-lessac-medium.onnx.json
+├── en_US-amy-medium.onnx
+├── en_US-amy-medium.onnx.json
+├── en_GB-alan-medium.onnx
+└── en_GB-alan-medium.onnx.json
+```
+
+### Step 3: Test
+
+```bash
+cd backend
+python test_piper_direct.py
+```
+
+You should see: "✓ Synthesis successful"
+
+## Done! 🎉
+
+Now you can:
+1. Start the backend: `uvicorn main:app --reload`
+2. Open the UI
+3. Click "Piper TTS" button
+4. Select Piper voices
+5. Generate audiobooks with pitch control!
+
+## More Voices (Optional)
+
+Want more variety? Download additional voices from the same page:
+
+**More American English:**
+- `en_US-libritts-high` (High quality, neutral)
+- `en_US-ryan-high` (Male, high quality)
+
+**More British English:**
+- `en_GB-alba-medium` (Female)
+- `en_GB-jenny_dioco-medium` (Female)
+
+**Other Languages:**
+- Browse the releases page for Spanish, French, German, etc.
+
+## Troubleshooting
+
+### "Model not found" error
+- Make sure you downloaded BOTH `.onnx` and `.onnx.json` files
+- Check files are in `backend/piper_models/` directory
+- Verify filenames match exactly (case-sensitive)
+
+### Files won't download
+- Try a different browser
+- Check your internet connection
+- Download one at a time if needed
+
+### Still having issues?
+- Fall back to Kokoro TTS (works out of the box)
+- Check `backend/PIPER_SETUP.md` for detailed troubleshooting
+
+## Why Manual Download?
+
+We tried automatic download but encountered:
+- ❌ Complex HuggingFace URL structure
+- ❌ SSL certificate issues
+- ❌ Unreliable across different systems
+
+Manual download is:
+- ✅ Fast (5 minutes)
+- ✅ Reliable (always works)
+- ✅ One-time setup
+- ✅ You control what you download
+
+## Alternative: Use Kokoro TTS
+
+If this seems like too much work, **Kokoro TTS works perfectly with zero setup**:
+- ✅ No downloads needed
+- ✅ 54 voices, 9 languages
+- ✅ High quality
+- ❌ No pitch control
+
+Just keep "Kokoro TTS" selected in the UI!
+
+## Need Help?
+
+1. Check the files are in the right place
+2. Run `python test_piper_direct.py` to diagnose
+3. Check backend logs for errors
+4. See `PIPER_STATUS.md` for more troubleshooting
+
+---
+
+**Remember:** This is a one-time setup. Once downloaded, Piper voices work forever! 🚀

backend/PIPER_DOWNLOAD_GUIDE.md

@@ -0,0 +1,154 @@
+# Piper Voice Download - Visual Guide
+
+## 📥 Step-by-Step Instructions
+
+### Step 1: Go to Piper Releases Page
+
+Open this link in your browser:
+```
+https://github.com/rhasspy/piper/releases/tag/v1.2.0
+```
+
+### Step 2: Scroll to "Assets" Section
+
+Scroll down the page until you see a section called "Assets" with a list of files.
+
+### Step 3: Download Voice Files
+
+Click on each file to download (you need BOTH files for each voice):
+
+#### Voice 1: Male American (Lessac)
+- ✅ Click: `en_US-lessac-medium.onnx` (63 MB)
+- ✅ Click: `en_US-lessac-medium.onnx.json` (8 KB)
+
+#### Voice 2: Female American (Amy)
+- ✅ Click: `en_US-amy-medium.onnx` (63 MB)
+- ✅ Click: `en_US-amy-medium.onnx.json` (8 KB)
+
+#### Voice 3: Male British (Alan)
+- ✅ Click: `en_GB-alan-medium.onnx` (63 MB)
+- ✅ Click: `en_GB-alan-medium.onnx.json` (8 KB)
+
+**Total:** 6 files, ~190 MB
+
+### Step 4: Move Files to Models Directory
+
+1. Open your terminal
+2. Navigate to your project:
+   ```bash
+   cd /path/to/audiobook/backend
+   ```
+
+3. Create models directory if it doesn't exist:
+   ```bash
+   mkdir -p piper_models
+   ```
+
+4. Move downloaded files:
+   ```bash
+   # From your Downloads folder
+   mv ~/Downloads/en_US-*.onnx* piper_models/
+   mv ~/Downloads/en_GB-*.onnx* piper_models/
+   ```
+
+### Step 5: Verify Files
+
+Check that files are in place:
+```bash
+ls -lh piper_models/
+```
+
+You should see:
+```
+en_US-lessac-medium.onnx       (63 MB)
+en_US-lessac-medium.onnx.json  (8 KB)
+en_US-amy-medium.onnx          (63 MB)
+en_US-amy-medium.onnx.json     (8 KB)
+en_GB-alan-medium.onnx         (63 MB)
+en_GB-alan-medium.onnx.json    (8 KB)
+```
+
+### Step 6: Test Installation
+
+```bash
+python test_piper_direct.py
+```
+
+Expected output:
+```
+✓ Piper found
+✓ Model found: /path/to/piper_models/en_US-lessac-medium.onnx
+✓ Synthesis successful: XXXXX bytes of audio
+```
+
+## ✅ You're Done!
+
+Now you can use Piper TTS:
+
+1. **Start backend:**
+   ```bash
+   uvicorn main:app --reload
+   ```
+
+2. **Open frontend** in browser
+
+3. **Select "Piper TTS"** in Voice Assignment screen
+
+4. **Choose Piper voices** from dropdown
+
+5. **Generate audiobook** with pitch control!
+
+## 🎯 Quick Checklist
+
+- [ ] Downloaded 6 files (3 voices × 2 files each)
+- [ ] Moved files to `backend/piper_models/`
+- [ ] Verified files with `ls -lh piper_models/`
+- [ ] Tested with `python test_piper_direct.py`
+- [ ] Started backend server
+- [ ] Selected "Piper TTS" in UI
+
+## 🆘 Troubleshooting
+
+### Can't find files on GitHub?
+- Make sure you're on the v1.2.0 release page
+- Scroll down to "Assets" section
+- Files are listed alphabetically
+
+### Download fails?
+- Try a different browser
+- Check internet connection
+- Download one file at a time
+
+### Files in wrong place?
+```bash
+# Check current location
+pwd
+
+# Should show: /path/to/audiobook/backend
+
+# List models directory
+ls piper_models/
+```
+
+### Test fails?
+- Make sure BOTH .onnx and .onnx.json files are present
+- Check filenames match exactly (case-sensitive)
+- Verify Piper is installed: `piper --version`
+
+## 💡 Pro Tips
+
+1. **Download all at once:** Select all 6 files and download together
+2. **Use command line:** Faster to move files with `mv` command
+3. **Bookmark the page:** Easy to download more voices later
+4. **Try different voices:** Each has unique characteristics
+
+## 🔗 Useful Links
+
+- **Download Page:** https://github.com/rhasspy/piper/releases/tag/v1.2.0
+- **Voice Samples:** https://rhasspy.github.io/piper-samples/
+- **Full Setup Guide:** `PIPER_SETUP.md`
+- **Troubleshooting:** `PIPER_STATUS.md`
+
+---
+
+**Need more help?** Check `EASY_PIPER_SETUP.md` or ask for assistance!

backend/PIPER_SETUP.md

@@ -0,0 +1,98 @@
+# Piper TTS Setup Guide
+
+## Quick Start
+
+Piper TTS is now integrated but requires manual voice model setup.
+
+### 1. Install Piper
+
+```bash
+cd backend
+./install_piper.sh
+```
+
+Verify installation:
+```bash
+piper --version
+```
+
+### 2. Download Voice Models
+
+Piper voice models need to be downloaded manually and placed in `backend/piper_models/`.
+
+**Download voices from:**
+https://github.com/rhasspy/piper/releases/tag/v1.2.0
+
+**Recommended voices for English:**
+
+1. **en_US-lessac-medium** (Male, American)
+   - Download: `en_US-lessac-medium.onnx` and `en_US-lessac-medium.onnx.json`
+   - Place in: `backend/piper_models/`
+
+2. **en_US-amy-medium** (Female, American)
+   - Download: `en_US-amy-medium.onnx` and `en_US-amy-medium.onnx.json`
+   - Place in: `backend/piper_models/`
+
+3. **en_GB-alan-medium** (Male, British)
+   - Download: `en_GB-alan-medium.onnx` and `en_GB-alan-medium.onnx.json`
+   - Place in: `backend/piper_models/`
+
+### 3. Directory Structure
+
+After downloading, your directory should look like:
+
+```
+backend/
+├── piper_models/
+│   ├── en_US-lessac-medium.onnx
+│   ├── en_US-lessac-medium.onnx.json
+│   ├── en_US-amy-medium.onnx
+│   ├── en_US-amy-medium.onnx.json
+│   ├── en_GB-alan-medium.onnx
+│   └── en_GB-alan-medium.onnx.json
+└── ...
+```
+
+### 4. Test Piper
+
+```bash
+cd backend
+python test_piper_direct.py
+```
+
+### 5. Use in Application
+
+1. Start the backend server
+2. In the frontend, click "Piper TTS" button in Voice Assignment screen
+3. Select Piper voices from the dropdown
+4. Generate audiobook with pitch control!
+
+## Troubleshooting
+
+### "Model not found" error
+
+- Make sure you downloaded both `.onnx` and `.onnx.json` files
+- Check files are in `backend/piper_models/` directory
+- Verify filenames match exactly (case-sensitive)
+
+### "Piper not found" error
+
+- Run `./install_piper.sh` to install Piper
+- Or install manually from https://github.com/rhasspy/piper/releases
+
+### Synthesis fails
+
+- Check Piper version: `piper --version`
+- Try running Piper directly: `echo "test" | piper --model piper_models/en_US-lessac-medium.onnx --output-raw > test.wav`
+- Check backend logs for detailed error messages
+
+## Alternative: Use Kokoro TTS
+
+If Piper setup is too complex, you can continue using Kokoro TTS (the default engine) which works out of the box with no additional setup.
+
+## More Voices
+
+Browse all available Piper voices:
+https://rhasspy.github.io/piper-samples/
+
+Download any voice and place the `.onnx` and `.onnx.json` files in `backend/piper_models/`.

backend/PIPER_TTS_GUIDE.md

@@ -0,0 +1,292 @@
+# Piper TTS Integration Guide
+
+This guide covers the Piper TTS engine integration, including installation, configuration, and usage.
+
+## What is Piper TTS?
+
+Piper is a fast, local neural text-to-speech system that runs entirely on your machine. It offers:
+
+- **Fast synthesis**: Faster than Kokoro for most use cases
+- **Pitch control**: Adjust voice pitch per character (-12 to +12 semitones)
+- **Multiple voices**: Various English voices with different characteristics
+- **Low resource usage**: Smaller models and lower memory footprint
+- **Privacy**: All processing happens locally
+
+## Installation
+
+### Automated Installation (Recommended)
+
+```bash
+cd backend
+./install_piper.sh
+```
+
+This script will:
+1. Detect your OS and architecture
+2. Download the appropriate Piper binary
+3. Install it to `/usr/local/bin`
+4. Verify the installation
+
+### Manual Installation
+
+1. Visit [Piper Releases](https://github.com/rhasspy/piper/releases/tag/v1.2.0)
+2. Download the appropriate archive for your platform:
+   - **Linux x86_64**: `piper_amd64.tar.gz`
+   - **Linux ARM64**: `piper_arm64.tar.gz`
+   - **macOS**: `piper_macos_x64.tar.gz`
+3. Extract the archive
+4. Copy the `piper` binary to a directory in your PATH
+
+### Verify Installation
+
+```bash
+piper --version
+```
+
+You should see output like: `1.2.0`
+
+## Available Voices
+
+Piper supports multiple English voices:
+
+| Voice ID | Language | Gender | Quality | Description |
+|----------|----------|--------|---------|-------------|
+| `en_US-lessac-medium` | US English | Male | Medium | Clear, neutral male voice |
+| `en_US-libritts-high` | US English | Neutral | High | High-quality neutral voice |
+| `en_US-amy-medium` | US English | Female | Medium | Clear female voice |
+| `en_GB-alan-medium` | UK English | Male | Medium | British male voice |
+| `en_GB-alba-medium` | UK English | Female | Medium | British female voice |
+
+Voice models are automatically downloaded on first use (~10-50MB each).
+
+## Configuration
+
+### Set Piper as Default Engine
+
+**Option 1: Environment Variable**
+```bash
+export TTS_ENGINE=piper
+```
+
+Add to your `.env` file:
+```bash
+TTS_ENGINE=piper
+```
+
+**Option 2: Runtime API Call**
+```bash
+curl -X POST http://localhost:8000/api/tts/engines \
+  -H "Content-Type: application/json" \
+  -d '{"engine": "piper"}'
+```
+
+### Voice Model Storage
+
+Voice models are stored in:
+```
+backend/piper_models/
+```
+
+Models are downloaded automatically on first use. You can pre-download models manually if needed.
+
+## Usage Examples
+
+### Basic Text-to-Speech
+
+```bash
+curl -X POST http://localhost:8000/api/tts \
+  -H "Content-Type: application/json" \
+  -d '{
+    "text": "Hello, this is a test of Piper TTS.",
+    "lang": "a",
+    "roles": [
+      {"id": "Narrator", "voice": "en_US-lessac-medium"}
+    ],
+    "speed": 1.0
+  }' \
+  --output test.wav
+```
+
+### Multi-Voice with Pitch Control
+
+```bash
+curl -X POST http://localhost:8000/api/tts \
+  -H "Content-Type: application/json" \
+  -d '{
+    "text": "Alice: Hello Bob!\nBob: Hi Alice, how are you?\nNarrator: They greeted each other warmly.",
+    "lang": "a",
+    "roles": [
+      {"id": "Alice", "voice": "en_US-amy-medium"},
+      {"id": "Bob", "voice": "en_US-lessac-medium"},
+      {"id": "Narrator", "voice": "en_GB-alan-medium"}
+    ],
+    "speed": 1.0,
+    "pitch_adjustments": [
+      {"id": "Alice", "pitch": 4},
+      {"id": "Bob", "pitch": -3},
+      {"id": "Narrator", "pitch": 0}
+    ]
+  }' \
+  --output audiobook.wav
+```
+
+### Pitch Adjustment Guidelines
+
+Pitch is measured in semitones (half-steps on a musical scale):
+
+- **+12 semitones**: One octave higher (very high-pitched)
+- **+6 semitones**: Noticeably higher (child-like)
+- **+3 semitones**: Slightly higher (feminine adjustment)
+- **0 semitones**: Original voice (no change)
+- **-3 semitones**: Slightly lower (masculine adjustment)
+- **-6 semitones**: Noticeably lower (deep voice)
+- **-12 semitones**: One octave lower (very deep)
+
+**Recommended ranges:**
+- Female characters: +2 to +5
+- Male characters: -2 to -5
+- Children: +5 to +8
+- Elderly/deep voices: -4 to -8
+
+## Python API Usage
+
+```python
+from services.unified_tts_service import UnifiedTTSService
+
+# Initialize with Piper engine
+tts = UnifiedTTSService(engine="piper")
+
+# Generate audiobook with pitch control
+audio_bytes = await tts.generate_audiobook(
+    text="Alice: Hello!\nBob: Hi there!",
+    lang="a",
+    role_voice_map={
+        "Alice": "en_US-amy-medium",
+        "Bob": "en_US-lessac-medium"
+    },
+    speed=1.0,
+    pitch_adjustments={
+        "Alice": 3,
+        "Bob": -2
+    }
+)
+
+# Save to file
+with open("output.wav", "wb") as f:
+    f.write(audio_bytes)
+```
+
+## Performance Comparison
+
+| Feature | Kokoro TTS | Piper TTS |
+|---------|------------|-----------|
+| Speed | Medium | Fast |
+| Quality | High | Medium-High |
+| Pitch Control | ❌ No | ✅ Yes |
+| Model Size | ~500MB | ~10-50MB per voice |
+| Memory Usage | Higher | Lower |
+| Voice Variety | 10+ voices | 5+ voices (expandable) |
+| Languages | 4 languages | English (more available) |
+
+## Troubleshooting
+
+### Piper Not Found
+
+**Error:** `piper: command not found`
+
+**Solution:**
+```bash
+# Check if piper is in PATH
+which piper
+
+# If not found, reinstall
+./install_piper.sh
+
+# Or add to PATH manually
+export PATH="/usr/local/bin:$PATH"
+```
+
+### Voice Model Download Fails
+
+**Error:** Model download timeout or failure
+
+**Solution:**
+1. Check internet connection
+2. Manually download models from [Piper releases](https://github.com/rhasspy/piper/releases)
+3. Place `.onnx` and `.onnx.json` files in `backend/piper_models/`
+
+### Audio Quality Issues
+
+**Problem:** Distorted or robotic audio
+
+**Solutions:**
+- Reduce pitch shift amount (stay within ±6 semitones)
+- Try different voice models
+- Adjust speed (try 0.9 or 1.1)
+- Check for text formatting issues
+
+### Synthesis Timeout
+
+**Error:** Piper synthesis times out
+
+**Solutions:**
+- Break text into smaller chunks
+- Increase timeout in `piper_tts_service.py`
+- Check system resources (CPU, memory)
+
+## Advanced Configuration
+
+### Custom Voice Models
+
+To add custom Piper voice models:
+
+1. Download `.onnx` and `.onnx.json` files
+2. Place in `backend/piper_models/`
+3. Update `AVAILABLE_VOICES` in `piper_tts_service.py`:
+
+```python
+AVAILABLE_VOICES = {
+    "en_US-custom-voice": {"lang": "en", "gender": "female", "quality": "high"},
+    # ... existing voices
+}
+```
+
+### Adjusting Audio Effects
+
+Modify `_apply_audio_effects()` in `piper_tts_service.py` to customize:
+- Pitch shifting algorithm
+- Speed adjustment method
+- Audio processing pipeline
+
+## Best Practices
+
+1. **Voice Selection**
+   - Use distinct voices for different characters
+   - Match voice gender to character when possible
+   - Use British voices for variety
+
+2. **Pitch Adjustments**
+   - Start with small adjustments (±2-3 semitones)
+   - Test and iterate to find natural-sounding values
+   - Avoid extreme values (±10+) unless intentional
+
+3. **Performance**
+   - Pre-download voice models for faster first use
+   - Cache generated audio when possible
+   - Use appropriate chunk sizes for long texts
+
+4. **Quality**
+   - Use high-quality voice models when available
+   - Adjust speed slightly (0.95-1.05) for more natural pacing
+   - Combine with AI segmentation for best results
+
+## Resources
+
+- [Piper GitHub Repository](https://github.com/rhasspy/piper)
+- [Piper Voice Samples](https://rhasspy.github.io/piper-samples/)
+- [Voice Model Downloads](https://github.com/rhasspy/piper/releases/tag/v1.2.0)
+- [Piper Documentation](https://github.com/rhasspy/piper/blob/master/README.md)
+
+## License
+
+Piper TTS is licensed under the MIT License.

backend/README.md

@@ -13,6 +13,7 @@ The backend provides REST API endpoints for:
 
 - Python 3.10 or higher
 - espeak-ng (system dependency for grapheme-to-phoneme conversion)
+- Piper TTS (optional, for alternative TTS engine with pitch control)
 - Docker (optional, for containerized deployment)
 
 ## Local Development Setup
@@ -62,7 +63,78 @@ pip install --upgrade pip
 pip install -r requirements.txt
 ```
 
-### 3. Environment Configuration
+### 3. Piper TTS Setup (Optional)
+
+For an alternative TTS engine with pitch control support:
+
+**Installation:**
+```bash
+# Run the installation script
+./install_piper.sh
+```
+
+Or install manually:
+- Visit [Piper releases](https://github.com/rhasspy/piper/releases)
+- Download the appropriate binary for your platform
+- Extract and place in your PATH
+
+**Verify installation:**
+```bash
+piper --version
+```
+
+**Download Voice Models:**
+
+Piper requires manual voice model download. See [PIPER_SETUP.md](PIPER_SETUP.md) for detailed instructions.
+
+Quick steps:
+1. Visit https://github.com/rhasspy/piper/releases/tag/v1.2.0
+2. Download voice models (e.g., `en_US-lessac-medium.onnx` and `.onnx.json`)
+3. Place in `backend/piper_models/` directory
+
+**Benefits of Piper TTS:**
+- ✨ Pitch shifting support (-12 to +12 semitones per role)
+- ✨ Fast, lightweight neural TTS
+- ✨ Multiple voice models available
+- ✨ Lower resource usage than Kokoro
+
+### 4. Ollama Setup (Optional but Recommended)
+
+For AI-powered speaker detection and text segmentation, install Ollama:
+
+**Installation:**
+- Visit [ollama.com](https://ollama.com) and download for your platform
+- Or use package managers:
+  ```bash
+  # macOS
+  brew install ollama
+  
+  # Linux
+  curl -fsSL https://ollama.com/install.sh | sh
+  ```
+
+**Pull the required model:**
+```bash
+ollama pull llama3
+```
+
+**Start Ollama service:**
+```bash
+ollama serve
+```
+
+Verify Ollama is running:
+```bash
+curl http://localhost:11434/api/tags
+```
+
+**Benefits of using Ollama:**
+- ✨ Intelligently detects speakers in unmarked text
+- ✨ Automatically segments dialogue and assigns to correct characters
+- ✨ Handles narrative text without explicit role markers
+- ✨ Falls back to pattern matching if unavailable
+
+### 5. Environment Configuration
 
 ```bash
 cp .env.example .env
@@ -72,9 +144,11 @@ Edit `.env` if needed:
 ```bash
 PORT=8000
 LOG_LEVEL=info
+OLLAMA_BASE_URL=http://localhost:11434  # Optional: Ollama API URL
+TTS_ENGINE=kokoro  # Options: kokoro, piper (default: kokoro)
 ```
 
-### 4. Run the Server
+### 6. Run the Server
 
 ```bash
 uvicorn main:app --reload --host 0.0.0.0 --port 8000
@@ -142,6 +216,43 @@ The Dockerfile includes:
 - Storage: ~500MB for Kokoro models
 - CPU: Multi-core recommended
 
+## TTS Engine Selection
+
+The backend now supports multiple TTS engines that can be selected at runtime:
+
+### Available Engines
+
+1. **Kokoro TTS** (default)
+   - High-quality neural TTS
+   - Multiple voices per language
+   - No pitch control
+   - ~500MB model size
+
+2. **Piper TTS**
+   - Fast, lightweight neural TTS
+   - Pitch shifting support (-12 to +12 semitones)
+   - Multiple voice models
+   - Lower resource usage
+
+### Switching Engines
+
+**Via Environment Variable:**
+```bash
+export TTS_ENGINE=piper  # or kokoro
+uvicorn main:app --reload
+```
+
+**Via API:**
+```bash
+# Get available engines
+curl http://localhost:8000/api/tts/engines
+
+# Set active engine
+curl -X POST http://localhost:8000/api/tts/engines \
+  -H "Content-Type: application/json" \
+  -d '{"engine": "piper"}'
+```
+
 ## API Endpoints
 
 ### GET /api/health
@@ -162,7 +273,10 @@ curl http://localhost:8000/api/health
 
 ### POST /api/tts/roles
 
-Detect distinct roles/speakers in text.
+Detect distinct roles/speakers in text using AI-powered detection.
+
+**AI-Powered Detection:**
+When Ollama is available, the system uses AI (llama3) to intelligently detect speakers in unmarked text. This allows you to input plain narrative text without explicit role markers, and the AI will identify all characters and speakers.
 
 **Request Body:**
 ```json
@@ -182,20 +296,101 @@ Detect distinct roles/speakers in text.
 }
 ```
 
-**Supported Role Patterns:**
+**Detection Methods:**
-- Colon pattern: `RoleName: dialogue text`
+1. **AI Detection (Primary)**: Uses Ollama with llama3 to intelligently identify speakers in unmarked text
-- Bracket pattern: `[RoleName] dialogue text`
+   - Example: "The wizard spoke softly. The knight replied." → Detects "Wizard" and "Knight"
+2. **Pattern Matching (Fallback)**: Falls back to pattern-based detection if Ollama unavailable
+   - Colon pattern: `RoleName: dialogue text`
+   - Bracket pattern: `[RoleName] dialogue text`
 
-**Example:**
+**Example with AI Detection:**
+```bash
+curl -X POST http://localhost:8000/api/tts/roles \
+  -H "Content-Type: application/json" \
+  -d '{"text":"The wizard gazed into his crystal ball. The knight drew his sword."}'
+```
+
+**Example with Pattern Markers:**
 ```bash
 curl -X POST http://localhost:8000/api/tts/roles \
   -H "Content-Type: application/json" \
   -d '{"text":"Alice: Hello!\nBob: Hi there!"}'
 ```
 
+### GET /api/tts/engines
+
+Get list of available TTS engines and current selection.
+
+**Response:**
+```json
+{
+  "engines": [
+    {"name": "kokoro", "active": true},
+    {"name": "piper", "active": false}
+  ],
+  "current": "kokoro"
+}
+```
+
+**Example:**
+```bash
+curl http://localhost:8000/api/tts/engines
+```
+
+### POST /api/tts/engines
+
+Set the active TTS engine.
+
+**Request Body:**
+```json
+{
+  "engine": "piper"
+}
+```
+
+**Response:**
+```json
+{
+  "status": "ok",
+  "engine": "piper"
+}
+```
+
+**Example:**
+```bash
+curl -X POST http://localhost:8000/api/tts/engines \
+  -H "Content-Type: application/json" \
+  -d '{"engine": "piper"}'
+```
+
+### GET /api/tts/voices
+
+Get available voices for all TTS engines.
+
+**Response:**
+```json
+{
+  "voices": {
+    "kokoro": ["af_bella", "af_sarah", "am_adam", "am_michael", ...],
+    "piper": ["en_US-lessac-medium", "en_US-amy-medium", ...]
+  }
+}
+```
+
+**Example:**
+```bash
+curl http://localhost:8000/api/tts/voices
+```
+
 ### POST /api/tts
 
-Generate multi-voice audiobook.
+Generate multi-voice audiobook with AI-powered text segmentation.
+
+**AI-Powered Segmentation:**
+When Ollama is available, the system uses AI to intelligently split text and assign each segment to the appropriate speaker. This means you can input plain narrative text, and the AI will automatically:
+- Assign dialogue to the correct character
+- Assign narrative descriptions to the Narrator
+- Handle mixed dialogue and narration seamlessly
 
 **Request Body:**
 ```json
@@ -211,17 +406,26 @@ Generate multi-voice audiobook.
 ```
 
 **Parameters:**
-- `text` (required): Text to synthesize
+- `text` (required): Text to synthesize (can be plain narrative or marked with role patterns)
 - `lang` (required): Language code (a=American English, b=British English, f=French, j=Japanese)
 - `roles` (required): Array of role-to-voice mappings
 - `speed` (optional): Playback speed (0.5-1.5, default: 1.0)
+- `pitch_adjustments` (optional): Array of role-to-pitch mappings (Piper only, -12 to +12 semitones)
 
 **Response:**
 - Content-Type: `audio/wav`
+- Content-Disposition: `attachment; filename=audiobook.wav`
+
+**Segmentation Methods:**
+1. **AI Segmentation (Primary)**: Uses Ollama to intelligently split text and assign speakers
+   - Handles unmarked dialogue and narrative
+   - Automatically assigns dialogue to characters and descriptions to Narrator
+2. **Pattern Segmentation (Fallback)**: Uses explicit role markers when AI unavailable
+   - Requires `RoleName:` or `[RoleName]` markers in text
 - Content-Disposition: `attachment; filename="audiobook.wav"`
 - Body: Audio file bytes
 
-**Example:**
+**Example (Kokoro):**
 ```bash
 curl -X POST http://localhost:8000/api/tts \
   -H "Content-Type: application/json" \
@@ -237,6 +441,26 @@ curl -X POST http://localhost:8000/api/tts \
   --output audiobook.wav
 ```
 
+**Example (Piper with pitch control):**
+```bash
+curl -X POST http://localhost:8000/api/tts \
+  -H "Content-Type: application/json" \
+  -d '{
+    "text": "Alice: Hello!\nBob: Hi!",
+    "lang": "a",
+    "roles": [
+      {"id": "Alice", "voice": "en_US-amy-medium"},
+      {"id": "Bob", "voice": "en_US-lessac-medium"}
+    ],
+    "speed": 1.0,
+    "pitch_adjustments": [
+      {"id": "Alice", "pitch": 3},
+      {"id": "Bob", "pitch": -2}
+    ]
+  }' \
+  --output audiobook.wav
+```
+
 ## Kokoro TTS Configuration
 
 ### Supported Languages

backend/check_voices.py

@@ -0,0 +1,10 @@
+#!/usr/bin/env python3
+"""Check available Kokoro TTS voices."""
+from kokoro import VOICE_NAMES
+
+print("Available Kokoro TTS voices:")
+print("=" * 50)
+for voice in sorted(VOICE_NAMES):
+    print(f"  {voice}")
+print("=" * 50)
+print(f"Total: {len(VOICE_NAMES)} voices")

backend/download_piper_voices.py

@@ -0,0 +1,219 @@
+#!/usr/bin/env python3
+"""
+Simple script to download Piper TTS voice models.
+"""
+import os
+import sys
+import urllib.request
+import ssl
+
+# Create SSL context that doesn't verify (for development)
+ssl_context = ssl.create_default_context()
+ssl_context.check_hostname = False
+ssl_context.verify_mode = ssl.CERT_NONE
+
+# Models directory
+SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
+MODELS_DIR = os.path.join(SCRIPT_DIR, "piper_models")
+os.makedirs(MODELS_DIR, exist_ok=True)
+
+# Available voices with direct download links
+VOICES = {
+    "1": {
+        "name": "en_US-lessac-medium",
+        "description": "Male, American, Medium Quality",
+        "model_url": "https://huggingface.co/rhasspy/piper-voices/resolve/v1.0.0/en/en_US/en_US-lessac-medium.onnx",
+        "config_url": "https://huggingface.co/rhasspy/piper-voices/resolve/v1.0.0/en/en_US/en_US-lessac-medium.onnx.json",
+    },
+    "2": {
+        "name": "en_US-amy-medium",
+        "description": "Female, American, Medium Quality",
+        "model_url": "https://huggingface.co/rhasspy/piper-voices/resolve/v1.0.0/en/en_US/en_US-amy-medium.onnx",
+        "config_url": "https://huggingface.co/rhasspy/piper-voices/resolve/v1.0.0/en/en_US/en_US-amy-medium.onnx.json",
+    },
+    "3": {
+        "name": "en_US-libritts-high",
+        "description": "Neutral, American, High Quality",
+        "model_url": "https://huggingface.co/rhasspy/piper-voices/resolve/v1.0.0/en/en_US/en_US-libritts-high.onnx",
+        "config_url": "https://huggingface.co/rhasspy/piper-voices/resolve/v1.0.0/en/en_US/en_US-libritts-high.onnx.json",
+    },
+    "4": {
+        "name": "en_GB-alan-medium",
+        "description": "Male, British, Medium Quality",
+        "model_url": "https://huggingface.co/rhasspy/piper-voices/resolve/v1.0.0/en/en_GB/en_GB-alan-medium.onnx",
+        "config_url": "https://huggingface.co/rhasspy/piper-voices/resolve/v1.0.0/en/en_GB/en_GB-alan-medium.onnx.json",
+    },
+    "5": {
+        "name": "en_GB-alba-medium",
+        "description": "Female, British, Medium Quality",
+        "model_url": "https://huggingface.co/rhasspy/piper-voices/resolve/v1.0.0/en/en_GB/en_GB-alba-medium.onnx",
+        "config_url": "https://huggingface.co/rhasspy/piper-voices/resolve/v1.0.0/en/en_GB/en_GB-alba-medium.onnx.json",
+    },
+}
+
+
+def download_file(url, dest_path):
+    """Download a file with progress indication."""
+    try:
+        print(f"    Downloading from: {url}")
+        
+        # Use urllib with SSL context
+        with urllib.request.urlopen(url, context=ssl_context, timeout=120) as response:
+            total_size = int(response.headers.get('content-length', 0))
+            
+            with open(dest_path, 'wb') as f:
+                downloaded = 0
+                chunk_size = 8192
+                
+                while True:
+                    chunk = response.read(chunk_size)
+                    if not chunk:
+                        break
+                    
+                    f.write(chunk)
+                    downloaded += len(chunk)
+                    
+                    if total_size > 0:
+                        percent = (downloaded / total_size) * 100
+                        print(f"\r    Progress: {percent:.1f}% ({downloaded}/{total_size} bytes)", end='')
+        
+        print()  # New line after progress
+        
+        # Verify file size
+        file_size = os.path.getsize(dest_path)
+        if file_size < 1000:
+            print(f"    ✗ Download failed (file too small: {file_size} bytes)")
+            os.remove(dest_path)
+            return False
+        
+        print(f"    ✓ Downloaded: {file_size:,} bytes")
+        return True
+        
+    except Exception as e:
+        print(f"    ✗ Error: {e}")
+        if os.path.exists(dest_path):
+            os.remove(dest_path)
+        return False
+
+
+def download_voice(voice_key):
+    """Download a voice model and config."""
+    voice = VOICES[voice_key]
+    name = voice["name"]
+    
+    model_path = os.path.join(MODELS_DIR, f"{name}.onnx")
+    config_path = os.path.join(MODELS_DIR, f"{name}.onnx.json")
+    
+    # Check if already exists
+    if os.path.exists(model_path) and os.path.exists(config_path):
+        print(f"  ✓ {name} - Already downloaded")
+        return True
+    
+    print(f"\n  Downloading: {name}")
+    print(f"  Description: {voice['description']}")
+    
+    # Download model
+    print("  [1/2] Model file (.onnx)...")
+    if not download_file(voice["model_url"], model_path):
+        return False
+    
+    # Download config
+    print("  [2/2] Config file (.onnx.json)...")
+    if not download_file(voice["config_url"], config_path):
+        return False
+    
+    print(f"  ✓ {name} - Complete!")
+    return True
+
+
+def main():
+    print("=" * 60)
+    print("Piper TTS Voice Model Downloader")
+    print("=" * 60)
+    print(f"\nModels directory: {MODELS_DIR}\n")
+    
+    print("Available voices:\n")
+    for key, voice in VOICES.items():
+        print(f"  {key}) {voice['name']}")
+        print(f"     {voice['description']}")
+        print()
+    
+    print("Quick options:")
+    print("  a) Download all voices (recommended)")
+    print("  s) Download starter pack (1, 2, 4)")
+    print("  q) Quit")
+    print()
+    
+    choice = input("Enter your choice (1-5, a, s, or q): ").strip().lower()
+    
+    if choice == 'q':
+        print("Exiting...")
+        return
+    
+    print("\n" + "=" * 60)
+    print("Downloading...")
+    print("=" * 60)
+    
+    success_count = 0
+    total_count = 0
+    
+    if choice == 'a':
+        # Download all
+        for key in VOICES.keys():
+            total_count += 1
+            if download_voice(key):
+                success_count += 1
+    elif choice == 's':
+        # Starter pack
+        for key in ['1', '2', '4']:
+            total_count += 1
+            if download_voice(key):
+                success_count += 1
+    elif choice in VOICES:
+        # Single voice
+        total_count += 1
+        if download_voice(choice):
+            success_count += 1
+    else:
+        print(f"Invalid choice: {choice}")
+        return
+    
+    print("\n" + "=" * 60)
+    print("Download Summary")
+    print("=" * 60)
+    print(f"\nSuccessfully downloaded: {success_count}/{total_count} voices")
+    
+    # List downloaded files
+    print(f"\nFiles in {MODELS_DIR}:")
+    try:
+        files = sorted(os.listdir(MODELS_DIR))
+        if files:
+            for f in files:
+                size = os.path.getsize(os.path.join(MODELS_DIR, f))
+                print(f"  {f} ({size:,} bytes)")
+        else:
+            print("  (empty)")
+    except Exception as e:
+        print(f"  Error listing files: {e}")
+    
+    print("\n" + "=" * 60)
+    print("Next Steps")
+    print("=" * 60)
+    print("\n1. Test Piper installation:")
+    print("   python test_piper_direct.py")
+    print("\n2. Start the backend:")
+    print("   uvicorn main:app --reload")
+    print("\n3. In the UI, click 'Piper TTS' button")
+    print("\n4. Select a Piper voice and generate!")
+    print()
+
+
+if __name__ == "__main__":
+    try:
+        main()
+    except KeyboardInterrupt:
+        print("\n\nDownload cancelled by user.")
+        sys.exit(1)
+    except Exception as e:
+        print(f"\n\nError: {e}")
+        sys.exit(1)

backend/download_piper_voices.sh

@@ -0,0 +1,149 @@
+#!/bin/bash
+# Helper script to download Piper TTS voice models
+
+set -e
+
+echo "=================================================="
+echo "Piper TTS Voice Model Downloader"
+echo "=================================================="
+echo ""
+
+# Create models directory
+MODELS_DIR="$(dirname "$0")/piper_models"
+mkdir -p "$MODELS_DIR"
+echo "✓ Models directory: $MODELS_DIR"
+echo ""
+
+# Base URL for Piper voices
+BASE_URL="https://huggingface.co/rhasspy/piper-voices/resolve/main"
+
+# Function to download a voice
+download_voice() {
+    local voice_id=$1
+    local lang_code=$2
+    
+    echo "Downloading $voice_id..."
+    
+    # Construct URLs
+    local model_url="${BASE_URL}/${lang_code}/${lang_code}_${voice_id}.onnx"
+    local config_url="${BASE_URL}/${lang_code}/${lang_code}_${voice_id}.onnx.json"
+    
+    local model_file="${MODELS_DIR}/${lang_code}-${voice_id}.onnx"
+    local config_file="${MODELS_DIR}/${lang_code}-${voice_id}.onnx.json"
+    
+    # Check if already exists
+    if [ -f "$model_file" ] && [ -f "$config_file" ]; then
+        echo "  ✓ Already downloaded"
+        return 0
+    fi
+    
+    # Download with curl
+    if command -v curl &> /dev/null; then
+        echo "  Downloading model file..."
+        curl -L -o "$model_file" "$model_url" 2>/dev/null || {
+            echo "  ✗ Failed to download model"
+            return 1
+        }
+        
+        echo "  Downloading config file..."
+        curl -L -o "$config_file" "$config_url" 2>/dev/null || {
+            echo "  ✗ Failed to download config"
+            return 1
+        }
+        
+        # Verify files are not error pages
+        if [ $(wc -c < "$model_file") -lt 1000 ]; then
+            echo "  ✗ Download failed (file too small)"
+            rm -f "$model_file" "$config_file"
+            return 1
+        fi
+        
+        echo "  ✓ Downloaded successfully"
+        return 0
+    else
+        echo "  ✗ curl not found"
+        return 1
+    fi
+}
+
+echo "Select voices to download:"
+echo ""
+echo "Recommended starter pack (3 voices):"
+echo "  1) en_US-lessac-medium (Male, American)"
+echo "  2) en_US-amy-medium (Female, American)"
+echo "  3) en_GB-alan-medium (Male, British)"
+echo ""
+echo "All English voices (5 voices):"
+echo "  4) All of the above + 2 more"
+echo ""
+echo "Manual selection:"
+echo "  5) Choose specific voices"
+echo ""
+echo "  0) Exit"
+echo ""
+read -p "Enter your choice (0-5): " choice
+
+case $choice in
+    1)
+        echo ""
+        echo "Downloading starter pack..."
+        echo ""
+        download_voice "lessac-medium" "en_US"
+        download_voice "amy-medium" "en_US"
+        download_voice "alan-medium" "en_GB"
+        ;;
+    2)
+        echo ""
+        echo "Downloading all English voices..."
+        echo ""
+        download_voice "lessac-medium" "en_US"
+        download_voice "amy-medium" "en_US"
+        download_voice "libritts-high" "en_US"
+        download_voice "alan-medium" "en_GB"
+        download_voice "alba-medium" "en_GB"
+        ;;
+    3)
+        echo ""
+        echo "Available voices:"
+        echo "  en_US-lessac-medium (Male, American)"
+        echo "  en_US-amy-medium (Female, American)"
+        echo "  en_US-libritts-high (Neutral, American, High Quality)"
+        echo "  en_GB-alan-medium (Male, British)"
+        echo "  en_GB-alba-medium (Female, British)"
+        echo ""
+        echo "Enter voice IDs separated by spaces (e.g., lessac-medium amy-medium):"
+        read -p "> " voices
+        
+        for voice in $voices; do
+            if [[ $voice == *"GB"* ]]; then
+                download_voice "$voice" "en_GB"
+            else
+                download_voice "$voice" "en_US"
+            fi
+        done
+        ;;
+    0)
+        echo "Exiting..."
+        exit 0
+        ;;
+    *)
+        echo "Invalid choice"
+        exit 1
+        ;;
+esac
+
+echo ""
+echo "=================================================="
+echo "Download Summary"
+echo "=================================================="
+echo ""
+echo "Downloaded files in: $MODELS_DIR"
+ls -lh "$MODELS_DIR" 2>/dev/null || echo "No files found"
+echo ""
+echo "✓ Setup complete!"
+echo ""
+echo "Next steps:"
+echo "  1. Test Piper: python test_piper_direct.py"
+echo "  2. Start backend: uvicorn main:app --reload"
+echo "  3. Select 'Piper TTS' in the UI"
+echo ""

backend/install_piper.sh

@@ -0,0 +1,67 @@
+#!/bin/bash
+# Script to install Piper TTS
+
+echo "Installing Piper TTS..."
+
+# Detect OS
+OS="$(uname -s)"
+ARCH="$(uname -m)"
+
+case "${OS}" in
+    Linux*)
+        if [ "${ARCH}" = "x86_64" ]; then
+            PIPER_URL="https://github.com/rhasspy/piper/releases/download/v1.2.0/piper_amd64.tar.gz"
+        elif [ "${ARCH}" = "aarch64" ]; then
+            PIPER_URL="https://github.com/rhasspy/piper/releases/download/v1.2.0/piper_arm64.tar.gz"
+        else
+            echo "Unsupported architecture: ${ARCH}"
+            exit 1
+        fi
+        ;;
+    Darwin*)
+        if [ "${ARCH}" = "x86_64" ] || [ "${ARCH}" = "arm64" ]; then
+            PIPER_URL="https://github.com/rhasspy/piper/releases/download/v1.2.0/piper_macos_x64.tar.gz"
+        else
+            echo "Unsupported architecture: ${ARCH}"
+            exit 1
+        fi
+        ;;
+    *)
+        echo "Unsupported OS: ${OS}"
+        exit 1
+        ;;
+esac
+
+# Create temp directory
+TEMP_DIR=$(mktemp -d)
+cd "${TEMP_DIR}"
+
+# Download Piper
+echo "Downloading Piper from ${PIPER_URL}..."
+curl -L -o piper.tar.gz "${PIPER_URL}"
+
+# Extract
+echo "Extracting..."
+tar -xzf piper.tar.gz
+
+# Install to /usr/local/bin (requires sudo)
+echo "Installing to /usr/local/bin (may require password)..."
+sudo cp piper/piper /usr/local/bin/
+sudo chmod +x /usr/local/bin/piper
+
+# Cleanup
+cd -
+rm -rf "${TEMP_DIR}"
+
+# Verify installation
+if command -v piper &> /dev/null; then
+    echo "✓ Piper TTS installed successfully!"
+    piper --version
+else
+    echo "✗ Installation failed"
+    exit 1
+fi
+
+echo ""
+echo "To download voice models, they will be automatically downloaded on first use."
+echo "Or you can manually download from: https://github.com/rhasspy/piper/releases/tag/v1.2.0"

backend/main.py

@@ -11,7 +11,7 @@ from pydantic import BaseModel, Field
 
 # Import services
 from services.role_detector import RoleDetector
-from services.tts_service import TTSService
+from services.unified_tts_service import UnifiedTTSService
 
 # Configure logging
 logging.basicConfig(
@@ -34,17 +34,46 @@ class RolesResponse(BaseModel):
     """Response model for role detection endpoint."""
     roles: List[RoleInfo] = Field(..., description="List of detected roles")
 
+class ScriptSegment(BaseModel):
+    """Model representing a script segment with speaker assignment."""
+    id: str = Field(..., description="Unique segment identifier")
+    speaker: str = Field(..., description="Assigned speaker/role")
+    text: str = Field(..., description="Text content for this segment")
+
+class ScriptRequest(BaseModel):
+    """Request model for script generation endpoint."""
+    text: str = Field(..., description="Text to segment and analyze")
+    roles: List[str] = Field(..., description="List of detected role IDs")
+
+class ScriptResponse(BaseModel):
+    """Response model for script generation endpoint."""
+    segments: List[ScriptSegment] = Field(..., description="List of script segments with speaker assignments")
+
 class RoleVoiceMapping(BaseModel):
     """Model for role-to-voice mapping."""
     id: str = Field(..., description="Role identifier")
     voice: str = Field(..., description="Kokoro voice ID")
 
+class RolePitchMapping(BaseModel):
+    """Model for role-to-pitch mapping."""
+    id: str = Field(..., description="Role identifier")
+    pitch: int = Field(0, description="Pitch shift in semitones (-12 to +12)")
+
 class TTSRequest(BaseModel):
     """Request model for TTS generation endpoint."""
-    text: str = Field(..., description="Text to convert to speech")
+    segments: Optional[List[ScriptSegment]] = Field(None, description="Optional edited script segments")
+    text: Optional[str] = Field(None, description="Text to convert to speech (used if segments not provided)")
     lang: str = Field(..., description="Language code (a, b, f, j)")
     roles: List[RoleVoiceMapping] = Field(..., description="Role to voice mappings")
     speed: Optional[float] = Field(1.0, description="Playback speed (0.5-1.5)")
+    pitch_adjustments: Optional[List[RolePitchMapping]] = Field(None, description="Optional pitch adjustments per role (Piper only)")
+
+class VoicePreviewRequest(BaseModel):
+    """Request model for voice preview endpoint."""
+    voice: str = Field(..., description="Kokoro voice ID to preview")
+    lang: str = Field(..., description="Language code (a, b, f, j)")
+    speed: Optional[float] = Field(1.0, description="Playback speed (0.5-1.5)")
+    text: Optional[str] = Field(None, description="Custom text to preview (uses default if not provided)")
 
 class ErrorResponse(BaseModel):
     """Standard error response model."""
@@ -52,6 +81,24 @@ class ErrorResponse(BaseModel):
     message: str = Field(..., description="Human-readable error message")
     details: Optional[dict] = Field(None, description="Additional error details")
 
+class EngineInfo(BaseModel):
+    """Model for TTS engine information."""
+    name: str = Field(..., description="Engine identifier")
+    active: bool = Field(..., description="Whether this engine is currently active")
+
+class EnginesResponse(BaseModel):
+    """Response model for available engines."""
+    engines: List[EngineInfo] = Field(..., description="List of available TTS engines")
+    current: str = Field(..., description="Currently active engine")
+
+class SetEngineRequest(BaseModel):
+    """Request model for setting TTS engine."""
+    engine: str = Field(..., description="Engine to activate (kokoro or piper)")
+
+class VoicesResponse(BaseModel):
+    """Response model for available voices."""
+    voices: dict = Field(..., description="Dict mapping engine names to voice lists")
+
 # Initialize FastAPI app
 app = FastAPI(
     title="Text to Audiobook API",
@@ -62,7 +109,7 @@ app = FastAPI(
 # Configure CORS
 app.add_middleware(
     CORSMiddleware,
-    allow_origins=["http://localhost:5173", "http://localhost:3000"],
+    allow_origins=["http://localhost:5173", "http://localhost:5174", "http://localhost:3000"],
     allow_credentials=True,
     allow_methods=["*"],
     allow_headers=["*"],
@@ -97,7 +144,7 @@ async def general_exception_handler(request: Request, exc: Exception):
 
 # Initialize services
 role_detector = RoleDetector()
-tts_service = TTSService()
+tts_service = UnifiedTTSService()
 
 # API Endpoints
 @app.get("/api/health")
@@ -106,11 +153,87 @@ async def health_check():
     logger.info("Health check requested")
     return {"status": "ok"}
 
+@app.get("/api/tts/engines", response_model=EnginesResponse)
+async def get_engines():
+    """
+    Get list of available TTS engines and current selection.
+    
+    Returns:
+        EnginesResponse with list of engines and current active engine
+    """
+    logger.info("Engines list requested")
+    
+    try:
+        available = tts_service.get_available_engines()
+        current = tts_service.engine_name
+        
+        engines = [
+            EngineInfo(name=engine, active=(engine == current))
+            for engine in available
+        ]
+        
+        return EnginesResponse(engines=engines, current=current)
+    except Exception as e:
+        logger.error(f"Error getting engines: {str(e)}", exc_info=True)
+        raise
+
+@app.post("/api/tts/engines")
+async def set_engine(request: SetEngineRequest):
+    """
+    Set the active TTS engine.
+    
+    Args:
+        request: SetEngineRequest with engine name
+        
+    Returns:
+        Success message with new engine
+        
+    Raises:
+        400: If engine name is invalid
+    """
+    logger.info(f"Engine change requested: {request.engine}")
+    
+    try:
+        tts_service.set_engine(request.engine)
+        return {"status": "ok", "engine": request.engine}
+    except ValueError as e:
+        logger.error(f"Invalid engine: {str(e)}")
+        return JSONResponse(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            content={
+                "error": "ValidationError",
+                "message": str(e),
+                "details": {"field": "engine"}
+            }
+        )
+    except Exception as e:
+        logger.error(f"Error setting engine: {str(e)}", exc_info=True)
+        raise
+
+@app.get("/api/tts/voices", response_model=VoicesResponse)
+async def get_voices():
+    """
+    Get available voices for all TTS engines.
+    
+    Returns:
+        VoicesResponse with dict mapping engine names to voice lists
+    """
+    logger.info("Voices list requested")
+    
+    try:
+        voices = tts_service.get_available_voices()
+        return VoicesResponse(voices=voices)
+    except Exception as e:
+        logger.error(f"Error getting voices: {str(e)}", exc_info=True)
+        raise
+
 @app.post("/api/tts/roles", response_model=RolesResponse)
 async def detect_roles(request: RoleDetectionRequest):
     """
     Analyzes text and returns detected speaker roles.
     
+    Uses AI-based detection (Ollama) first, then falls back to pattern matching.
+    
     Supports two pattern types:
     - Colon pattern: "RoleName:" at line start
     - Bracket pattern: "[RoleName]" preceding dialogue
@@ -120,13 +243,230 @@ async def detect_roles(request: RoleDetectionRequest):
     logger.info(f"Role detection requested for text of length {len(request.text)}")
     
     try:
-        roles = role_detector.detect_roles(request.text)
+        roles = await role_detector.detect_roles(request.text)
         logger.info(f"Detected {len(roles)} roles: {[r['label'] for r in roles]}")
         return RolesResponse(roles=roles)
     except Exception as e:
         logger.error(f"Error during role detection: {str(e)}", exc_info=True)
         raise
 
+@app.post("/api/tts/script", response_model=ScriptResponse)
+async def generate_script(request: ScriptRequest):
+    """
+    Generates script preview with AI-segmented text and speaker assignments.
+    
+    Uses AI (Ollama) to intelligently segment the text and assign speakers to each segment.
+    Falls back to pattern-based segmentation if AI is unavailable.
+    
+    Args:
+        request: ScriptRequest containing text and list of detected roles
+        
+    Returns:
+        ScriptResponse with list of segments, each containing id, speaker, and text
+        
+    Raises:
+        400: If validation fails (empty text or roles)
+        500: If script generation fails
+    """
+    logger.info(
+        f"Script generation requested for text of length {len(request.text)} "
+        f"with {len(request.roles)} roles"
+    )
+    
+    # Validate text is not empty
+    if not request.text or not request.text.strip():
+        logger.error("Empty text provided for script generation")
+        return JSONResponse(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            content={
+                "error": "ValidationError",
+                "message": "Text field cannot be empty",
+                "details": {"field": "text"}
+            }
+        )
+    
+    # Validate roles list is not empty
+    if not request.roles:
+        logger.error("No roles provided for script generation")
+        return JSONResponse(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            content={
+                "error": "ValidationError",
+                "message": "At least one role is required",
+                "details": {"field": "roles"}
+            }
+        )
+    
+    try:
+        # Generate script segments using TTS service
+        segments = await tts_service.generate_script_segments(
+            text=request.text,
+            roles=request.roles
+        )
+        
+        if not segments:
+            logger.warning("Script generation produced no segments")
+            return JSONResponse(
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                content={
+                    "error": "ScriptGenerationError",
+                    "message": "Failed to generate script segments",
+                    "details": {"reason": "No segments produced"}
+                }
+            )
+        
+        # Convert to response format with unique IDs
+        script_segments = [
+            ScriptSegment(
+                id=f"seg_{i}",
+                speaker=speaker,
+                text=text
+            )
+            for i, (speaker, text) in enumerate(segments)
+        ]
+        
+        logger.info(f"Generated script with {len(script_segments)} segments")
+        return ScriptResponse(segments=script_segments)
+        
+    except Exception as e:
+        logger.error(f"Error during script generation: {str(e)}", exc_info=True)
+        return JSONResponse(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            content={
+                "error": "ScriptGenerationError",
+                "message": "Failed to generate script",
+                "details": {"error": str(e)}
+            }
+        )
+
+@app.post("/api/tts/preview")
+async def preview_voice(request: VoicePreviewRequest):
+    """
+    Generates a short audio preview of a voice.
+    
+    Args:
+        request: VoicePreviewRequest containing voice ID, language, speed, and optional text
+        
+    Returns:
+        StreamingResponse with audio/wav content
+        
+    Raises:
+        400: If validation fails
+        500: If audio generation fails
+    """
+    logger.info(f"Voice preview requested: voice={request.voice}, lang={request.lang}, speed={request.speed}")
+    
+    # Validate language code
+    supported_langs = ['a', 'b', 'e', 'f', 'h', 'i', 'j', 'p', 'z']
+    if request.lang not in supported_langs:
+        logger.error(f"Invalid language code: {request.lang}")
+        return JSONResponse(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            content={
+                "error": "ValidationError",
+                "message": f"Invalid language code: {request.lang}",
+                "details": {"field": "lang", "supported": supported_langs}
+            }
+        )
+    
+    # Validate speed range
+    if request.speed < 0.5 or request.speed > 1.5:
+        logger.error(f"Invalid speed value: {request.speed}")
+        return JSONResponse(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            content={
+                "error": "ValidationError",
+                "message": "Speed must be between 0.5 and 1.5",
+                "details": {"field": "speed", "value": request.speed, "range": [0.5, 1.5]}
+            }
+        )
+    
+    # Use provided text or default preview text
+    preview_text = request.text or "Hello! This is a preview of this voice. How does it sound?"
+    
+    try:
+        import io
+        import soundfile as sf
+        import numpy as np
+        
+        # Check which engine is active
+        if tts_service.engine_name == 'kokoro':
+            # Use Kokoro service
+            pipeline = tts_service.kokoro_service.get_pipeline(request.lang)
+            audio = tts_service.kokoro_service.synthesize_segment(
+                pipeline=pipeline,
+                text=preview_text,
+                voice=request.voice,
+                speed=request.speed
+            )
+            sample_rate = tts_service.kokoro_service.SAMPLE_RATE
+            
+        elif tts_service.engine_name == 'piper':
+            # Use Piper service with pitch control
+            audio = tts_service.piper_service.synthesize_with_pitch(
+                text=preview_text,
+                voice=request.voice,
+                speed=request.speed,
+                pitch_shift=0  # No pitch shift for preview
+            )
+            sample_rate = tts_service.piper_service.SAMPLE_RATE
+            
+        else:
+            raise ValueError(f"Unknown engine: {tts_service.engine_name}")
+        
+        # Check if audio was generated
+        if audio is None or len(audio) == 0:
+            raise ValueError("No audio generated - voice model may be missing")
+        
+        # Convert to WAV bytes
+        buffer = io.BytesIO()
+        sf.write(buffer, audio, sample_rate, format='WAV')
+        buffer.seek(0)
+        audio_bytes = buffer.read()
+        
+        logger.info(f"Generated voice preview ({tts_service.engine_name}): {len(audio_bytes)} bytes")
+        
+        return StreamingResponse(
+            iter([audio_bytes]),
+            media_type="audio/wav",
+            headers={"Content-Disposition": "inline; filename=preview.wav"}
+        )
+    
+    except FileNotFoundError as e:
+        logger.error(f"Voice model not found: {str(e)}")
+        return JSONResponse(
+            status_code=status.HTTP_404_NOT_FOUND,
+            content={
+                "error": "VoiceModelNotFound",
+                "message": f"Voice model '{request.voice}' not found. Please download Piper voice models manually.",
+                "details": {
+                    "voice": request.voice,
+                    "engine": tts_service.engine_name,
+                    "setup_guide": "See backend/PIPER_SETUP.md for instructions"
+                }
+            }
+        )
+    except ValueError as e:
+        logger.error(f"Validation error during preview: {str(e)}")
+        return JSONResponse(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            content={
+                "error": "ValidationError",
+                "message": str(e),
+                "details": {"voice": request.voice, "engine": tts_service.engine_name}
+            }
+        )
+    except Exception as e:
+        logger.error(f"Error during voice preview: {str(e)}", exc_info=True)
+        return JSONResponse(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            content={
+                "error": "PreviewGenerationError",
+                "message": "Failed to generate voice preview",
+                "details": {"error": str(e)}
+            }
+        )
+
 @app.post("/api/tts")
 async def generate_audiobook(request: TTSRequest):
     """
@@ -147,11 +487,24 @@ async def generate_audiobook(request: TTSRequest):
     """
     logger.info(
         f"Audio generation requested: lang={request.lang}, "
-        f"roles={len(request.roles)}, speed={request.speed}"
+        f"roles={len(request.roles)}, speed={request.speed}, "
+        f"segments={len(request.segments) if request.segments else 0}"
     )
     
-    # Validate required fields (Pydantic handles basic validation)
+    # Validate that either segments or text is provided
-    if not request.text or not request.text.strip():
+    if not request.segments and not request.text:
+        logger.error("Neither segments nor text provided")
+        return JSONResponse(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            content={
+                "error": "ValidationError",
+                "message": "Either segments or text must be provided",
+                "details": {"fields": ["segments", "text"]}
+            }
+        )
+    
+    # Validate text if provided and no segments
+    if not request.segments and request.text and not request.text.strip():
         logger.error("Empty text provided")
         return JSONResponse(
             status_code=status.HTTP_400_BAD_REQUEST,
@@ -163,7 +516,7 @@ async def generate_audiobook(request: TTSRequest):
         )
     
     # Validate language code
-    supported_langs = ['a', 'b', 'f', 'j']
+    supported_langs = ['a', 'b', 'e', 'f', 'h', 'i', 'j', 'p', 'z']
     if request.lang not in supported_langs:
         logger.error(f"Invalid language code: {request.lang}")
         return JSONResponse(
@@ -209,14 +562,31 @@ async def generate_audiobook(request: TTSRequest):
     # Convert roles list to dictionary for TTS service
     role_voice_map = {role.id: role.voice for role in request.roles}
     
+    # Convert pitch adjustments to dictionary if provided
+    pitch_map = None
+    if request.pitch_adjustments:
+        pitch_map = {p.id: p.pitch for p in request.pitch_adjustments}
+    
     try:
-        # Generate audiobook
+        # Generate audiobook using segments if provided, otherwise use text
-        audio_bytes = await tts_service.generate_audiobook(
+        if request.segments:
-            text=request.text,
+            logger.info(f"Generating audiobook from {len(request.segments)} edited segments")
-            lang=request.lang,
+            audio_bytes = await tts_service.generate_audiobook_from_segments(
-            role_voice_map=role_voice_map,
+                segments=[(seg.speaker, seg.text) for seg in request.segments],
-            speed=request.speed
+                lang=request.lang,
-        )
+                role_voice_map=role_voice_map,
+                speed=request.speed,
+                pitch_adjustments=pitch_map
+            )
+        else:
+            logger.info("Generating audiobook from text with automatic segmentation")
+            audio_bytes = await tts_service.generate_audiobook(
+                text=request.text,
+                lang=request.lang,
+                role_voice_map=role_voice_map,
+                speed=request.speed,
+                pitch_adjustments=pitch_map
+            )
         
         # Create streaming response with proper headers
         return StreamingResponse(

backend/piper_models/en_US-lessac-medium.onnx

@@ -0,0 +1 @@
+Entry not found

backend/piper_models/en_US-lessac-medium.onnx.json

@@ -0,0 +1 @@
+Entry not found

backend/requirements.txt

@@ -5,3 +5,6 @@ soundfile==0.12.1
 python-multipart==0.0.6
 pydantic==2.5.3
 numpy==1.26.3
+httpx==0.26.0
+piper-tts==1.2.0
+pydub==0.25.1

backend/server.log

@@ -29,3 +29,27 @@ INFO:     127.0.0.1:53090 - "POST /api/tts HTTP/1.1" 400 Bad Request
 2025-12-09 01:20:19,494 - services.tts_service - INFO - Generated audiobook: 44 bytes
 WARNING: Defaulting repo_id to hexgrad/Kokoro-82M. Pass repo_id='hexgrad/Kokoro-82M' to suppress this warning.
 INFO:     127.0.0.1:53092 - "POST /api/tts HTTP/1.1" 200 OK
+INFO:     127.0.0.1:54291 - "OPTIONS /api/tts/roles HTTP/1.1" 200 OK
+2025-12-09 10:15:45,219 - main - INFO - Role detection requested for text of length 4
+2025-12-09 10:15:45,226 - main - INFO - Detected 1 roles: ['Narrator']
+INFO:     127.0.0.1:54291 - "POST /api/tts/roles HTTP/1.1" 200 OK
+INFO:     127.0.0.1:54296 - "OPTIONS /api/tts HTTP/1.1" 200 OK
+2025-12-09 10:15:51,949 - main - INFO - Audio generation requested: lang=a, roles=1, speed=1.0
+2025-12-09 10:15:51,953 - services.tts_service - INFO - Generating audiobook: lang=a, speed=1.0, roles=1
+2025-12-09 10:15:51,955 - services.tts_service - INFO - Segmented text into 1 segments
+Fatal Python error: init_sys_streams: can't initialize sys standard streams
+Python runtime state: core initialized
+OSError: [Errno 9] Bad file descriptor
+
+Current thread 0x00000001f799e080 (most recent call first):
+  <no Python frame>
+2025-12-09 10:15:55,293 - services.tts_service - INFO - Generated audiobook: 44 bytes
+INFO:     127.0.0.1:54296 - "POST /api/tts HTTP/1.1" 200 OK
+2025-12-09 10:16:52,356 - main - INFO - Role detection requested for text of length 40
+2025-12-09 10:16:52,358 - main - INFO - Detected 1 roles: ['Narrator']
+INFO:     127.0.0.1:54431 - "POST /api/tts/roles HTTP/1.1" 200 OK
+2025-12-09 10:17:02,016 - main - INFO - Audio generation requested: lang=a, roles=1, speed=1.0
+2025-12-09 10:17:02,017 - services.tts_service - INFO - Generating audiobook: lang=a, speed=1.0, roles=1
+2025-12-09 10:17:02,018 - services.tts_service - INFO - Segmented text into 1 segments
+2025-12-09 10:17:02,814 - services.tts_service - INFO - Generated audiobook: 44 bytes
+INFO:     127.0.0.1:54433 - "POST /api/tts HTTP/1.1" 200 OK

backend/services/ollama_service.py

@@ -0,0 +1,376 @@
+"""
+Ollama integration service for AI-based speaker detection and text segmentation.
+"""
+import json
+import logging
+import os
+from typing import List, Optional, Dict, Tuple
+import httpx
+
+
+logger = logging.getLogger(__name__)
+
+
+class OllamaService:
+    """
+    Service for integrating with Ollama API for AI-based speaker detection.
+    
+    Uses llama3:8b model to intelligently detect speakers in text without
+    explicit role markers.
+    """
+    
+    def __init__(self, base_url: Optional[str] = None):
+        """
+        Initializes Ollama service with base URL.
+        
+        Args:
+            base_url: Ollama API base URL. Defaults to OLLAMA_BASE_URL env var
+                     or http://localhost:11434 if not set.
+        """
+        self.base_url = base_url or os.getenv("OLLAMA_BASE_URL", "http://localhost:11434")
+        self.model = "llama3:latest"  # Using llama3:latest (8B model)
+        self.timeout = 30.0  # 30 seconds timeout
+        
+    async def detect_speakers(self, text: str) -> List[str]:
+        """
+        Sends text to Ollama for speaker detection.
+        Samples up to 4 chunks of 5000 characters from different parts of the text
+        to ensure comprehensive speaker detection in long texts.
+        
+        Args:
+            text: Input text to analyze for speakers
+            
+        Returns:
+            List of detected speaker names (deduplicated across all samples)
+            
+        Raises:
+            Exception: If Ollama is unavailable or request fails
+        """
+        # Get text samples from different parts of the text
+        samples = self._sample_text(text, chunk_size=5000, num_samples=4)
+        
+        all_speakers = set()
+        
+        try:
+            async with httpx.AsyncClient(timeout=self.timeout) as client:
+                # Process each sample
+                for i, sample in enumerate(samples):
+                    prompt = self._build_prompt(sample)
+                    
+                    logger.debug(f"Sending sample {i+1}/{len(samples)} to Ollama ({len(sample)} chars)")
+                    
+                    response = await client.post(
+                        f"{self.base_url}/api/generate",
+                        json={
+                            "model": self.model,
+                            "prompt": prompt,
+                            "stream": False,
+                            "format": "json"
+                        }
+                    )
+                    response.raise_for_status()
+                    
+                    result = response.json()
+                    response_text = result.get("response", "")
+                    
+                    speakers = self._parse_response(response_text)
+                    logger.info(f"Sample {i+1} detected {len(speakers)} speakers: {speakers}")
+                    
+                    # Add to our set (automatically deduplicates)
+                    all_speakers.update(speakers)
+                
+                speaker_list = sorted(list(all_speakers))
+                logger.info(f"Ollama detected {len(speaker_list)} total unique speakers: {speaker_list}")
+                return speaker_list
+                
+        except httpx.TimeoutException:
+            logger.warning("Ollama request timed out after 30 seconds")
+            raise Exception("Ollama request timed out")
+        except httpx.HTTPError as e:
+            logger.warning(f"Ollama HTTP error: {e}")
+            raise Exception(f"Ollama service error: {e}")
+        except Exception as e:
+            logger.warning(f"Ollama detection failed: {e}")
+            raise
+    
+    def _sample_text(self, text: str, chunk_size: int = 5000, num_samples: int = 4) -> List[str]:
+        """
+        Samples text from different parts to ensure comprehensive speaker detection.
+        
+        For short texts, returns the full text.
+        For long texts, samples from beginning, middle sections, and end.
+        
+        Args:
+            text: Input text to sample
+            chunk_size: Size of each sample in characters
+            num_samples: Number of samples to extract
+            
+        Returns:
+            List of text samples
+        """
+        text_len = len(text)
+        
+        # If text is shorter than one chunk, return it as-is
+        if text_len <= chunk_size:
+            return [text]
+        
+        # If text is shorter than what we'd sample, return fewer samples
+        max_possible_samples = (text_len // chunk_size) + 1
+        actual_samples = min(num_samples, max_possible_samples)
+        
+        samples = []
+        
+        if actual_samples == 1:
+            # Just take the beginning
+            samples.append(text[:chunk_size])
+        else:
+            # Distribute samples evenly across the text
+            step = text_len // actual_samples
+            
+            for i in range(actual_samples):
+                start = i * step
+                end = min(start + chunk_size, text_len)
+                samples.append(text[start:end])
+        
+        return samples
+    
+    def _build_prompt(self, text: str) -> str:
+        """
+        Constructs prompt for speaker detection.
+        
+        Instructs model to return JSON array of speaker names.
+        
+        Args:
+            text: Input text to analyze (should already be sampled/truncated)
+            
+        Returns:
+            Formatted prompt string
+        """
+        prompt = f"""Analyze the following text and identify all distinct speakers or characters who need voice assignments.
+
+CRITICAL: Look for TWO types of content:
+1. NARRATIVE TEXT: Descriptions, scene-setting, "he said", "she thought", etc. → This needs "Narrator"
+2. CHARACTER DIALOGUE: Direct speech by characters → These need character names
+
+You MUST include "Narrator" if there is ANY narrative text, descriptions, or non-dialogue content.
+
+Return ONLY a JSON object with a "speakers" array.
+
+Examples:
+- Text: "Alice said hello. Bob waved back." → {{"speakers": ["Narrator", "Alice", "Bob"]}}
+- Text: "Once upon a time, there was a princess." → {{"speakers": ["Narrator"]}}
+- Text: "The wizard spoke. 'I see danger,' he warned." → {{"speakers": ["Narrator"]}}
+- Text: "Alice: Hello! Bob: Hi there!" → {{"speakers": ["Alice", "Bob"]}}
+
+Text to analyze:
+{text}
+
+Return format: {{"speakers": ["Narrator", "Character1", "Character2", ...]}}
+"""
+        return prompt
+    
+    def _parse_response(self, response: str) -> List[str]:
+        """
+        Parses Ollama response to extract speaker names.
+        
+        Handles both JSON and plain text responses.
+        
+        Args:
+            response: Response text from Ollama
+            
+        Returns:
+            List of speaker names
+        """
+        if not response or not response.strip():
+            return []
+        
+        try:
+            # Try to parse as JSON
+            data = json.loads(response.strip())
+            
+            # Handle different possible JSON structures
+            if isinstance(data, dict):
+                if "speakers" in data:
+                    speakers = data["speakers"]
+                elif "characters" in data:
+                    speakers = data["characters"]
+                elif "roles" in data:
+                    speakers = data["roles"]
+                else:
+                    # Try to find any array in the response
+                    for value in data.values():
+                        if isinstance(value, list):
+                            speakers = value
+                            break
+                    else:
+                        return []
+            elif isinstance(data, list):
+                speakers = data
+            else:
+                return []
+            
+            # Ensure we have a list of strings
+            if isinstance(speakers, list):
+                return [str(s).strip() for s in speakers if s]
+            
+            return []
+            
+        except json.JSONDecodeError:
+            logger.warning(f"Failed to parse Ollama response as JSON: {response[:100]}")
+            # Try to extract speaker names from plain text
+            # Look for common patterns like lists or quoted names
+            return []
+    
+    async def segment_text(self, text: str, speakers: List[str]) -> List[Tuple[str, str]]:
+        """
+        Uses AI to segment text and assign each segment to a speaker.
+        
+        Args:
+            text: Input text to segment
+            speakers: List of known speakers in the text
+            
+        Returns:
+            List of tuples: (speaker_name, text_segment)
+            
+        Raises:
+            Exception: If Ollama is unavailable or request fails
+        """
+        try:
+            async with httpx.AsyncClient(timeout=60.0) as client:  # Longer timeout for segmentation
+                prompt = self._build_segmentation_prompt(text, speakers)
+                
+                logger.info(f"Requesting AI segmentation for {len(text)} chars with {len(speakers)} speakers")
+                
+                response = await client.post(
+                    f"{self.base_url}/api/generate",
+                    json={
+                        "model": self.model,
+                        "prompt": prompt,
+                        "stream": False,
+                        "format": "json"
+                    }
+                )
+                response.raise_for_status()
+                
+                result = response.json()
+                response_text = result.get("response", "")
+                
+                segments = self._parse_segmentation_response(response_text)
+                logger.info(f"AI segmentation produced {len(segments)} segments")
+                
+                return segments
+                
+        except httpx.TimeoutException:
+            logger.warning("Ollama segmentation request timed out")
+            raise Exception("Ollama segmentation timed out")
+        except httpx.HTTPError as e:
+            logger.warning(f"Ollama HTTP error during segmentation: {e}")
+            raise Exception(f"Ollama service error: {e}")
+        except Exception as e:
+            logger.warning(f"Ollama segmentation failed: {e}")
+            raise
+    
+    def _build_segmentation_prompt(self, text: str, speakers: List[str]) -> str:
+        """
+        Constructs prompt for text segmentation with speaker attribution.
+        
+        Args:
+            text: Input text to segment
+            speakers: List of known speakers
+            
+        Returns:
+            Formatted prompt string
+        """
+        speakers_str = ", ".join(f'"{s}"' for s in speakers)
+        
+        prompt = f"""You are analyzing a story or dialogue. Your task is to split the text into segments and assign each segment to the appropriate speaker.
+
+Known speakers: {speakers_str}
+
+Rules:
+1. Split the text into logical segments (sentences or short paragraphs)
+2. Assign each segment to the speaker who is speaking or being described
+3. Use "Narrator" for narrative text, descriptions, or text that doesn't belong to a specific character
+4. If a character is mentioned but not speaking, use "Narrator"
+5. Only use speakers from the known speakers list
+
+Return a JSON object with a "segments" array. Each segment should have:
+- "speaker": the name of the speaker (must be from the known speakers list or "Narrator")
+- "text": the text content for that segment
+
+Example format:
+{{
+  "segments": [
+    {{"speaker": "Narrator", "text": "The old wizard gazed into his crystal ball."}},
+    {{"speaker": "Wizard", "text": "I see danger approaching."}},
+    {{"speaker": "Narrator", "text": "A young knight heard the warning."}}
+  ]
+}}
+
+Text to segment:
+{text}
+
+Return ONLY the JSON object with the segments array.
+"""
+        return prompt
+    
+    def _parse_segmentation_response(self, response: str) -> List[Tuple[str, str]]:
+        """
+        Parses Ollama segmentation response to extract speaker-text pairs.
+        
+        Args:
+            response: Response text from Ollama
+            
+        Returns:
+            List of tuples: (speaker_name, text_content)
+        """
+        if not response or not response.strip():
+            return []
+        
+        try:
+            # Try to parse as JSON
+            data = json.loads(response.strip())
+            
+            # Extract segments array
+            segments_data = []
+            if isinstance(data, dict):
+                if "segments" in data:
+                    segments_data = data["segments"]
+                else:
+                    # Try to find any array in the response
+                    for value in data.values():
+                        if isinstance(value, list):
+                            segments_data = value
+                            break
+            elif isinstance(data, list):
+                segments_data = data
+            
+            # Convert to tuples
+            segments = []
+            for seg in segments_data:
+                if isinstance(seg, dict) and "speaker" in seg and "text" in seg:
+                    speaker = str(seg["speaker"]).strip()
+                    text = str(seg["text"]).strip()
+                    if speaker and text:
+                        segments.append((speaker, text))
+            
+            return segments
+            
+        except json.JSONDecodeError:
+            logger.warning(f"Failed to parse Ollama segmentation response as JSON: {response[:200]}")
+            return []
+    
+    async def is_available(self) -> bool:
+        """
+        Checks if Ollama service is available.
+        
+        Returns:
+            True if service responds to health check, False otherwise
+        """
+        try:
+            async with httpx.AsyncClient(timeout=5.0) as client:
+                response = await client.get(f"{self.base_url}/api/tags")
+                return response.status_code == 200
+        except Exception as e:
+            logger.debug(f"Ollama availability check failed: {e}")
+            return False

backend/services/piper_tts_service.py

@@ -0,0 +1,275 @@
+"""
+Piper TTS service for generating multi-voice audiobooks.
+"""
+import logging
+import io
+import os
+import subprocess
+from typing import Dict, List, Tuple, Optional
+import numpy as np
+import soundfile as sf
+from pydub import AudioSegment
+from pydub.effects import speedup
+
+logger = logging.getLogger(__name__)
+
+
+class PiperTTSService:
+    """
+    Service for text-to-speech synthesis using Piper TTS.
+    
+    Piper is a fast, local neural TTS system that supports multiple voices
+    and allows pitch modification through audio processing.
+    """
+    
+    # Default voice for unmapped roles
+    DEFAULT_VOICE = "en_US-lessac-medium"
+    
+    # Sample rate for Piper TTS (typically 22050)
+    SAMPLE_RATE = 22050
+    
+    # Available Piper voices with their characteristics
+    AVAILABLE_VOICES = {
+        # English voices
+        "en_US-lessac-medium": {"lang": "en", "gender": "male", "quality": "medium"},
+        "en_US-libritts-high": {"lang": "en", "gender": "neutral", "quality": "high"},
+        "en_US-amy-medium": {"lang": "en", "gender": "female", "quality": "medium"},
+        "en_GB-alan-medium": {"lang": "en", "gender": "male", "quality": "medium"},
+        "en_GB-alba-medium": {"lang": "en", "gender": "female", "quality": "medium"},
+    }
+    
+    def __init__(self):
+        """Initializes Piper TTS service."""
+        self.models_dir = os.path.join(os.path.dirname(__file__), "..", "piper_models")
+        os.makedirs(self.models_dir, exist_ok=True)
+        logger.info("PiperTTSService initialized")
+    
+    def _check_piper_installed(self) -> bool:
+        """Check if Piper is installed and accessible."""
+        try:
+            result = subprocess.run(
+                ["piper", "--version"],
+                capture_output=True,
+                text=True,
+                timeout=5
+            )
+            return result.returncode == 0
+        except (subprocess.SubprocessError, FileNotFoundError):
+            return False
+    
+    def _download_voice_model(self, voice: str) -> bool:
+        """
+        Download a Piper voice model if not already present.
+        
+        Args:
+            voice: Voice ID to download
+            
+        Returns:
+            True if model is available, False otherwise
+        """
+        model_path = os.path.join(self.models_dir, f"{voice}.onnx")
+        config_path = os.path.join(self.models_dir, f"{voice}.onnx.json")
+        
+        # Check if model already exists
+        if os.path.exists(model_path) and os.path.exists(config_path):
+            logger.info(f"Voice model {voice} already exists")
+            return True
+        
+        logger.info(f"Downloading Piper voice model: {voice}")
+        logger.info(f"Models directory: {self.models_dir}")
+        
+        # Try to download using wget/curl as Piper's download might not work
+        try:
+            # Piper models are hosted on HuggingFace
+            base_url = "https://huggingface.co/rhasspy/piper-voices/resolve/v1.0.0"
+            
+            # Determine language prefix from voice ID
+            lang_prefix = voice.split('-')[0]  # e.g., "en_US" from "en_US-lessac-medium"
+            
+            model_url = f"{base_url}/{lang_prefix}/{voice}.onnx"
+            config_url = f"{base_url}/{lang_prefix}/{voice}.onnx.json"
+            
+            logger.info(f"Downloading from: {model_url}")
+            
+            # Try using curl/wget first (more reliable)
+            try:
+                # Try curl
+                subprocess.run(
+                    ["curl", "-L", "-o", model_path, model_url],
+                    check=True,
+                    timeout=120,
+                    capture_output=True
+                )
+                subprocess.run(
+                    ["curl", "-L", "-o", config_path, config_url],
+                    check=True,
+                    timeout=120,
+                    capture_output=True
+                )
+            except (subprocess.SubprocessError, FileNotFoundError):
+                # Fall back to urllib with SSL context
+                import urllib.request
+                import ssl
+                
+                # Create SSL context that doesn't verify certificates (for development)
+                ssl_context = ssl.create_default_context()
+                ssl_context.check_hostname = False
+                ssl_context.verify_mode = ssl.CERT_NONE
+                
+                urllib.request.urlretrieve(model_url, model_path, context=ssl_context)
+                urllib.request.urlretrieve(config_url, config_path, context=ssl_context)
+            
+            if os.path.exists(model_path) and os.path.exists(config_path):
+                logger.info(f"Successfully downloaded voice model: {voice}")
+                return True
+            else:
+                logger.error(f"Download completed but files not found")
+                return False
+                
+        except Exception as e:
+            logger.error(f"Failed to download voice model {voice}: {e}")
+            logger.error(f"Please manually download from: https://github.com/rhasspy/piper/releases/tag/v1.2.0")
+            logger.error(f"See backend/PIPER_SETUP.md for detailed instructions")
+            return False
+    
+    def synthesize_with_pitch(
+        self,
+        text: str,
+        voice: str,
+        speed: float = 1.0,
+        pitch_shift: int = 0
+    ) -> np.ndarray:
+        """
+        Synthesizes text with Piper and applies pitch shifting.
+        
+        Args:
+            text: Text to synthesize
+            voice: Piper voice ID
+            speed: Playback speed (0.5-2.0)
+            pitch_shift: Semitones to shift pitch (-12 to +12)
+            
+        Returns:
+            Audio samples as numpy array
+        """
+        # Ensure voice model is available
+        if not self._download_voice_model(voice):
+            error_msg = (
+                f"Piper voice model '{voice}' not found. "
+                f"Please download voice models manually. "
+                f"See backend/PIPER_SETUP.md for instructions."
+            )
+            logger.error(error_msg)
+            raise FileNotFoundError(error_msg)
+        
+        model_path = os.path.join(self.models_dir, f"{voice}.onnx")
+        
+        # Check if model file exists
+        if not os.path.exists(model_path):
+            logger.error(f"Model file not found: {model_path}")
+            return np.array([], dtype=np.float32)
+        
+        # Generate audio with Piper
+        try:
+            logger.info(f"Running Piper with model: {model_path}")
+            
+            # Run piper command
+            process = subprocess.Popen(
+                ["piper", "--model", model_path, "--output-raw"],
+                stdin=subprocess.PIPE,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE
+            )
+            
+            # Send text and get audio
+            stdout, stderr = process.communicate(input=text.encode('utf-8'), timeout=30)
+            
+            if process.returncode != 0:
+                error_msg = stderr.decode() if stderr else "Unknown error"
+                logger.error(f"Piper synthesis failed (exit code {process.returncode}): {error_msg}")
+                return np.array([], dtype=np.float32)
+            
+            # Convert raw audio to numpy array
+            audio_data = np.frombuffer(stdout, dtype=np.int16)
+            audio_float = audio_data.astype(np.float32) / 32768.0
+            
+            # Apply pitch shift and speed change using pydub
+            if pitch_shift != 0 or speed != 1.0:
+                audio_float = self._apply_audio_effects(
+                    audio_float,
+                    self.SAMPLE_RATE,
+                    speed,
+                    pitch_shift
+                )
+            
+            return audio_float
+            
+        except subprocess.TimeoutExpired:
+            logger.error("Piper synthesis timed out")
+            return np.array([], dtype=np.float32)
+        except Exception as e:
+            logger.error(f"Error in Piper synthesis: {e}")
+            return np.array([], dtype=np.float32)
+    
+    def _apply_audio_effects(
+        self,
+        audio: np.ndarray,
+        sample_rate: int,
+        speed: float,
+        pitch_shift: int
+    ) -> np.ndarray:
+        """
+        Apply speed and pitch effects to audio using pydub.
+        
+        Args:
+            audio: Audio samples
+            sample_rate: Sample rate
+            speed: Speed multiplier
+            pitch_shift: Semitones to shift
+            
+        Returns:
+            Processed audio samples
+        """
+        try:
+            # Convert numpy to pydub AudioSegment
+            audio_int16 = (audio * 32768.0).astype(np.int16)
+            audio_bytes = audio_int16.tobytes()
+            
+            audio_segment = AudioSegment(
+                audio_bytes,
+                frame_rate=sample_rate,
+                sample_width=2,
+                channels=1
+            )
+            
+            # Apply pitch shift
+            if pitch_shift != 0:
+                # Pitch shift by changing frame rate then resampling
+                new_sample_rate = int(sample_rate * (2.0 ** (pitch_shift / 12.0)))
+                audio_segment = audio_segment._spawn(
+                    audio_segment.raw_data,
+                    overrides={'frame_rate': new_sample_rate}
+                )
+                audio_segment = audio_segment.set_frame_rate(sample_rate)
+            
+            # Apply speed change
+            if speed != 1.0:
+                audio_segment = speedup(audio_segment, playback_speed=speed)
+            
+            # Convert back to numpy
+            samples = np.array(audio_segment.get_array_of_samples())
+            audio_float = samples.astype(np.float32) / 32768.0
+            
+            return audio_float
+            
+        except Exception as e:
+            logger.error(f"Error applying audio effects: {e}")
+            return audio
+    
+    def get_available_voices(self) -> Dict[str, Dict[str, str]]:
+        """
+        Returns dictionary of available Piper voices.
+        
+        Returns:
+            Dict mapping voice IDs to their characteristics
+        """
+        return self.AVAILABLE_VOICES.copy()

backend/services/role_detector.py

@@ -2,13 +2,20 @@
 Role detection service for identifying distinct speakers in text.
 """
 import re
-from typing import List, Set, Dict
+import logging
+from typing import List, Set, Dict, Optional
+from .ollama_service import OllamaService
+
+
+logger = logging.getLogger(__name__)
 
 
 class RoleDetector:
     """
     Service for detecting distinct speaker roles in text.
     
+    Uses AI-based detection (Ollama) as primary method, with fallback to pattern matching.
+    
     Supports two pattern types:
     1. Colon pattern: "RoleName:" at the start of a line
     2. Bracket pattern: "[RoleName]" preceding dialogue
@@ -19,10 +26,23 @@ class RoleDetector:
     BRACKET_PATTERN = r'\[([A-Z][a-zA-Z\s]+?)\]'
     DEFAULT_ROLE = "Narrator"
     
-    def detect_roles(self, text: str) -> List[Dict[str, str]]:
+    def __init__(self, ollama_service: Optional[OllamaService] = None):
+        """
+        Initializes RoleDetector with optional OllamaService.
+        
+        Args:
+            ollama_service: Optional OllamaService instance for AI-based detection.
+                          If None, creates a new instance.
+        """
+        self.ollama_service = ollama_service or OllamaService()
+    
+    async def detect_roles(self, text: str) -> List[Dict[str, str]]:
         """
         Analyzes text to identify distinct speaker roles.
         
+        Uses AI-based detection (Ollama) first, then falls back to pattern matching.
+        Merges and deduplicates results from both methods.
+        
         Args:
             text: Input text to analyze
             
@@ -33,15 +53,26 @@ class RoleDetector:
         if not text or not text.strip():
             return [{"id": self.DEFAULT_ROLE, "label": self.DEFAULT_ROLE}]
         
-        # Extract roles from both patterns
+        all_roles = set()
+        
+        # Try AI-based detection first
+        ollama_roles = await self._detect_with_ollama(text)
+        if ollama_roles:
+            all_roles.update(ollama_roles)
+            logger.info(f"AI detection found {len(ollama_roles)} roles: {sorted(ollama_roles)}")
+        
+        # Always run pattern matching as well (for marked text or as fallback)
         colon_roles = self._extract_colon_pattern(text)
         bracket_roles = self._extract_bracket_pattern(text)
+        pattern_roles = colon_roles.union(bracket_roles)
         
-        # Combine and deduplicate
+        if pattern_roles:
-        all_roles = colon_roles.union(bracket_roles)
+            all_roles.update(pattern_roles)
+            logger.info(f"Pattern detection found {len(pattern_roles)} roles: {sorted(pattern_roles)}")
         
-        # If no roles found, return default
+        # If no roles found by either method, return default
         if not all_roles:
+            logger.info("No roles detected, using default Narrator")
             return [{"id": self.DEFAULT_ROLE, "label": self.DEFAULT_ROLE}]
         
         # Convert to role dictionaries and sort for consistent ordering
@@ -50,8 +81,40 @@ class RoleDetector:
             for role in sorted(all_roles)
         ]
         
+        logger.info(f"Total unique roles after merging: {len(role_list)}")
         return role_list
     
+    async def _detect_with_ollama(self, text: str) -> Set[str]:
+        """
+        Uses Ollama with llama3:8B to intelligently detect speakers.
+        
+        Args:
+            text: Input text to analyze
+            
+        Returns:
+            Set of speaker names or empty set if Ollama unavailable/fails.
+        """
+        try:
+            # Check if Ollama is available
+            is_available = await self.ollama_service.is_available()
+            if not is_available:
+                logger.info("Ollama service not available, skipping AI detection")
+                return set()
+            
+            # Detect speakers using Ollama
+            speakers = await self.ollama_service.detect_speakers(text)
+            
+            if speakers:
+                logger.info(f"Ollama detected speakers: {speakers}")
+                return set(speakers)
+            else:
+                logger.info("Ollama returned no speakers")
+                return set()
+                
+        except Exception as e:
+            logger.warning(f"Ollama detection failed: {e}, falling back to pattern matching")
+            return set()
+    
     def _extract_colon_pattern(self, text: str) -> Set[str]:
         """
         Extracts roles from "RoleName:" pattern at line starts.

backend/services/tts_service.py

@@ -8,6 +8,7 @@ from typing import Dict, List, Tuple, Optional
 import numpy as np
 import soundfile as sf
 from kokoro import KPipeline
+from .ollama_service import OllamaService
 
 logger = logging.getLogger(__name__)
 
@@ -30,9 +31,10 @@ class TTSService:
     COLON_PATTERN = r'^([A-Z][a-zA-Z\s]+?):\s*(.+)$'
     BRACKET_PATTERN = r'^\[([A-Z][a-zA-Z\s]+?)\]\s*(.+)$'
     
-    def __init__(self):
+    def __init__(self, ollama_service: Optional[OllamaService] = None):
-        """Initializes TTS service with empty pipeline cache."""
+        """Initializes TTS service with empty pipeline cache and optional Ollama service."""
         self.pipelines: Dict[str, KPipeline] = {}
+        self.ollama_service = ollama_service or OllamaService()
         logger.info("TTSService initialized")
     
     def get_pipeline(self, lang_code: str) -> KPipeline:
@@ -41,7 +43,7 @@ class TTSService:
         Caches pipelines to avoid reloading.
         
         Args:
-            lang_code: Language code (a, b, f, j)
+            lang_code: Language code (a, b, e, f, h, i, j, p, z)
             
         Returns:
             KPipeline instance for the language
@@ -49,7 +51,7 @@ class TTSService:
         Raises:
             ValueError: If language code is not supported
         """
-        supported_langs = ['a', 'b', 'f', 'j']
+        supported_langs = ['a', 'b', 'e', 'f', 'h', 'i', 'j', 'p', 'z']
         if lang_code not in supported_langs:
             raise ValueError(
                 f"Unsupported language code: {lang_code}. "
@@ -72,15 +74,62 @@ class TTSService:
             logger.error(f"Failed to initialize pipeline for language {lang_code}: {e}")
             raise
     
+    async def segment_text_with_ai(
+        self,
+        text: str,
+        role_voice_map: Dict[str, str]
+    ) -> Optional[List[Tuple[str, str, str]]]:
+        """
+        Uses AI to segment text and assign speakers intelligently.
+        
+        Args:
+            text: Input text to segment
+            role_voice_map: Mapping of role IDs to voice IDs
+            
+        Returns:
+            List of tuples: (role_id, voice_id, text_content) or None if AI unavailable
+        """
+        try:
+            # Check if Ollama is available
+            is_available = await self.ollama_service.is_available()
+            if not is_available:
+                logger.info("Ollama not available for AI segmentation")
+                return None
+            
+            # Get list of speakers from role_voice_map
+            speakers = list(role_voice_map.keys())
+            
+            # Request AI segmentation
+            ai_segments = await self.ollama_service.segment_text(text, speakers)
+            
+            if not ai_segments:
+                logger.warning("AI segmentation returned no segments")
+                return None
+            
+            # Convert to format with voice assignments
+            segments = []
+            for speaker, content in ai_segments:
+                voice = role_voice_map.get(speaker, self.DEFAULT_VOICE)
+                segments.append((speaker, voice, content))
+            
+            logger.info(f"AI segmented text into {len(segments)} segments")
+            return segments
+            
+        except Exception as e:
+            logger.warning(f"AI segmentation failed: {e}")
+            return None
+    
     def segment_text(
         self, 
         text: str, 
         role_voice_map: Dict[str, str]
     ) -> List[Tuple[str, str, str]]:
         """
-        Segments text into (role_id, voice, text_content) tuples.
+        Segments text into (role_id, voice, text_content) tuples using pattern matching.
         Identifies role markers and assigns segments accordingly.
         
+        This is the fallback method when AI segmentation is not available.
+        
         Args:
             text: Input text to segment
             role_voice_map: Mapping of role IDs to voice IDs
@@ -118,7 +167,7 @@ class TTSService:
             voice = role_voice_map.get("Narrator", self.DEFAULT_VOICE)
             segments.append(("Narrator", voice, line))
         
-        logger.info(f"Segmented text into {len(segments)} segments")
+        logger.info(f"Pattern-based segmentation produced {len(segments)} segments")
         return segments
     
     def _chunk_text(self, text: str, max_length: int = 500) -> List[str]:
@@ -186,13 +235,16 @@ class TTSService:
             try:
                 # Generate audio for chunk
                 result = pipeline(chunk, voice=voice, speed=speed)
-                # Kokoro returns a generator that yields audio arrays
+                # Kokoro returns a generator that yields Result objects
-                # Collect all arrays and concatenate them
+                # Each Result object has an .audio attribute (torch.Tensor)
                 audio_parts = []
                 for part in result:
-                    if isinstance(part, np.ndarray):
+                    # Extract audio tensor and convert to numpy
-                        # Flatten to 1D if needed
+                    if hasattr(part, 'audio'):
-                        audio_parts.append(part.flatten())
+                        audio_tensor = part.audio
+                        # Convert torch tensor to numpy and flatten
+                        audio_np = audio_tensor.cpu().numpy().flatten()
+                        audio_parts.append(audio_np)
                 
                 # Concatenate all parts
                 if audio_parts:
@@ -236,6 +288,62 @@ class TTSService:
         
         return concatenated
     
+    async def generate_script_segments(
+        self,
+        text: str,
+        roles: List[str]
+    ) -> List[Tuple[str, str]]:
+        """
+        Generates script segments with speaker assignments using AI.
+        
+        This method is used for the script preview feature, allowing users to
+        review and edit speaker assignments before generating audio.
+        
+        Args:
+            text: Input text to segment
+            roles: List of detected role IDs/names
+            
+        Returns:
+            List of tuples: (speaker_name, text_content)
+            
+        Raises:
+            Exception: If both AI and pattern-based segmentation fail
+        """
+        logger.info(f"Generating script segments for {len(text)} chars with {len(roles)} roles")
+        
+        # Try AI segmentation first
+        try:
+            is_available = await self.ollama_service.is_available()
+            if is_available:
+                logger.info("Using AI for script segmentation")
+                segments = await self.ollama_service.segment_text(text, roles)
+                
+                if segments:
+                    logger.info(f"AI segmentation produced {len(segments)} segments")
+                    return segments
+                else:
+                    logger.warning("AI segmentation returned empty result")
+            else:
+                logger.info("Ollama not available for script segmentation")
+        except Exception as e:
+            logger.warning(f"AI segmentation failed: {e}")
+        
+        # Fall back to pattern-based segmentation
+        logger.info("Using pattern-based segmentation as fallback")
+        
+        # Create a dummy role_voice_map for pattern-based segmentation
+        # We don't need actual voices here, just role assignments
+        role_voice_map = {role: self.DEFAULT_VOICE for role in roles}
+        
+        # Use existing segment_text method
+        segments_with_voice = self.segment_text(text, role_voice_map)
+        
+        # Convert from (role, voice, text) to (role, text)
+        segments = [(role, text) for role, voice, text in segments_with_voice]
+        
+        logger.info(f"Pattern-based segmentation produced {len(segments)} segments")
+        return segments
+    
     async def generate_audiobook(
         self,
         text: str,
@@ -247,6 +355,8 @@ class TTSService:
         Main orchestration method for audiobook generation.
         Segments text, synthesizes each segment, concatenates, and returns audio bytes.
         
+        Uses AI segmentation when available, falls back to pattern matching.
+        
         Args:
             text: Input text
             lang: Language code
@@ -264,8 +374,14 @@ class TTSService:
         # Get or create pipeline for language
         pipeline = self.get_pipeline(lang)
         
-        # Segment text by roles
+        # Try AI segmentation first, fall back to pattern matching
-        segments = self.segment_text(text, role_voice_map)
+        segments = await self.segment_text_with_ai(text, role_voice_map)
+        
+        if segments is None:
+            logger.info("Using pattern-based segmentation as fallback")
+            segments = self.segment_text(text, role_voice_map)
+        else:
+            logger.info("Using AI-powered segmentation")
         
         if not segments:
             raise ValueError("No segments to synthesize")
@@ -288,3 +404,66 @@ class TTSService:
         
         logger.info(f"Generated audiobook: {len(audio_bytes)} bytes")
         return audio_bytes
+
+    async def generate_audiobook_from_segments(
+        self,
+        segments: List[Tuple[str, str]],
+        lang: str,
+        role_voice_map: Dict[str, str],
+        speed: float = 1.0
+    ) -> bytes:
+        """
+        Generates audiobook from pre-segmented script with speaker assignments.
+        
+        This method is used when the user has reviewed and edited the script,
+        bypassing automatic segmentation.
+        
+        Args:
+            segments: List of (speaker_name, text_content) tuples
+            lang: Language code
+            role_voice_map: Role to voice ID mapping
+            speed: Playback speed
+            
+        Returns:
+            Audio data as bytes (WAV format)
+            
+        Raises:
+            ValueError: If segments is empty or invalid
+        """
+        logger.info(
+            f"Generating audiobook from {len(segments)} edited segments: "
+            f"lang={lang}, speed={speed}, roles={len(role_voice_map)}"
+        )
+        
+        if not segments:
+            raise ValueError("No segments provided for synthesis")
+        
+        # Get or create pipeline for language
+        pipeline = self.get_pipeline(lang)
+        
+        # Convert segments to format with voice assignments
+        segments_with_voice = []
+        for speaker, text in segments:
+            voice = role_voice_map.get(speaker, self.DEFAULT_VOICE)
+            segments_with_voice.append((speaker, voice, text))
+        
+        logger.info(f"Processing {len(segments_with_voice)} segments with voice assignments")
+        
+        # Synthesize each segment
+        audio_segments = []
+        for role_id, voice, content in segments_with_voice:
+            logger.debug(f"Synthesizing segment for role '{role_id}' with voice '{voice}'")
+            audio = self.synthesize_segment(pipeline, content, voice, speed)
+            audio_segments.append(audio)
+        
+        # Concatenate all audio
+        final_audio = self.concatenate_audio(audio_segments)
+        
+        # Convert to bytes (WAV format)
+        buffer = io.BytesIO()
+        sf.write(buffer, final_audio, self.SAMPLE_RATE, format='WAV')
+        buffer.seek(0)
+        audio_bytes = buffer.read()
+        
+        logger.info(f"Generated audiobook from edited segments: {len(audio_bytes)} bytes")
+        return audio_bytes

backend/services/unified_tts_service.py

@@ -0,0 +1,283 @@
+"""
+Unified TTS service that supports multiple TTS engines (Kokoro, Piper).
+"""
+import logging
+import os
+from typing import Dict, List, Tuple, Optional
+from enum import Enum
+
+logger = logging.getLogger(__name__)
+
+
+class TTSEngine(str, Enum):
+    """Available TTS engines."""
+    KOKORO = "kokoro"
+    PIPER = "piper"
+
+
+class UnifiedTTSService:
+    """
+    Unified service that delegates to specific TTS engines.
+    Allows runtime selection between Kokoro and Piper TTS.
+    """
+    
+    def __init__(self, engine: Optional[str] = None, ollama_service=None):
+        """
+        Initialize unified TTS service.
+        
+        Args:
+            engine: TTS engine to use ('kokoro' or 'piper'). 
+                   Defaults to TTS_ENGINE env var or 'kokoro'
+            ollama_service: Optional OllamaService for AI segmentation
+        """
+        self.engine_name = engine or os.getenv("TTS_ENGINE", "kokoro")
+        self.ollama_service = ollama_service
+        
+        # Lazy load engines
+        self._kokoro_service = None
+        self._piper_service = None
+        
+        logger.info(f"UnifiedTTSService initialized with engine: {self.engine_name}")
+    
+    @property
+    def kokoro_service(self):
+        """Lazy load Kokoro service."""
+        if self._kokoro_service is None:
+            from .tts_service import TTSService
+            self._kokoro_service = TTSService(self.ollama_service)
+        return self._kokoro_service
+    
+    @property
+    def piper_service(self):
+        """Lazy load Piper service."""
+        if self._piper_service is None:
+            from .piper_tts_service import PiperTTSService
+            self._piper_service = PiperTTSService()
+        return self._piper_service
+    
+    def set_engine(self, engine: str):
+        """
+        Change the active TTS engine.
+        
+        Args:
+            engine: Engine name ('kokoro' or 'piper')
+        """
+        if engine not in [e.value for e in TTSEngine]:
+            raise ValueError(f"Unknown engine: {engine}. Use 'kokoro' or 'piper'")
+        
+        self.engine_name = engine
+        logger.info(f"Switched TTS engine to: {engine}")
+    
+    def get_available_engines(self) -> List[str]:
+        """
+        Get list of available TTS engines.
+        
+        Returns:
+            List of engine names
+        """
+        return [e.value for e in TTSEngine]
+    
+    def get_available_voices(self) -> Dict[str, List[str]]:
+        """
+        Get available voices for all engines.
+        
+        Returns:
+            Dict mapping engine names to lists of voice IDs
+        """
+        voices = {}
+        
+        # Kokoro voices (from documentation)
+        voices["kokoro"] = [
+            "af_bella", "af_nicole", "af_sarah", "af_sky",
+            "am_adam", "am_michael", "bf_emma", "bf_isabella",
+            "bm_george", "bm_lewis"
+        ]
+        
+        # Piper voices
+        try:
+            piper_voices = self.piper_service.get_available_voices()
+            voices["piper"] = list(piper_voices.keys())
+        except Exception as e:
+            logger.warning(f"Could not load Piper voices: {e}")
+            voices["piper"] = []
+        
+        return voices
+    
+    async def generate_script_segments(
+        self,
+        text: str,
+        roles: List[str]
+    ) -> List[Tuple[str, str]]:
+        """
+        Generate script segments with speaker assignments.
+        Uses AI when available, falls back to pattern matching.
+        
+        Args:
+            text: Input text to segment
+            roles: List of detected role IDs/names
+            
+        Returns:
+            List of tuples: (speaker_name, text_content)
+        """
+        # This is engine-agnostic, use Kokoro's implementation
+        return await self.kokoro_service.generate_script_segments(text, roles)
+    
+    async def generate_audiobook(
+        self,
+        text: str,
+        lang: str,
+        role_voice_map: Dict[str, str],
+        speed: float = 1.0,
+        pitch_adjustments: Optional[Dict[str, int]] = None
+    ) -> bytes:
+        """
+        Generate audiobook using the selected TTS engine.
+        
+        Args:
+            text: Input text
+            lang: Language code
+            role_voice_map: Role to voice ID mapping
+            speed: Playback speed
+            pitch_adjustments: Optional dict of role to pitch shift (semitones)
+            
+        Returns:
+            Audio data as bytes (WAV format)
+        """
+        if self.engine_name == TTSEngine.KOKORO:
+            # Kokoro doesn't support pitch adjustment
+            return await self.kokoro_service.generate_audiobook(
+                text, lang, role_voice_map, speed
+            )
+        
+        elif self.engine_name == TTSEngine.PIPER:
+            # Use Piper with pitch support
+            return await self._generate_with_piper(
+                text, lang, role_voice_map, speed, pitch_adjustments or {}
+            )
+        
+        else:
+            raise ValueError(f"Unknown engine: {self.engine_name}")
+    
+    async def generate_audiobook_from_segments(
+        self,
+        segments: List[Tuple[str, str]],
+        lang: str,
+        role_voice_map: Dict[str, str],
+        speed: float = 1.0,
+        pitch_adjustments: Optional[Dict[str, int]] = None
+    ) -> bytes:
+        """
+        Generate audiobook from pre-segmented script.
+        
+        Args:
+            segments: List of (speaker_name, text_content) tuples
+            lang: Language code
+            role_voice_map: Role to voice ID mapping
+            speed: Playback speed
+            pitch_adjustments: Optional dict of role to pitch shift (semitones)
+            
+        Returns:
+            Audio data as bytes (WAV format)
+        """
+        if self.engine_name == TTSEngine.KOKORO:
+            return await self.kokoro_service.generate_audiobook_from_segments(
+                segments, lang, role_voice_map, speed
+            )
+        
+        elif self.engine_name == TTSEngine.PIPER:
+            return await self._generate_from_segments_with_piper(
+                segments, lang, role_voice_map, speed, pitch_adjustments or {}
+            )
+        
+        else:
+            raise ValueError(f"Unknown engine: {self.engine_name}")
+    
+    async def _generate_with_piper(
+        self,
+        text: str,
+        lang: str,
+        role_voice_map: Dict[str, str],
+        speed: float,
+        pitch_adjustments: Dict[str, int]
+    ) -> bytes:
+        """Generate audiobook using Piper TTS with pitch control."""
+        import io
+        import numpy as np
+        import soundfile as sf
+        
+        # Segment text using Kokoro's logic
+        segments = await self.kokoro_service.segment_text_with_ai(text, role_voice_map)
+        
+        if segments is None:
+            segments = self.kokoro_service.segment_text(text, role_voice_map)
+        
+        if not segments:
+            raise ValueError("No segments to synthesize")
+        
+        # Synthesize each segment with Piper
+        audio_segments = []
+        for role_id, voice, content in segments:
+            pitch_shift = pitch_adjustments.get(role_id, 0)
+            logger.debug(
+                f"Synthesizing with Piper: role='{role_id}', voice='{voice}', "
+                f"pitch={pitch_shift}"
+            )
+            
+            audio = self.piper_service.synthesize_with_pitch(
+                content, voice, speed, pitch_shift
+            )
+            audio_segments.append(audio)
+        
+        # Concatenate
+        final_audio = np.concatenate([s for s in audio_segments if len(s) > 0])
+        
+        # Convert to WAV bytes
+        buffer = io.BytesIO()
+        sf.write(buffer, final_audio, self.piper_service.SAMPLE_RATE, format='WAV')
+        buffer.seek(0)
+        
+        logger.info(f"Generated Piper audiobook: {len(buffer.getvalue())} bytes")
+        return buffer.read()
+    
+    async def _generate_from_segments_with_piper(
+        self,
+        segments: List[Tuple[str, str]],
+        lang: str,
+        role_voice_map: Dict[str, str],
+        speed: float,
+        pitch_adjustments: Dict[str, int]
+    ) -> bytes:
+        """Generate audiobook from segments using Piper TTS."""
+        import io
+        import numpy as np
+        import soundfile as sf
+        
+        if not segments:
+            raise ValueError("No segments provided")
+        
+        # Synthesize each segment
+        audio_segments = []
+        for speaker, text in segments:
+            voice = role_voice_map.get(speaker, self.piper_service.DEFAULT_VOICE)
+            pitch_shift = pitch_adjustments.get(speaker, 0)
+            
+            logger.debug(
+                f"Synthesizing segment: speaker='{speaker}', voice='{voice}', "
+                f"pitch={pitch_shift}"
+            )
+            
+            audio = self.piper_service.synthesize_with_pitch(
+                text, voice, speed, pitch_shift
+            )
+            audio_segments.append(audio)
+        
+        # Concatenate
+        final_audio = np.concatenate([s for s in audio_segments if len(s) > 0])
+        
+        # Convert to WAV bytes
+        buffer = io.BytesIO()
+        sf.write(buffer, final_audio, self.piper_service.SAMPLE_RATE, format='WAV')
+        buffer.seek(0)
+        
+        logger.info(f"Generated Piper audiobook from segments: {len(buffer.getvalue())} bytes")
+        return buffer.read()

backend/start_backend.sh

@@ -0,0 +1,4 @@
+#!/bin/bash
+cd "$(dirname "$0")"
+source venv/bin/activate
+uvicorn main:app --reload --host 0.0.0.0 --port 8002

backend/test_ai_segmentation.py

@@ -0,0 +1,149 @@
+#!/usr/bin/env python3
+"""
+Test script for AI-powered text segmentation.
+Tests the integration between OllamaService and TTSService for intelligent text splitting.
+"""
+import asyncio
+import sys
+from services.ollama_service import OllamaService
+from services.tts_service import TTSService
+
+
+async def test_ai_segmentation():
+    """Test AI segmentation with a sample narrative text."""
+    print("Testing AI-Powered Text Segmentation\n" + "="*50)
+    
+    # Sample text without explicit role markers
+    text = """The old wizard gazed into his crystal ball. "I see danger approaching," he whispered.
+A young knight heard the warning and drew his sword. "I will protect the kingdom," he declared boldly.
+The princess watched from her tower window. She knew the prophecy would come true."""
+    
+    print(f"\nInput text:\n{text}\n")
+    
+    # Initialize services
+    ollama_service = OllamaService()
+    tts_service = TTSService(ollama_service=ollama_service)
+    
+    # Check if Ollama is available
+    is_available = await ollama_service.is_available()
+    if not is_available:
+        print("❌ Ollama is not available. Please start Ollama service.")
+        return False
+    
+    print("✓ Ollama service is available\n")
+    
+    # Define role-voice mapping (simulating what user would assign)
+    role_voice_map = {
+        "Narrator": "af_bella",
+        "The old wizard": "am_adam",
+        "A young knight": "am_michael",
+        "The princess": "af_sarah"
+    }
+    
+    print(f"Role-voice mapping: {role_voice_map}\n")
+    
+    # Test AI segmentation
+    try:
+        print("Requesting AI segmentation...")
+        segments = await tts_service.segment_text_with_ai(text, role_voice_map)
+        
+        if segments is None:
+            print("❌ AI segmentation returned None")
+            return False
+        
+        print(f"\n✓ AI segmentation successful! Generated {len(segments)} segments:\n")
+        
+        for i, (speaker, voice, content) in enumerate(segments, 1):
+            print(f"Segment {i}:")
+            print(f"  Speaker: {speaker}")
+            print(f"  Voice: {voice}")
+            print(f"  Text: {content[:80]}{'...' if len(content) > 80 else ''}")
+            print()
+        
+        # Verify segments are properly assigned
+        speakers_used = set(seg[0] for seg in segments)
+        print(f"Speakers used in segmentation: {speakers_used}")
+        
+        # Check if AI intelligently assigned different speakers
+        if len(speakers_used) > 1:
+            print("\n✓ SUCCESS: AI intelligently assigned multiple speakers!")
+            return True
+        else:
+            print("\n⚠ WARNING: Only one speaker used. AI may not have detected dialogue.")
+            return True  # Still a success, just not ideal
+            
+    except Exception as e:
+        print(f"\n❌ ERROR: {e}")
+        import traceback
+        traceback.print_exc()
+        return False
+
+
+async def test_fallback_to_pattern():
+    """Test that pattern-based segmentation works as fallback."""
+    print("\n" + "="*50)
+    print("Testing Fallback to Pattern-Based Segmentation\n")
+    
+    # Text with explicit markers
+    text = """Alice: Hello there!
+Bob: Hi Alice, how are you?
+[Narrator] They continued their conversation in the garden."""
+    
+    print(f"Input text:\n{text}\n")
+    
+    tts_service = TTSService()
+    
+    role_voice_map = {
+        "Alice": "af_bella",
+        "Bob": "am_adam",
+        "Narrator": "af_sarah"
+    }
+    
+    print(f"Role-voice mapping: {role_voice_map}\n")
+    
+    # Use pattern-based segmentation
+    segments = tts_service.segment_text(text, role_voice_map)
+    
+    print(f"✓ Pattern segmentation generated {len(segments)} segments:\n")
+    
+    for i, (speaker, voice, content) in enumerate(segments, 1):
+        print(f"Segment {i}: [{speaker}] {content}")
+    
+    # Verify all speakers were detected
+    speakers_used = set(seg[0] for seg in segments)
+    expected_speakers = {"Alice", "Bob", "Narrator"}
+    
+    if speakers_used == expected_speakers:
+        print(f"\n✓ SUCCESS: All expected speakers detected: {speakers_used}")
+        return True
+    else:
+        print(f"\n❌ FAIL: Expected {expected_speakers}, got {speakers_used}")
+        return False
+
+
+async def main():
+    """Run all tests."""
+    print("\n" + "="*70)
+    print("AI-POWERED TEXT SEGMENTATION TEST SUITE")
+    print("="*70 + "\n")
+    
+    # Test 1: AI segmentation
+    test1_passed = await test_ai_segmentation()
+    
+    # Test 2: Pattern fallback
+    test2_passed = await test_fallback_to_pattern()
+    
+    # Summary
+    print("\n" + "="*70)
+    print("TEST SUMMARY")
+    print("="*70)
+    print(f"AI Segmentation: {'✓ PASSED' if test1_passed else '❌ FAILED'}")
+    print(f"Pattern Fallback: {'✓ PASSED' if test2_passed else '❌ FAILED'}")
+    print("="*70 + "\n")
+    
+    return test1_passed and test2_passed
+
+
+if __name__ == '__main__':
+    success = asyncio.run(main())
+    sys.exit(0 if success else 1)

backend/test_end_to_end_ai.py

@@ -0,0 +1,168 @@
+#!/usr/bin/env python3
+"""
+End-to-end test demonstrating AI-powered audiobook generation.
+Shows the complete workflow from unmarked text to multi-voice audio.
+"""
+import asyncio
+import sys
+from services.role_detector import RoleDetector
+from services.tts_service import TTSService
+from services.ollama_service import OllamaService
+
+
+async def test_complete_workflow():
+    """Test the complete AI-powered audiobook generation workflow."""
+    print("\n" + "="*70)
+    print("END-TO-END AI-POWERED AUDIOBOOK GENERATION TEST")
+    print("="*70 + "\n")
+    
+    # Sample story without any role markers
+    story = """The old wizard Merlin gazed into his crystal ball with concern. 
+"Dark times are coming," he whispered to himself.
+
+A young knight named Arthur entered the chamber. "Master Merlin, I heard your summons," he said with determination.
+
+Merlin turned to face him. "Arthur, the kingdom needs you now more than ever."
+
+Arthur drew his sword. "I am ready to defend our people."
+
+From the shadows, the sorceress Morgana watched silently. She knew the prophecy would unfold exactly as foretold."""
+    
+    print("STORY TEXT (unmarked narrative):")
+    print("-" * 70)
+    print(story)
+    print("-" * 70 + "\n")
+    
+    # Initialize services
+    ollama_service = OllamaService()
+    role_detector = RoleDetector(ollama_service=ollama_service)
+    tts_service = TTSService(ollama_service=ollama_service)
+    
+    # Check Ollama availability
+    is_available = await ollama_service.is_available()
+    if not is_available:
+        print("❌ Ollama is not available. This test requires Ollama.")
+        print("   Please start Ollama with: ollama serve")
+        return False
+    
+    print("✓ Ollama service is available\n")
+    
+    # Step 1: Detect roles using AI
+    print("STEP 1: AI Role Detection")
+    print("-" * 70)
+    try:
+        roles = await role_detector.detect_roles(story)
+        print(f"✓ Detected {len(roles)} roles:\n")
+        for role in roles:
+            print(f"  - {role['label']}")
+        print()
+    except Exception as e:
+        print(f"❌ Role detection failed: {e}")
+        return False
+    
+    # Step 2: User assigns voices (simulated)
+    print("STEP 2: Voice Assignment (simulated user input)")
+    print("-" * 70)
+    role_voice_map = {}
+    voice_options = ["af_bella", "am_adam", "am_michael", "af_sarah", "bf_emma"]
+    
+    for i, role in enumerate(roles):
+        voice = voice_options[i % len(voice_options)]
+        role_voice_map[role['id']] = voice
+        print(f"  {role['label']} → {voice}")
+    print()
+    
+    # Step 3: AI text segmentation
+    print("STEP 3: AI Text Segmentation")
+    print("-" * 70)
+    try:
+        segments = await tts_service.segment_text_with_ai(story, role_voice_map)
+        
+        if segments is None:
+            print("❌ AI segmentation failed")
+            return False
+        
+        print(f"✓ AI segmented text into {len(segments)} segments:\n")
+        
+        for i, (speaker, voice, text) in enumerate(segments, 1):
+            # Truncate long text for display
+            display_text = text[:60] + "..." if len(text) > 60 else text
+            print(f"  {i}. [{speaker}] ({voice})")
+            print(f"     \"{display_text}\"")
+        print()
+        
+        # Verify intelligent segmentation
+        speakers_used = set(seg[0] for seg in segments)
+        print(f"Speakers used: {speakers_used}")
+        
+        # Check if dialogue was properly assigned
+        has_multiple_speakers = len(speakers_used) > 1
+        has_narrator = "Narrator" in speakers_used or any("Merlin" in s or "Arthur" in s or "Morgana" in s for s in speakers_used)
+        
+        if has_multiple_speakers and has_narrator:
+            print("✓ AI successfully assigned dialogue to characters and narrative to appropriate speakers")
+        else:
+            print("⚠ Segmentation may not be optimal")
+        print()
+        
+    except Exception as e:
+        print(f"❌ Segmentation failed: {e}")
+        import traceback
+        traceback.print_exc()
+        return False
+    
+    # Step 4: Verify segmentation quality
+    print("STEP 4: Segmentation Quality Analysis")
+    print("-" * 70)
+    
+    # Count segments per speaker
+    speaker_counts = {}
+    for speaker, _, _ in segments:
+        speaker_counts[speaker] = speaker_counts.get(speaker, 0) + 1
+    
+    print("Segments per speaker:")
+    for speaker, count in sorted(speaker_counts.items(), key=lambda x: x[1], reverse=True):
+        print(f"  {speaker}: {count} segments")
+    print()
+    
+    # Check for dialogue detection
+    dialogue_keywords = ['"', "'", "said", "whispered", "replied"]
+    dialogue_segments = 0
+    for _, _, text in segments:
+        if any(kw in text.lower() for kw in dialogue_keywords):
+            dialogue_segments += 1
+    
+    print(f"Dialogue segments detected: {dialogue_segments}/{len(segments)}")
+    print()
+    
+    # Summary
+    print("="*70)
+    print("TEST SUMMARY")
+    print("="*70)
+    print(f"✓ Role Detection: {len(roles)} roles detected")
+    print(f"✓ Voice Assignment: {len(role_voice_map)} voices assigned")
+    print(f"✓ Text Segmentation: {len(segments)} segments created")
+    print(f"✓ Speaker Distribution: {len(speakers_used)} unique speakers used")
+    print(f"✓ Dialogue Detection: {dialogue_segments} dialogue segments")
+    print()
+    print("🎉 AI-POWERED AUDIOBOOK GENERATION: SUCCESS!")
+    print("="*70 + "\n")
+    
+    return True
+
+
+async def main():
+    """Run the end-to-end test."""
+    try:
+        success = await test_complete_workflow()
+        return success
+    except Exception as e:
+        print(f"\n❌ Test failed with exception: {e}")
+        import traceback
+        traceback.print_exc()
+        return False
+
+
+if __name__ == '__main__':
+    success = asyncio.run(main())
+    sys.exit(0 if success else 1)

backend/test_engine_selection.py

@@ -0,0 +1,58 @@
+"""
+Test script for TTS engine selection functionality.
+"""
+import asyncio
+import sys
+from services.unified_tts_service import UnifiedTTSService
+
+
+async def test_engine_selection():
+    """Test switching between TTS engines."""
+    print("Testing TTS Engine Selection\n" + "="*50)
+    
+    # Initialize service
+    print("\n1. Initializing UnifiedTTSService...")
+    tts = UnifiedTTSService()
+    print(f"   Default engine: {tts.engine_name}")
+    
+    # Get available engines
+    print("\n2. Getting available engines...")
+    engines = tts.get_available_engines()
+    print(f"   Available: {engines}")
+    
+    # Get available voices
+    print("\n3. Getting available voices...")
+    voices = tts.get_available_voices()
+    for engine, voice_list in voices.items():
+        print(f"   {engine}: {len(voice_list)} voices")
+        if voice_list:
+            print(f"      Examples: {voice_list[:3]}")
+    
+    # Test switching to Piper
+    print("\n4. Switching to Piper engine...")
+    try:
+        tts.set_engine('piper')
+        print(f"   Current engine: {tts.engine_name}")
+    except Exception as e:
+        print(f"   ⚠️  Error: {e}")
+        print("   Note: Piper may not be installed. Run ./install_piper.sh")
+    
+    # Switch back to Kokoro
+    print("\n5. Switching back to Kokoro engine...")
+    tts.set_engine('kokoro')
+    print(f"   Current engine: {tts.engine_name}")
+    
+    # Test invalid engine
+    print("\n6. Testing invalid engine...")
+    try:
+        tts.set_engine('invalid')
+        print("   ❌ Should have raised error!")
+    except ValueError as e:
+        print(f"   ✓ Correctly rejected: {e}")
+    
+    print("\n" + "="*50)
+    print("✓ Engine selection tests completed!")
+
+
+if __name__ == "__main__":
+    asyncio.run(test_engine_selection())

backend/test_ollama_integration.py

@@ -0,0 +1,175 @@
+#!/usr/bin/env python3
+"""
+Unit tests for Ollama integration in RoleDetector.
+Tests the integration between RoleDetector and OllamaService.
+"""
+import pytest
+import asyncio
+from unittest.mock import AsyncMock, MagicMock, patch
+from services.role_detector import RoleDetector
+from services.ollama_service import OllamaService
+
+
+@pytest.mark.asyncio
+async def test_detect_roles_with_ollama_available():
+    """Test role detection when Ollama is available and returns speakers."""
+    # Create mock OllamaService
+    mock_ollama = AsyncMock(spec=OllamaService)
+    mock_ollama.is_available.return_value = True
+    mock_ollama.detect_speakers.return_value = ["Alice", "Bob", "Charlie"]
+    
+    # Create RoleDetector with mock
+    detector = RoleDetector(ollama_service=mock_ollama)
+    
+    # Test with text that has no pattern markers
+    text = "This is a conversation between Alice and Bob. Charlie joins later."
+    roles = await detector.detect_roles(text)
+    
+    # Verify Ollama was called
+    mock_ollama.is_available.assert_called_once()
+    mock_ollama.detect_speakers.assert_called_once_with(text)
+    
+    # Verify roles were detected
+    role_labels = [r['label'] for r in roles]
+    assert "Alice" in role_labels
+    assert "Bob" in role_labels
+    assert "Charlie" in role_labels
+    print("✓ PASS: Ollama detection works when available")
+
+
+@pytest.mark.asyncio
+async def test_detect_roles_with_ollama_unavailable():
+    """Test role detection falls back to pattern matching when Ollama unavailable."""
+    # Create mock OllamaService that's unavailable
+    mock_ollama = AsyncMock(spec=OllamaService)
+    mock_ollama.is_available.return_value = False
+    
+    # Create RoleDetector with mock
+    detector = RoleDetector(ollama_service=mock_ollama)
+    
+    # Test with text that has pattern markers
+    text = "Alice: Hello there!\nBob: Hi Alice!"
+    roles = await detector.detect_roles(text)
+    
+    # Verify Ollama availability was checked
+    mock_ollama.is_available.assert_called_once()
+    # Verify detect_speakers was NOT called since unavailable
+    mock_ollama.detect_speakers.assert_not_called()
+    
+    # Verify pattern matching still worked
+    role_labels = [r['label'] for r in roles]
+    assert "Alice" in role_labels
+    assert "Bob" in role_labels
+    print("✓ PASS: Falls back to pattern matching when Ollama unavailable")
+
+
+@pytest.mark.asyncio
+async def test_detect_roles_with_ollama_error():
+    """Test role detection handles Ollama errors gracefully."""
+    # Create mock OllamaService that throws error
+    mock_ollama = AsyncMock(spec=OllamaService)
+    mock_ollama.is_available.return_value = True
+    mock_ollama.detect_speakers.side_effect = Exception("Ollama connection failed")
+    
+    # Create RoleDetector with mock
+    detector = RoleDetector(ollama_service=mock_ollama)
+    
+    # Test with text that has pattern markers
+    text = "Alice: Hello there!\nBob: Hi Alice!"
+    roles = await detector.detect_roles(text)
+    
+    # Verify Ollama was attempted
+    mock_ollama.is_available.assert_called_once()
+    mock_ollama.detect_speakers.assert_called_once()
+    
+    # Verify pattern matching still worked as fallback
+    role_labels = [r['label'] for r in roles]
+    assert "Alice" in role_labels
+    assert "Bob" in role_labels
+    print("✓ PASS: Handles Ollama errors gracefully and falls back to patterns")
+
+
+@pytest.mark.asyncio
+async def test_detect_roles_merges_ollama_and_pattern_results():
+    """Test that roles from both Ollama and pattern matching are merged."""
+    # Create mock OllamaService
+    mock_ollama = AsyncMock(spec=OllamaService)
+    mock_ollama.is_available.return_value = True
+    mock_ollama.detect_speakers.return_value = ["Alice", "Charlie"]
+    
+    # Create RoleDetector with mock
+    detector = RoleDetector(ollama_service=mock_ollama)
+    
+    # Test with text that has pattern markers for different roles
+    text = "Alice: Hello!\nBob: Hi there!\nCharlie appears later."
+    roles = await detector.detect_roles(text)
+    
+    # Verify both methods were used
+    mock_ollama.detect_speakers.assert_called_once()
+    
+    # Verify roles from both sources are present
+    role_labels = [r['label'] for r in roles]
+    assert "Alice" in role_labels  # From both Ollama and pattern
+    assert "Bob" in role_labels    # From pattern only
+    assert "Charlie" in role_labels  # From Ollama only
+    print("✓ PASS: Merges results from both Ollama and pattern matching")
+
+
+@pytest.mark.asyncio
+async def test_detect_roles_deduplicates_across_methods():
+    """Test that duplicate roles from Ollama and patterns are deduplicated."""
+    # Create mock OllamaService
+    mock_ollama = AsyncMock(spec=OllamaService)
+    mock_ollama.is_available.return_value = True
+    mock_ollama.detect_speakers.return_value = ["Alice", "Bob"]
+    
+    # Create RoleDetector with mock
+    detector = RoleDetector(ollama_service=mock_ollama)
+    
+    # Test with text where patterns also detect Alice and Bob
+    text = "Alice: Hello!\nBob: Hi there!"
+    roles = await detector.detect_roles(text)
+    
+    # Verify roles are deduplicated
+    role_labels = [r['label'] for r in roles]
+    assert role_labels.count("Alice") == 1
+    assert role_labels.count("Bob") == 1
+    assert len(role_labels) == 2
+    print("✓ PASS: Deduplicates roles across both detection methods")
+
+
+@pytest.mark.asyncio
+async def test_detect_roles_returns_narrator_when_no_roles_found():
+    """Test that default Narrator is returned when no roles detected by either method."""
+    # Create mock OllamaService that returns empty
+    mock_ollama = AsyncMock(spec=OllamaService)
+    mock_ollama.is_available.return_value = True
+    mock_ollama.detect_speakers.return_value = []
+    
+    # Create RoleDetector with mock
+    detector = RoleDetector(ollama_service=mock_ollama)
+    
+    # Test with text that has no role markers
+    text = "This is just plain text without any speakers."
+    roles = await detector.detect_roles(text)
+    
+    # Verify default Narrator is returned
+    assert len(roles) == 1
+    assert roles[0]['label'] == "Narrator"
+    print("✓ PASS: Returns default Narrator when no roles found")
+
+
+if __name__ == '__main__':
+    # Run tests
+    print("Testing Ollama Integration in RoleDetector...\n")
+    
+    asyncio.run(test_detect_roles_with_ollama_available())
+    asyncio.run(test_detect_roles_with_ollama_unavailable())
+    asyncio.run(test_detect_roles_with_ollama_error())
+    asyncio.run(test_detect_roles_merges_ollama_and_pattern_results())
+    asyncio.run(test_detect_roles_deduplicates_across_methods())
+    asyncio.run(test_detect_roles_returns_narrator_when_no_roles_found())
+    
+    print("\n" + "="*50)
+    print("All integration tests passed!")
+    print("="*50)

backend/test_ollama_quick.py

@@ -0,0 +1,18 @@
+import asyncio
+from services.ollama_service import OllamaService
+
+async def test():
+    service = OllamaService()
+    text = '''Once upon a time, in a tiny village surrounded by lush green forests, there lived three best friends: Lily the rabbit, Benny the bear, and Sammy the squirrel.
+
+As they sat down on a blanket, Lily asked, "Have you guys heard about the new stream that just appeared in the woods?"
+
+Benny's eyes lit up. "Ooh, I love streams! Do we get to go see it now?"
+
+Sammy nodded enthusiastically. "I've been wanting to explore the forest more since the snow melted. Let's go!"'''
+    
+    print("Testing Ollama speaker detection...")
+    speakers = await service.detect_speakers(text)
+    print(f'Detected speakers: {speakers}')
+
+asyncio.run(test())

backend/test_ollama_service.py

@@ -0,0 +1,237 @@
+"""
+Tests for Ollama integration service.
+"""
+import pytest
+import json
+from unittest.mock import AsyncMock, patch, MagicMock
+from services.ollama_service import OllamaService
+
+
+@pytest.mark.asyncio
+async def test_ollama_service_initialization():
+    """Test OllamaService initializes with correct defaults."""
+    service = OllamaService()
+    assert service.base_url == "http://localhost:11434"
+    assert service.model == "llama3:8b"
+    assert service.timeout == 30.0
+
+
+@pytest.mark.asyncio
+async def test_ollama_service_custom_base_url():
+    """Test OllamaService accepts custom base URL."""
+    custom_url = "http://custom-ollama:11434"
+    service = OllamaService(base_url=custom_url)
+    assert service.base_url == custom_url
+
+
+@pytest.mark.asyncio
+async def test_sample_text_short():
+    """Test sampling short text returns full text."""
+    service = OllamaService()
+    text = "Short text"
+    samples = service._sample_text(text, chunk_size=5000, num_samples=4)
+    
+    assert len(samples) == 1
+    assert samples[0] == text
+
+
+@pytest.mark.asyncio
+async def test_sample_text_long():
+    """Test sampling long text returns multiple samples."""
+    service = OllamaService()
+    # Create text with position markers so we can verify different samples
+    text = "".join([f"Position{i:05d} " for i in range(2500)])  # ~25k characters
+    samples = service._sample_text(text, chunk_size=5000, num_samples=4)
+    
+    assert len(samples) == 4
+    assert all(len(s) <= 5000 for s in samples)
+    # Samples should be from different parts - check they contain different position markers
+    assert "Position00000" in samples[0]  # First sample should have early positions
+    assert "Position00000" not in samples[-1]  # Last sample should have later positions
+
+
+@pytest.mark.asyncio
+async def test_sample_text_medium():
+    """Test sampling medium text returns appropriate number of samples."""
+    service = OllamaService()
+    text = "B" * 8000  # 8k characters
+    samples = service._sample_text(text, chunk_size=5000, num_samples=4)
+    
+    # Should get 2 samples (8000 / 5000 = 1.6, so 2 samples)
+    assert len(samples) >= 1
+    assert all(len(s) <= 5000 for s in samples)
+
+
+@pytest.mark.asyncio
+async def test_build_prompt():
+    """Test prompt builder creates correct format."""
+    service = OllamaService()
+    text = "Alice: Hello there!\nBob: Hi Alice!"
+    prompt = service._build_prompt(text)
+    
+    assert "speakers" in prompt
+    assert "JSON" in prompt
+    assert text in prompt
+
+
+@pytest.mark.asyncio
+async def test_parse_response_with_speakers_key():
+    """Test parsing JSON response with 'speakers' key."""
+    service = OllamaService()
+    response = '{"speakers": ["Alice", "Bob", "Narrator"]}'
+    speakers = service._parse_response(response)
+    
+    assert speakers == ["Alice", "Bob", "Narrator"]
+
+
+@pytest.mark.asyncio
+async def test_parse_response_with_characters_key():
+    """Test parsing JSON response with 'characters' key."""
+    service = OllamaService()
+    response = '{"characters": ["Alice", "Bob"]}'
+    speakers = service._parse_response(response)
+    
+    assert speakers == ["Alice", "Bob"]
+
+
+@pytest.mark.asyncio
+async def test_parse_response_with_roles_key():
+    """Test parsing JSON response with 'roles' key."""
+    service = OllamaService()
+    response = '{"roles": ["Narrator", "Alice"]}'
+    speakers = service._parse_response(response)
+    
+    assert speakers == ["Narrator", "Alice"]
+
+
+@pytest.mark.asyncio
+async def test_parse_response_with_array():
+    """Test parsing JSON response that is a direct array."""
+    service = OllamaService()
+    response = '["Alice", "Bob"]'
+    speakers = service._parse_response(response)
+    
+    assert speakers == ["Alice", "Bob"]
+
+
+@pytest.mark.asyncio
+async def test_parse_response_empty():
+    """Test parsing empty response."""
+    service = OllamaService()
+    speakers = service._parse_response("")
+    assert speakers == []
+
+
+@pytest.mark.asyncio
+async def test_parse_response_invalid_json():
+    """Test parsing invalid JSON returns empty list."""
+    service = OllamaService()
+    response = "This is not JSON"
+    speakers = service._parse_response(response)
+    assert speakers == []
+
+
+@pytest.mark.asyncio
+async def test_detect_speakers_success():
+    """Test successful speaker detection with short text."""
+    service = OllamaService()
+    text = "Alice: Hello!\nBob: Hi there!"
+    
+    mock_response = MagicMock()
+    mock_response.json.return_value = {
+        "response": '{"speakers": ["Alice", "Bob"]}'
+    }
+    mock_response.raise_for_status = MagicMock()
+    
+    with patch('httpx.AsyncClient') as mock_client:
+        mock_client.return_value.__aenter__.return_value.post = AsyncMock(return_value=mock_response)
+        
+        speakers = await service.detect_speakers(text)
+        assert set(speakers) == {"Alice", "Bob"}
+
+
+@pytest.mark.asyncio
+async def test_detect_speakers_multiple_samples():
+    """Test speaker detection with long text requiring multiple samples."""
+    service = OllamaService()
+    text = "A" * 25000  # Long text requiring multiple samples
+    
+    # Mock responses for different samples
+    responses = [
+        MagicMock(json=lambda: {"response": '{"speakers": ["Alice", "Bob"]}'}),
+        MagicMock(json=lambda: {"response": '{"speakers": ["Charlie", "Bob"]}'}),
+        MagicMock(json=lambda: {"response": '{"speakers": ["Alice", "David"]}'}),
+        MagicMock(json=lambda: {"response": '{"speakers": ["Eve"]}'}),
+    ]
+    
+    for r in responses:
+        r.raise_for_status = MagicMock()
+    
+    with patch('httpx.AsyncClient') as mock_client:
+        mock_client.return_value.__aenter__.return_value.post = AsyncMock(side_effect=responses)
+        
+        speakers = await service.detect_speakers(text)
+        # Should deduplicate across all samples
+        assert set(speakers) == {"Alice", "Bob", "Charlie", "David", "Eve"}
+
+
+@pytest.mark.asyncio
+async def test_detect_speakers_timeout():
+    """Test speaker detection handles timeout."""
+    service = OllamaService()
+    text = "Some text"
+    
+    with patch('httpx.AsyncClient') as mock_client:
+        import httpx
+        mock_client.return_value.__aenter__.return_value.post = AsyncMock(
+            side_effect=httpx.TimeoutException("Timeout")
+        )
+        
+        with pytest.raises(Exception, match="timed out"):
+            await service.detect_speakers(text)
+
+
+@pytest.mark.asyncio
+async def test_detect_speakers_http_error():
+    """Test speaker detection handles HTTP errors."""
+    service = OllamaService()
+    text = "Some text"
+    
+    with patch('httpx.AsyncClient') as mock_client:
+        import httpx
+        mock_client.return_value.__aenter__.return_value.post = AsyncMock(
+            side_effect=httpx.HTTPError("Connection failed")
+        )
+        
+        with pytest.raises(Exception, match="Ollama service error"):
+            await service.detect_speakers(text)
+
+
+@pytest.mark.asyncio
+async def test_is_available_success():
+    """Test is_available returns True when service responds."""
+    service = OllamaService()
+    
+    mock_response = MagicMock()
+    mock_response.status_code = 200
+    
+    with patch('httpx.AsyncClient') as mock_client:
+        mock_client.return_value.__aenter__.return_value.get = AsyncMock(return_value=mock_response)
+        
+        available = await service.is_available()
+        assert available is True
+
+
+@pytest.mark.asyncio
+async def test_is_available_failure():
+    """Test is_available returns False when service is down."""
+    service = OllamaService()
+    
+    with patch('httpx.AsyncClient') as mock_client:
+        import httpx
+        mock_client.return_value.__aenter__.return_value.get = AsyncMock(
+            side_effect=httpx.ConnectError("Connection refused")
+        )
+        
+        available = await service.is_available()
+        assert available is False

backend/test_piper_direct.py

@@ -0,0 +1,94 @@
+"""
+Direct test of Piper TTS functionality.
+"""
+import subprocess
+import os
+
+def test_piper_installation():
+    """Test if Piper is installed and accessible."""
+    print("Testing Piper Installation\n" + "="*50)
+    
+    # Check if piper command exists
+    try:
+        result = subprocess.run(
+            ["piper", "--version"],
+            capture_output=True,
+            text=True,
+            timeout=5
+        )
+        print(f"✓ Piper found: {result.stdout.strip()}")
+        return True
+    except FileNotFoundError:
+        print("✗ Piper not found in PATH")
+        print("  Install with: ./install_piper.sh")
+        return False
+    except Exception as e:
+        print(f"✗ Error checking Piper: {e}")
+        return False
+
+
+def test_piper_synthesis():
+    """Test basic Piper synthesis."""
+    print("\nTesting Piper Synthesis\n" + "="*50)
+    
+    # Create models directory
+    models_dir = os.path.join(os.path.dirname(__file__), "piper_models")
+    os.makedirs(models_dir, exist_ok=True)
+    print(f"Models directory: {models_dir}")
+    
+    # Try to synthesize with default voice
+    voice = "en_US-lessac-medium"
+    model_path = os.path.join(models_dir, f"{voice}.onnx")
+    
+    if not os.path.exists(model_path):
+        print(f"\n⚠️  Model not found: {model_path}")
+        print(f"Attempting to download {voice}...")
+        
+        # Try downloading
+        try:
+            import urllib.request
+            base_url = "https://huggingface.co/rhasspy/piper-voices/resolve/v1.0.0"
+            model_url = f"{base_url}/en_US/{voice}.onnx"
+            config_url = f"{base_url}/en_US/{voice}.onnx.json"
+            
+            print(f"Downloading from: {model_url}")
+            urllib.request.urlretrieve(model_url, model_path)
+            urllib.request.urlretrieve(config_url, f"{model_path}.json")
+            print("✓ Download complete")
+        except Exception as e:
+            print(f"✗ Download failed: {e}")
+            return False
+    else:
+        print(f"✓ Model found: {model_path}")
+    
+    # Try synthesis
+    try:
+        print("\nAttempting synthesis...")
+        process = subprocess.Popen(
+            ["piper", "--model", model_path, "--output-raw"],
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE
+        )
+        
+        test_text = "Hello, this is a test."
+        stdout, stderr = process.communicate(input=test_text.encode('utf-8'), timeout=10)
+        
+        if process.returncode == 0:
+            print(f"✓ Synthesis successful: {len(stdout)} bytes of audio")
+            return True
+        else:
+            print(f"✗ Synthesis failed (exit code {process.returncode})")
+            print(f"  Error: {stderr.decode()}")
+            return False
+            
+    except Exception as e:
+        print(f"✗ Synthesis error: {e}")
+        return False
+
+
+if __name__ == "__main__":
+    if test_piper_installation():
+        test_piper_synthesis()
+    
+    print("\n" + "="*50)

backend/test_script_endpoint.py

@@ -0,0 +1,173 @@
+"""
+Tests for the script generation endpoint.
+"""
+import pytest
+from fastapi.testclient import TestClient
+from main import app
+
+client = TestClient(app)
+
+
+def test_script_endpoint_exists():
+    """Test that the /api/tts/script endpoint exists."""
+    response = client.post(
+        "/api/tts/script",
+        json={
+            "text": "Alice: Hello there!\nBob: Hi Alice!",
+            "roles": ["Alice", "Bob"]
+        }
+    )
+    # Should not return 404
+    assert response.status_code != 404
+
+
+def test_script_generation_with_valid_input():
+    """Test script generation with valid text and roles."""
+    response = client.post(
+        "/api/tts/script",
+        json={
+            "text": "Alice: Hello there!\nBob: Hi Alice, how are you?",
+            "roles": ["Alice", "Bob", "Narrator"]
+        }
+    )
+    
+    assert response.status_code == 200
+    data = response.json()
+    
+    # Check response structure
+    assert "segments" in data
+    assert isinstance(data["segments"], list)
+    assert len(data["segments"]) > 0
+    
+    # Check each segment has required fields
+    for segment in data["segments"]:
+        assert "id" in segment
+        assert "speaker" in segment
+        assert "text" in segment
+        assert isinstance(segment["id"], str)
+        assert isinstance(segment["speaker"], str)
+        assert isinstance(segment["text"], str)
+        assert len(segment["text"]) > 0
+
+
+def test_script_generation_with_empty_text():
+    """Test that empty text returns validation error."""
+    response = client.post(
+        "/api/tts/script",
+        json={
+            "text": "",
+            "roles": ["Alice", "Bob"]
+        }
+    )
+    
+    assert response.status_code == 400
+    data = response.json()
+    assert "error" in data
+    assert data["error"] == "ValidationError"
+
+
+def test_script_generation_with_empty_roles():
+    """Test that empty roles list returns validation error."""
+    response = client.post(
+        "/api/tts/script",
+        json={
+            "text": "Some text here",
+            "roles": []
+        }
+    )
+    
+    assert response.status_code == 400
+    data = response.json()
+    assert "error" in data
+    assert data["error"] == "ValidationError"
+
+
+def test_script_generation_missing_text_field():
+    """Test that missing text field returns validation error."""
+    response = client.post(
+        "/api/tts/script",
+        json={
+            "roles": ["Alice", "Bob"]
+        }
+    )
+    
+    # Our error handler converts 422 to 400
+    assert response.status_code == 400
+    data = response.json()
+    assert "error" in data
+    assert data["error"] == "ValidationError"
+
+
+def test_script_generation_missing_roles_field():
+    """Test that missing roles field returns validation error."""
+    response = client.post(
+        "/api/tts/script",
+        json={
+            "text": "Some text here"
+        }
+    )
+    
+    # Our error handler converts 422 to 400
+    assert response.status_code == 400
+    data = response.json()
+    assert "error" in data
+    assert data["error"] == "ValidationError"
+
+
+def test_script_segments_have_unique_ids():
+    """Test that each segment has a unique ID."""
+    response = client.post(
+        "/api/tts/script",
+        json={
+            "text": "Alice: Hello!\nBob: Hi!\nAlice: How are you?\nBob: Good!",
+            "roles": ["Alice", "Bob"]
+        }
+    )
+    
+    assert response.status_code == 200
+    data = response.json()
+    
+    segment_ids = [seg["id"] for seg in data["segments"]]
+    # Check all IDs are unique
+    assert len(segment_ids) == len(set(segment_ids))
+
+
+def test_script_generation_with_narrator_text():
+    """Test script generation with narrative text (no role markers)."""
+    response = client.post(
+        "/api/tts/script",
+        json={
+            "text": "The sun was setting over the horizon. It was a beautiful evening.",
+            "roles": ["Narrator"]
+        }
+    )
+    
+    assert response.status_code == 200
+    data = response.json()
+    
+    assert len(data["segments"]) > 0
+    # Should assign to Narrator since no role markers
+    assert any(seg["speaker"] == "Narrator" for seg in data["segments"])
+
+
+def test_script_generation_with_mixed_content():
+    """Test script generation with both dialogue and narrative."""
+    response = client.post(
+        "/api/tts/script",
+        json={
+            "text": "The wizard looked into his crystal ball.\nWizard: I see danger approaching.\nThe knight heard the warning.",
+            "roles": ["Wizard", "Narrator"]
+        }
+    )
+    
+    assert response.status_code == 200
+    data = response.json()
+    
+    assert len(data["segments"]) >= 2
+    speakers = [seg["speaker"] for seg in data["segments"]]
+    # Should have both Wizard and Narrator
+    assert "Wizard" in speakers or "Narrator" in speakers
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v"])

backend/test_segment_based_generation.py

@@ -0,0 +1,164 @@
+"""
+Test for segment-based audiobook generation (Task 19).
+
+Tests that the TTS endpoint can accept edited script segments
+and generate audio from them, while maintaining backward compatibility
+with text-based generation.
+"""
+import pytest
+from fastapi.testclient import TestClient
+from main import app
+
+client = TestClient(app)
+
+
+def test_generate_audiobook_with_segments():
+    """Test that audiobook can be generated from edited script segments."""
+    # Prepare request with segments
+    request_data = {
+        "segments": [
+            {"id": "seg_0", "speaker": "Alice", "text": "Hello, how are you?"},
+            {"id": "seg_1", "speaker": "Bob", "text": "I'm doing great, thanks!"},
+            {"id": "seg_2", "speaker": "Narrator", "text": "They continued their conversation."}
+        ],
+        "lang": "a",
+        "roles": [
+            {"id": "Alice", "voice": "af_bella"},
+            {"id": "Bob", "voice": "am_adam"},
+            {"id": "Narrator", "voice": "af_sarah"}
+        ],
+        "speed": 1.0
+    }
+    
+    response = client.post("/api/tts", json=request_data)
+    
+    # Should succeed
+    assert response.status_code == 200
+    assert response.headers["content-type"] == "audio/wav"
+    assert "audiobook.wav" in response.headers.get("content-disposition", "")
+    assert len(response.content) > 0
+
+
+def test_generate_audiobook_with_text_backward_compatibility():
+    """Test that audiobook generation still works with text (backward compatibility)."""
+    # Prepare request with text (old format)
+    request_data = {
+        "text": "Alice: Hello there!\nBob: Hi Alice!",
+        "lang": "a",
+        "roles": [
+            {"id": "Alice", "voice": "af_bella"},
+            {"id": "Bob", "voice": "am_adam"}
+        ],
+        "speed": 1.0
+    }
+    
+    response = client.post("/api/tts", json=request_data)
+    
+    # Should succeed
+    assert response.status_code == 200
+    assert response.headers["content-type"] == "audio/wav"
+    assert len(response.content) > 0
+
+
+def test_generate_audiobook_segments_take_precedence():
+    """Test that segments are used when both segments and text are provided."""
+    # Prepare request with both segments and text
+    request_data = {
+        "segments": [
+            {"id": "seg_0", "speaker": "Alice", "text": "From segments"}
+        ],
+        "text": "Alice: From text",
+        "lang": "a",
+        "roles": [
+            {"id": "Alice", "voice": "af_bella"}
+        ],
+        "speed": 1.0
+    }
+    
+    response = client.post("/api/tts", json=request_data)
+    
+    # Should succeed and use segments
+    assert response.status_code == 200
+    assert response.headers["content-type"] == "audio/wav"
+
+
+def test_generate_audiobook_missing_both_segments_and_text():
+    """Test that request fails when neither segments nor text is provided."""
+    request_data = {
+        "lang": "a",
+        "roles": [
+            {"id": "Alice", "voice": "af_bella"}
+        ],
+        "speed": 1.0
+    }
+    
+    response = client.post("/api/tts", json=request_data)
+    
+    # Should fail with validation error
+    assert response.status_code == 400
+    assert "ValidationError" in response.json()["error"]
+
+
+def test_generate_audiobook_empty_segments():
+    """Test that request fails when segments array is empty."""
+    request_data = {
+        "segments": [],
+        "lang": "a",
+        "roles": [
+            {"id": "Alice", "voice": "af_bella"}
+        ],
+        "speed": 1.0
+    }
+    
+    response = client.post("/api/tts", json=request_data)
+    
+    # Should fail - empty segments should be treated as not provided
+    assert response.status_code == 400
+
+
+def test_edited_script_preserves_speaker_assignments():
+    """Test that edited speaker assignments in segments are preserved."""
+    # Segments where user has changed speaker assignments
+    request_data = {
+        "segments": [
+            {"id": "seg_0", "speaker": "Bob", "text": "This was originally Alice's line"},
+            {"id": "seg_1", "speaker": "Alice", "text": "This was originally Bob's line"}
+        ],
+        "lang": "a",
+        "roles": [
+            {"id": "Alice", "voice": "af_bella"},
+            {"id": "Bob", "voice": "am_adam"}
+        ],
+        "speed": 1.0
+    }
+    
+    response = client.post("/api/tts", json=request_data)
+    
+    # Should succeed with edited assignments
+    assert response.status_code == 200
+    assert response.headers["content-type"] == "audio/wav"
+    assert len(response.content) > 0
+
+
+def test_segment_with_unmapped_speaker_uses_default():
+    """Test that segments with unmapped speakers fall back to default voice."""
+    request_data = {
+        "segments": [
+            {"id": "seg_0", "speaker": "UnknownSpeaker", "text": "Hello from unknown"}
+        ],
+        "lang": "a",
+        "roles": [
+            {"id": "Alice", "voice": "af_bella"}
+        ],
+        "speed": 1.0
+    }
+    
+    response = client.post("/api/tts", json=request_data)
+    
+    # Should succeed using default voice
+    assert response.status_code == 200
+    assert response.headers["content-type"] == "audio/wav"
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v"])

diagnose_issue.md

@@ -0,0 +1,79 @@
+# Audiobook Generation Issue - Diagnosis
+
+## Problem
+The story is coming out with only one voice (Narrator) instead of multiple voices for different characters.
+
+## Root Cause Analysis
+
+Based on my investigation, I found that:
+
+1. **Ollama IS working correctly** - When I tested with your story, it correctly detected all 3 characters:
+   - Lily
+   - Benny  
+   - Sammy
+
+2. **The backend logs show** that when you used the web interface, it only received 40 characters of text:
+   ```
+   2025-12-09 10:16:52,356 - main - INFO - Role detection requested for text of length 40
+   2025-12-09 10:16:52,358 - main - INFO - Detected 1 roles: ['Narrator']
+   ```
+
+3. **Your full story is 3,749 characters**, so something went wrong in the web interface.
+
+## Possible Causes
+
+### Most Likely: Text wasn't fully pasted or was truncated
+- The web interface might have had an issue with the paste operation
+- The text area might have a character limit
+- There might have been a copy/paste error
+
+### Less Likely: Backend issue
+- The backend is working correctly (I tested it directly)
+- Ollama is running and detecting speakers properly
+
+## Solution Steps
+
+### Step 1: Verify Backend is Running
+```bash
+# Check if backend is running
+curl http://localhost:8001/api/health
+
+# Should return: {"status":"ok"}
+```
+
+### Step 2: Test with the Full Story via API
+I'll create a test script that sends your full story directly to the backend to verify it works end-to-end.
+
+### Step 3: Check Frontend
+If the API works but the web interface doesn't, there might be an issue with:
+- Text area character limits
+- Copy/paste handling
+- Form submission
+
+## Quick Test Script
+
+Run this to test the full workflow with your story:
+
+```bash
+python3 test_full_workflow.py
+```
+
+This will:
+1. Send your full story to the role detection endpoint
+2. Show you what roles are detected
+3. Generate a sample audiobook with different voices
+4. Save it as `test_output.wav`
+
+## Expected Results
+
+When working correctly, you should see:
+- **3-4 roles detected**: Lily, Benny, Sammy, and possibly Narrator
+- **Multiple voices in the audio**: Each character should have a distinct voice
+- **Proper segmentation**: Dialogue should be assigned to the correct character
+
+## Next Steps
+
+1. Try the test script to verify the backend works
+2. If backend works, try the web interface again with the full story
+3. Make sure to paste the ENTIRE story (all 3,749 characters)
+4. Check the browser console for any JavaScript errors

frontend/.env

@@ -1 +1 @@
-VITE_API_BASE_URL=http://localhost:8000
+VITE_API_BASE_URL=http://localhost:8002

frontend/package.json

@@ -15,7 +15,6 @@
   },
   "devDependencies": {
     "@eslint/js": "^9.39.1",
-    "@tailwindcss/postcss": "^4.1.17",
     "@types/node": "^24.10.1",
     "@types/react": "^19.2.5",
     "@types/react-dom": "^19.2.3",
@@ -26,7 +25,7 @@
     "eslint-plugin-react-refresh": "^0.4.24",
     "globals": "^16.5.0",
     "postcss": "^8.5.6",
-    "tailwindcss": "^4.1.17",
+    "tailwindcss": "^3.4.18",
     "typescript": "~5.9.3",
     "typescript-eslint": "^8.46.4",
     "vite": "^7.2.4"

frontend/postcss.config.js

@@ -1,6 +1,6 @@
 export default {
   plugins: {
-    '@tailwindcss/postcss': {},
+    tailwindcss: {},
     autoprefixer: {},
   },
 }

frontend/src/App.css

@@ -1,13 +1,11 @@
-/* Mobile-first responsive styles */
 #root {
   width: 100%;
   margin: 0 auto;
   padding: 0;
 }
 
-/* Ensure touch-friendly interactions */
+button, input, select, textarea {
-.touch-manipulation {
+  transition: all 0.2s ease;
-  touch-action: manipulation;
 }
 
 /* Custom range slider styling for better mobile support */
@@ -17,9 +15,10 @@ input[type="range"] {
   width: 100%;
   height: 8px;
   border-radius: 4px;
-  background: #d1d5db;
+  background: linear-gradient(to right, #667eea, #764ba2);
   outline: none;
   cursor: pointer;
+  box-shadow: 0 2px 8px rgba(102, 126, 234, 0.3);
 }
 
 input[type="range"]::-webkit-slider-thumb {
@@ -28,35 +27,39 @@ input[type="range"]::-webkit-slider-thumb {
   width: 24px;
   height: 24px;
   border-radius: 50%;
-  background: #2563eb;
+  background: linear-gradient(135deg, #667eea, #764ba2);
   cursor: pointer;
-  transition: background 0.15s ease-in-out;
+  box-shadow: 0 4px 12px rgba(102, 126, 234, 0.4);
+  transition: all 0.3s ease;
 }
 
 input[type="range"]::-webkit-slider-thumb:hover {
-  background: #1d4ed8;
+  transform: scale(1.2);
+  box-shadow: 0 6px 16px rgba(102, 126, 234, 0.6);
 }
 
 input[type="range"]::-webkit-slider-thumb:active {
-  background: #1e40af;
+  transform: scale(1.1);
 }
 
 input[type="range"]::-moz-range-thumb {
   width: 24px;
   height: 24px;
   border-radius: 50%;
-  background: #2563eb;
+  background: linear-gradient(135deg, #667eea, #764ba2);
   cursor: pointer;
   border: none;
-  transition: background 0.15s ease-in-out;
+  box-shadow: 0 4px 12px rgba(102, 126, 234, 0.4);
+  transition: all 0.3s ease;
 }
 
 input[type="range"]::-moz-range-thumb:hover {
-  background: #1d4ed8;
+  transform: scale(1.2);
+  box-shadow: 0 6px 16px rgba(102, 126, 234, 0.6);
 }
 
 input[type="range"]::-moz-range-thumb:active {
-  background: #1e40af;
+  transform: scale(1.1);
 }
 
 /* Ensure audio controls are touch-friendly on mobile */

frontend/src/App.tsx

@@ -2,18 +2,24 @@ import { useState } from 'react'
 import './App.css'
 import TextInputSection from './components/TextInputSection'
 import VoiceAssignmentSection from './components/VoiceAssignmentSection'
+import ScriptReviewSection from './components/ScriptReviewSection'
 import AudioPlayerSection from './components/AudioPlayerSection'
-import type { Role } from './api/tts'
+import type { Role, ScriptSegment } from './api/tts'
-import { detectRoles, generateAudiobook } from './api/tts'
+import { detectRoles, generateScript, generateAudiobook } from './api/tts'
+
+type AgeCategory = 'young' | 'teen' | 'adult' | 'old';
 
 function App() {
   const [text, setText] = useState('')
-  const [phase, setPhase] = useState<'input' | 'assignment' | 'generated'>('input')
+  const [phase, setPhase] = useState<'input' | 'assignment' | 'review' | 'generated'>('input')
   const [isLoading, setIsLoading] = useState(false)
   const [roles, setRoles] = useState<Role[]>([])
   const [voiceAssignments, setVoiceAssignments] = useState<Map<string, string>>(new Map())
+  const [ageSettings, setAgeSettings] = useState<Map<string, AgeCategory>>(new Map())
+  const [scriptSegments, setScriptSegments] = useState<ScriptSegment[]>([])
   const [language, setLanguage] = useState('a') // Default: American English
   const [speed, setSpeed] = useState(1.0) // Default: 1.0x
+  const [isGeneratingScript, setIsGeneratingScript] = useState(false)
   const [isGenerating, setIsGenerating] = useState(false)
   const [error, setError] = useState<string | null>(null)
   const [audioUrl, setAudioUrl] = useState<string | null>(null)
@@ -29,6 +35,7 @@ function App() {
     try {
       // Detect roles in the text
       const response = await detectRoles(text)
+      console.log('Detected roles:', response.roles)
       setRoles(response.roles)
       
       // Initialize voice assignments map (empty initially)
@@ -52,6 +59,14 @@ function App() {
     })
   }
 
+  const handleAgeChange = (roleId: string, age: AgeCategory) => {
+    setAgeSettings(prev => {
+      const newMap = new Map(prev)
+      newMap.set(roleId, age)
+      return newMap
+    })
+  }
+
   const handleLanguageChange = (lang: string) => {
     setLanguage(lang)
   }
@@ -60,6 +75,88 @@ function App() {
     setSpeed(newSpeed)
   }
 
+  const handleGenerateScript = async () => {
+    setIsGeneratingScript(true)
+    setError(null)
+    
+    try {
+      // Generate script preview with AI segmentation
+      const roleIds = roles.map(role => role.id)
+      const response = await generateScript({
+        text,
+        roles: roleIds
+      })
+      
+      setScriptSegments(response.segments)
+      
+      // Move to review phase
+      setPhase('review')
+    } catch (err) {
+      setError(err instanceof Error ? err.message : 'Failed to generate script')
+      console.error('Script generation error:', err)
+    } finally {
+      setIsGeneratingScript(false)
+    }
+  }
+
+  const handleSkipReview = async () => {
+    // Skip review and go directly to generation
+    await handleGenerate()
+  }
+
+  const handleSegmentChange = (segmentId: string, newSpeaker: string) => {
+    setScriptSegments(prev => 
+      prev.map(segment => 
+        segment.id === segmentId 
+          ? { ...segment, speaker: newSpeaker }
+          : segment
+      )
+    )
+  }
+
+  const handleSegmentTextChange = (segmentId: string, newText: string) => {
+    setScriptSegments(prev => 
+      prev.map(segment => 
+        segment.id === segmentId 
+          ? { ...segment, text: newText }
+          : segment
+      )
+    )
+  }
+
+  const handleSegmentSplit = (segmentId: string, splitPosition: number) => {
+    setScriptSegments(prev => {
+      const segmentIndex = prev.findIndex(s => s.id === segmentId)
+      if (segmentIndex === -1) return prev
+      
+      const segment = prev[segmentIndex]
+      const firstPart = segment.text.substring(0, splitPosition).trim()
+      const secondPart = segment.text.substring(splitPosition).trim()
+      
+      if (!firstPart || !secondPart) return prev
+      
+      // Create new segments
+      const newSegments = [...prev]
+      newSegments[segmentIndex] = {
+        ...segment,
+        text: firstPart
+      }
+      
+      // Insert second part after the first
+      newSegments.splice(segmentIndex + 1, 0, {
+        id: `${segmentId}-split-${Date.now()}`,
+        speaker: segment.speaker, // Keep same speaker by default
+        text: secondPart
+      })
+      
+      return newSegments
+    })
+  }
+
+  const handleSegmentDelete = (segmentId: string) => {
+    setScriptSegments(prev => prev.filter(segment => segment.id !== segmentId))
+  }
+
   const handleGenerate = async () => {
     setIsGenerating(true)
     setError(null)
@@ -72,8 +169,11 @@ function App() {
       }))
       
       // Generate the audiobook
+      // If we have script segments (from review phase), use them
+      // Otherwise, fall back to text-based generation
       const audioBlob = await generateAudiobook({
-        text,
+        segments: scriptSegments.length > 0 ? scriptSegments : undefined,
+        text: scriptSegments.length > 0 ? undefined : text,
         lang: language,
         roles: rolesArray,
         speed
@@ -112,15 +212,59 @@ function App() {
   const allRolesAssigned = roles.length > 0 && roles.every(role => voiceAssignments.has(role.id))
 
   return (
-    <div className="min-h-screen bg-gray-50">
+    <div className="min-h-screen">
-      <div className="container mx-auto py-4 px-4 sm:py-8 sm:px-6 lg:px-8">
+      <div className="container mx-auto py-12 px-4 sm:px-6 lg:px-8">
-        <h1 className="text-2xl sm:text-3xl md:text-4xl font-bold text-center mb-4 sm:mb-6 md:mb-8">
+        {/* Header */}
-          Text to Audiobook
+        <div className="text-center mb-16 max-w-3xl mx-auto">
-        </h1>
+          <div className="inline-flex items-center justify-center w-20 h-20 bg-gradient-to-br from-indigo-500 to-purple-600 rounded-3xl mb-8 shadow-xl shadow-indigo-500/30">
+            <span className="text-4xl">🎧</span>
+          </div>
+          <h1 className="text-5xl sm:text-6xl md:text-7xl font-black text-gray-900 mb-6 tracking-tight">
+            Text to Audiobook
+          </h1>
+          <p className="text-xl text-gray-600 leading-relaxed">
+            Transform your stories into immersive audio experiences with AI-powered voices
+          </p>
+          
+          {/* Progress Steps */}
+          <div className="mt-12 flex justify-center items-center gap-2">
+            {['Input', 'Voices', 'Review', 'Done'].map((step, index) => {
+              const phases = ['input', 'assignment', 'review', 'generated'];
+              const isActive = phase === phases[index];
+              const isPast = phases.indexOf(phase) > index;
+              
+              return (
+                <div key={step} className="flex items-center">
+                  <div className="flex flex-col items-center">
+                    <div className={`flex items-center justify-center w-12 h-12 rounded-full font-bold text-sm transition-all duration-300 ${
+                      isActive ? 'bg-indigo-600 text-white scale-110 shadow-lg shadow-indigo-500/50' : 
+                      isPast ? 'bg-green-500 text-white' : 
+                      'bg-gray-200 text-gray-500'
+                    }`}>
+                      {isPast ? '✓' : index + 1}
+                    </div>
+                    <span className={`text-xs font-semibold mt-2 ${isActive ? 'text-indigo-600' : 'text-gray-500'}`}>
+                      {step}
+                    </span>
+                  </div>
+                  {index < 3 && (
+                    <div className={`w-16 h-1 mx-3 rounded-full transition-all duration-300 ${isPast || isActive ? 'bg-indigo-600' : 'bg-gray-200'}`}></div>
+                  )}
+                </div>
+              );
+            })}
+          </div>
+        </div>
         
         {error && (
-          <div className="max-w-4xl mx-auto mb-4 p-3 sm:p-4 bg-red-100 border border-red-400 text-red-700 rounded text-sm sm:text-base">
+          <div className="mb-6 p-4 bg-red-50 border border-red-200 text-red-700 rounded-xl">
-            {error}
+            <div className="flex items-start gap-3">
+              <span className="text-xl">⚠️</span>
+              <div>
+                <p className="font-semibold mb-1">Error</p>
+                <p className="text-sm">{error}</p>
+              </div>
+            </div>
           </div>
         )}
         
@@ -137,25 +281,56 @@ function App() {
         {phase === 'assignment' && (
           <>
             {isLongText && (
-              <div className="max-w-4xl mx-auto mb-4 p-3 sm:p-4 bg-yellow-100 border border-yellow-400 text-yellow-800 rounded text-sm sm:text-base">
+              <div className="mb-6 p-4 bg-yellow-50 border border-yellow-200 text-yellow-800 rounded-xl">
-                Generation may take several minutes for very long content.
+                <div className="flex items-center gap-2">
+                  <span>⏱️</span>
+                  <p className="text-sm font-medium">Generation may take several minutes for very long content.</p>
+                </div>
               </div>
             )}
+            {console.log('Rendering VoiceAssignmentSection with roles:', roles, 'allRolesAssigned:', allRolesAssigned)}
             <VoiceAssignmentSection
               roles={roles}
               voiceAssignments={voiceAssignments}
+              ageSettings={ageSettings}
               onVoiceChange={handleVoiceChange}
+              onAgeChange={handleAgeChange}
               language={language}
               onLanguageChange={handleLanguageChange}
               speed={speed}
               onSpeedChange={handleSpeedChange}
-              onGenerate={handleGenerate}
+              onGenerate={handleGenerateScript}
-              isGenerating={isGenerating}
+              onSkipReview={handleSkipReview}
+              isGenerating={isGeneratingScript}
               allRolesAssigned={allRolesAssigned}
             />
           </>
         )}
 
+        {phase === 'review' && (
+          <>
+            {isLongText && (
+              <div className="mb-6 p-4 bg-yellow-50 border border-yellow-200 text-yellow-800 rounded-xl">
+                <div className="flex items-center gap-2">
+                  <span>⏱️</span>
+                  <p className="text-sm font-medium">Generation may take several minutes for very long content.</p>
+                </div>
+              </div>
+            )}
+            <ScriptReviewSection
+              segments={scriptSegments}
+              roles={roles}
+              onSegmentChange={handleSegmentChange}
+              onSegmentTextChange={handleSegmentTextChange}
+              onSegmentSplit={handleSegmentSplit}
+              onSegmentDelete={handleSegmentDelete}
+              onGenerate={handleGenerate}
+              onSkipReview={handleSkipReview}
+              isGenerating={isGenerating}
+            />
+          </>
+        )}
+
         {phase === 'generated' && audioUrl && (
           <AudioPlayerSection
             audioUrl={audioUrl}
@@ -164,8 +339,26 @@ function App() {
         )}
 
         {isGenerating && isLongText && (
-          <div className="max-w-4xl mx-auto mt-4 p-3 sm:p-4 bg-blue-100 border border-blue-400 text-blue-800 rounded text-center text-sm sm:text-base">
+          <div className="mt-6 p-6 bg-blue-50 border border-blue-200 rounded-xl text-center">
-            Generation may take several minutes for very long content. Please be patient...
+            <div className="flex flex-col items-center gap-4">
+              <div className="animate-spin rounded-full h-10 w-10 border-3 border-indigo-600 border-t-transparent"></div>
+              <div>
+                <p className="font-semibold text-gray-900 mb-1">Generating Your Audiobook</p>
+                <p className="text-sm text-gray-600">This may take several minutes. Please be patient...</p>
+              </div>
+            </div>
+          </div>
+        )}
+
+        {isGeneratingScript && (
+          <div className="mt-6 p-6 bg-purple-50 border border-purple-200 rounded-xl text-center">
+            <div className="flex flex-col items-center gap-4">
+              <div className="animate-spin rounded-full h-10 w-10 border-3 border-purple-600 border-t-transparent"></div>
+              <div>
+                <p className="font-semibold text-gray-900 mb-1">Generating Script Preview</p>
+                <p className="text-sm text-gray-600">AI is analyzing your text...</p>
+              </div>
+            </div>
           </div>
         )}
       </div>

frontend/src/api/tts.ts

@@ -29,11 +29,36 @@ export interface RolesResponse {
   roles: Role[];
 }
 
+/**
+ * Represents a script segment with speaker assignment
+ */
+export interface ScriptSegment {
+  id: string;
+  speaker: string;
+  text: string;
+}
+
+/**
+ * Request payload for script generation
+ */
+export interface ScriptRequest {
+  text: string;
+  roles: string[];
+}
+
+/**
+ * Response from the script generation endpoint
+ */
+export interface ScriptResponse {
+  segments: ScriptSegment[];
+}
+
 /**
  * Request payload for audiobook generation
  */
 export interface GenerateRequest {
-  text: string;
+  segments?: ScriptSegment[];
+  text?: string;
   lang: string;
   roles: { id: string; voice: string }[];
   speed?: number;
@@ -188,6 +213,27 @@ export async function detectRoles(text: string): Promise<RolesResponse> {
   return await response.json();
 }
 
+/**
+ * Generate a script preview with AI-segmented text and speaker assignments
+ * @param request - Script request with text and detected roles
+ * @returns Promise resolving to script segments
+ * @throws ApiError if the request fails
+ */
+export async function generateScript(request: ScriptRequest): Promise<ScriptResponse> {
+  const baseUrl = getApiBaseUrl();
+  const url = `${baseUrl}/api/tts/script`;
+  
+  const response = await fetchWithErrorHandling(url, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify(request),
+  });
+  
+  return await response.json();
+}
+
 /**
  * Generate an audiobook from text with assigned voices
  * @param payload - Generation request with text, language, roles, and speed
@@ -209,3 +255,119 @@ export async function generateAudiobook(payload: GenerateRequest): Promise<Blob>
   // Convert response to blob for audio data
   return await response.blob();
 }
+
+/**
+ * TTS Engine information
+ */
+export interface EngineInfo {
+  name: string;
+  active: boolean;
+}
+
+/**
+ * Response from engines endpoint
+ */
+export interface EnginesResponse {
+  engines: EngineInfo[];
+  current: string;
+}
+
+/**
+ * Response from voices endpoint
+ */
+export interface VoicesResponse {
+  voices: {
+    [engine: string]: string[];
+  };
+}
+
+/**
+ * Request payload for voice preview
+ */
+export interface VoicePreviewRequest {
+  voice: string;
+  lang: string;
+  speed?: number;
+  text?: string;
+}
+
+/**
+ * Get available TTS engines
+ * @returns Promise resolving to engines list
+ * @throws ApiError if the request fails
+ */
+export async function getEngines(): Promise<EnginesResponse> {
+  const baseUrl = getApiBaseUrl();
+  const url = `${baseUrl}/api/tts/engines`;
+  
+  const response = await fetchWithErrorHandling(url, {
+    method: 'GET',
+    headers: {
+      'Content-Type': 'application/json',
+    },
+  });
+  
+  return await response.json();
+}
+
+/**
+ * Set the active TTS engine
+ * @param engine - Engine name to activate (kokoro or piper)
+ * @returns Promise resolving to success response
+ * @throws ApiError if the request fails
+ */
+export async function setEngine(engine: string): Promise<{ status: string; engine: string }> {
+  const baseUrl = getApiBaseUrl();
+  const url = `${baseUrl}/api/tts/engines`;
+  
+  const response = await fetchWithErrorHandling(url, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify({ engine }),
+  });
+  
+  return await response.json();
+}
+
+/**
+ * Get available voices for all engines
+ * @returns Promise resolving to voices by engine
+ * @throws ApiError if the request fails
+ */
+export async function getVoices(): Promise<VoicesResponse> {
+  const baseUrl = getApiBaseUrl();
+  const url = `${baseUrl}/api/tts/voices`;
+  
+  const response = await fetchWithErrorHandling(url, {
+    method: 'GET',
+    headers: {
+      'Content-Type': 'application/json',
+    },
+  });
+  
+  return await response.json();
+}
+
+/**
+ * Generate a preview of a voice
+ * @param payload - Preview request with voice, language, and optional speed/text
+ * @returns Promise resolving to audio blob
+ * @throws ApiError if the request fails
+ */
+export async function previewVoice(payload: VoicePreviewRequest): Promise<Blob> {
+  const baseUrl = getApiBaseUrl();
+  const url = `${baseUrl}/api/tts/preview`;
+  
+  const response = await fetchWithErrorHandling(url, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify(payload),
+  });
+  
+  // Convert response to blob for audio data
+  return await response.blob();
+}

frontend/src/components/AudioPlayerSection.tsx

@@ -8,28 +8,50 @@ export default function AudioPlayerSection({
   onDownload
 }: AudioPlayerSectionProps) {
   return (
-    <div className="w-full max-w-4xl mx-auto p-4 sm:p-6">
+    <div className="max-w-4xl mx-auto">
-      <h2 className="text-xl sm:text-2xl font-bold mb-4 sm:mb-6">Your Audiobook is Ready!</h2>
+      <div className="card-modern p-10 sm:p-12 space-y-10">
-      
+        {/* Success Header */}
-      <div className="bg-white rounded-lg shadow-md p-4 sm:p-6 mb-4 sm:mb-6">
+        <div className="text-center">
-        <h3 className="text-base sm:text-lg font-semibold mb-3 sm:mb-4">Listen to your audiobook</h3>
+          <div className="inline-flex items-center justify-center w-24 h-24 bg-gradient-to-br from-green-400 to-emerald-500 rounded-3xl mb-6 shadow-xl shadow-green-500/30">
-        <audio
+            <span className="text-5xl">🎉</span>
-          controls
+          </div>
-          src={audioUrl}
+          <h2 className="text-4xl font-black text-gray-900 mb-4">
-          className="w-full min-h-[44px]"
+            Your Audiobook is Ready!
-          preload="metadata"
+          </h2>
-        >
+          <p className="text-xl text-gray-600">
-          Your browser does not support the audio element.
+            Listen below or download to enjoy offline
-        </audio>
+          </p>
-      </div>
+        </div>
+        
+        {/* Audio Player */}
+        <div className="p-8 bg-gradient-to-br from-indigo-50 via-purple-50 to-pink-50 rounded-2xl border-2 border-indigo-200">
+          <audio
+            controls
+            src={audioUrl}
+            className="w-full"
+            preload="metadata"
+          >
+            Your browser does not support the audio element.
+          </audio>
+        </div>
 
-      <div className="flex justify-center">
+        {/* Download Button */}
-        <button
+        <div className="flex justify-center">
-          onClick={onDownload}
+          <button
-          className="w-full sm:w-auto px-6 py-3 min-h-[44px] bg-green-600 hover:bg-green-700 active:bg-green-800 text-white font-semibold rounded-lg transition-colors cursor-pointer touch-manipulation"
+            onClick={onDownload}
-        >
+            className="btn-primary flex items-center gap-3"
-          Download audiobook
+          >
-        </button>
+            <span className="text-xl">⬇️</span>
+            Download Audiobook
+          </button>
+        </div>
+
+        {/* Success Message */}
+        <div className="p-6 bg-green-50 border-2 border-green-200 text-green-900 rounded-2xl text-center">
+          <p className="font-bold text-lg">
+            ✅ Your audiobook has been successfully generated!
+          </p>
+        </div>
       </div>
     </div>
   );

frontend/src/components/ScriptReviewSection.tsx

@@ -0,0 +1,161 @@
+import type { Role, ScriptSegment } from '../api/tts';
+
+interface ScriptReviewSectionProps {
+  segments: ScriptSegment[];
+  roles: Role[];
+  onSegmentChange: (segmentId: string, newSpeaker: string) => void;
+  onSegmentTextChange: (segmentId: string, newText: string) => void;
+  onSegmentSplit: (segmentId: string, splitPosition: number) => void;
+  onSegmentDelete: (segmentId: string) => void;
+  onGenerate: () => void;
+  onSkipReview: () => void;
+  isGenerating: boolean;
+}
+
+export default function ScriptReviewSection({
+  segments,
+  roles,
+  onSegmentChange,
+  onSegmentTextChange,
+  onSegmentSplit,
+  onSegmentDelete,
+  onGenerate,
+  onSkipReview,
+  isGenerating,
+}: ScriptReviewSectionProps) {
+  const handleSpeakerChange = (segmentId: string, newSpeaker: string) => {
+    onSegmentChange(segmentId, newSpeaker);
+  };
+
+  const handleTextChange = (segmentId: string, newText: string) => {
+    onSegmentTextChange(segmentId, newText);
+  };
+
+  const handleSplit = (segmentId: string, text: string) => {
+    // Find a good split point (after a sentence or quote)
+    const quoteMatch = text.match(/^(.*?[.!?]"?\s*)(.*)/s);
+    if (quoteMatch && quoteMatch[1].length > 0 && quoteMatch[2].length > 0) {
+      onSegmentSplit(segmentId, quoteMatch[1].length);
+      return;
+    }
+    
+    // Fall back to middle split
+    const midPoint = Math.floor(text.length / 2);
+    const splitPoint = text.lastIndexOf(' ', midPoint);
+    if (splitPoint > 0) {
+      onSegmentSplit(segmentId, splitPoint + 1);
+    }
+  };
+
+  return (
+    <div className="max-w-5xl mx-auto">
+      <div className="card-modern p-10 sm:p-12 space-y-10">
+        <div>
+          <h2 className="text-3xl font-bold text-gray-900 mb-3">Review Script</h2>
+          <p className="text-lg text-gray-600">Review and adjust speaker assignments before generating your audiobook.</p>
+        </div>
+
+        {/* Script Segments */}
+        <div className="space-y-6">
+          {segments.map((segment, index) => (
+            <div 
+              key={segment.id} 
+              className="p-6 bg-gradient-to-br from-gray-50 to-white rounded-2xl border-2 border-gray-200 hover:border-indigo-300 transition-all duration-200"
+            >
+              {/* Header */}
+              <div className="flex flex-col sm:flex-row sm:items-center gap-4 mb-4">
+                <div className="flex items-center gap-4">
+                  <div className="flex items-center justify-center w-10 h-10 bg-gradient-to-br from-indigo-500 to-purple-600 text-white rounded-xl font-bold text-sm shadow-lg shadow-indigo-500/30">
+                    {index + 1}
+                  </div>
+                  <span className="text-sm font-bold text-gray-500 uppercase tracking-wide">Segment</span>
+                </div>
+                
+                {/* Speaker Dropdown */}
+                <div className="flex items-center gap-3 flex-1">
+                  <label className="text-base font-bold text-gray-700 whitespace-nowrap">
+                    Speaker:
+                  </label>
+                  <select
+                    value={segment.speaker}
+                    onChange={(e) => handleSpeakerChange(segment.id, e.target.value)}
+                    className="flex-1 p-3 border-2 border-gray-200 rounded-xl focus:border-indigo-500 focus:ring-4 focus:ring-indigo-100 focus:outline-none bg-white font-medium transition-all duration-200"
+                    disabled={isGenerating}
+                  >
+                    {roles.map((role) => (
+                      <option key={role.id} value={role.id}>
+                        {role.label}
+                      </option>
+                    ))}
+                  </select>
+                </div>
+              </div>
+
+              {/* Segment Text */}
+              <textarea
+                value={segment.text}
+                onChange={(e) => handleTextChange(segment.id, e.target.value)}
+                className="w-full p-5 bg-white rounded-xl border-2 border-gray-200 text-gray-800 leading-relaxed text-base focus:border-indigo-500 focus:ring-4 focus:ring-indigo-100 focus:outline-none resize-y min-h-[100px] font-sans"
+                disabled={isGenerating}
+              />
+
+              {/* Action Buttons */}
+              <div className="flex gap-2 mt-4">
+                <button
+                  onClick={() => handleSplit(segment.id, segment.text)}
+                  disabled={isGenerating || segment.text.length < 20}
+                  className="px-4 py-2 text-sm font-semibold text-indigo-600 bg-indigo-50 rounded-lg hover:bg-indigo-100 disabled:opacity-50 disabled:cursor-not-allowed transition-all duration-200 flex items-center gap-2"
+                  title="Split this segment into two parts"
+                >
+                  <span>✂️</span>
+                  Split Segment
+                </button>
+                
+                {segments.length > 1 && (
+                  <button
+                    onClick={() => onSegmentDelete(segment.id)}
+                    disabled={isGenerating}
+                    className="px-4 py-2 text-sm font-semibold text-red-600 bg-red-50 rounded-lg hover:bg-red-100 disabled:opacity-50 disabled:cursor-not-allowed transition-all duration-200 flex items-center gap-2"
+                    title="Delete this segment"
+                  >
+                    <span>🗑️</span>
+                    Delete
+                  </button>
+                )}
+              </div>
+            </div>
+          ))}
+        </div>
+
+        {/* Action Buttons */}
+        <div className="flex flex-col sm:flex-row gap-4 justify-end pt-4">
+          <button
+            onClick={onSkipReview}
+            disabled={isGenerating}
+            className="px-8 py-4 border-2 border-gray-300 text-gray-700 font-semibold rounded-xl hover:bg-gray-50 hover:border-gray-400 disabled:opacity-50 disabled:cursor-not-allowed transition-all duration-200"
+          >
+            Back
+          </button>
+          
+          <button
+            onClick={onGenerate}
+            disabled={isGenerating}
+            className="btn-primary"
+          >
+            {isGenerating ? (
+              <span className="flex items-center gap-3">
+                <div className="animate-spin rounded-full h-5 w-5 border-2 border-white border-t-transparent"></div>
+                Generating...
+              </span>
+            ) : (
+              <span className="flex items-center gap-3">
+                Generate Audiobook
+                <span className="text-lg">✨</span>
+              </span>
+            )}
+          </button>
+        </div>
+      </div>
+    </div>
+  );
+}

frontend/src/components/TextInputSection.tsx

@@ -36,36 +36,59 @@ export default function TextInputSection({
   const isButtonDisabled = disabled || isLoading || text.trim() === '';
 
   return (
-    <div className="w-full max-w-4xl mx-auto p-4 sm:p-6">
+    <div className="max-w-4xl mx-auto">
-      <h2 className="text-xl sm:text-2xl font-bold mb-3 sm:mb-4">Enter Your Text</h2>
+      <div className="card-modern p-10 sm:p-12">
-      
+        <div className="mb-10">
-      <div className="mb-4">
+          <h2 className="text-3xl font-bold text-gray-900 mb-3">Enter Your Text</h2>
-        <textarea
+          <p className="text-lg text-gray-600">Paste or type your story below. Use patterns like "Name:" to mark different speakers.</p>
-          value={text}
-          onChange={handleTextChange}
-          placeholder="Enter your text here. Use patterns like 'Name:' or '[Name]' to mark different speakers..."
-          className="w-full h-64 sm:h-80 md:h-96 p-3 sm:p-4 border-2 border-gray-300 rounded-lg focus:border-blue-500 focus:outline-none resize-y text-sm sm:text-base touch-manipulation"
-          disabled={disabled || isLoading}
-        />
-      </div>
-
-      {showValidation && text.trim() === '' && (
-        <div className="mb-4 p-3 bg-red-100 border border-red-400 text-red-700 rounded text-sm sm:text-base">
-          Please enter some text before proceeding.
         </div>
-      )}
+        
+        <div className="mb-8 relative">
+          <textarea
+            value={text}
+            onChange={handleTextChange}
+            placeholder="Example:
 
-      <button
+Sarah: Hello! How are you today?
-        onClick={handleNext}
+John: I'm doing great, thanks for asking!
-        disabled={isButtonDisabled}
+Sarah: That's wonderful to hear."
-        className={`w-full sm:w-auto px-6 py-3 min-h-[44px] rounded-lg font-semibold text-white transition-colors touch-manipulation ${
+            className="w-full h-96 p-6 border-2 border-gray-200 rounded-2xl focus:border-indigo-500 focus:ring-4 focus:ring-indigo-100 focus:outline-none resize-y text-base leading-relaxed transition-all duration-200 bg-gray-50 focus:bg-white"
-          isButtonDisabled
+            disabled={disabled || isLoading}
-            ? 'bg-gray-400 cursor-not-allowed'
+          />
-            : 'bg-blue-600 hover:bg-blue-700 active:bg-blue-800 cursor-pointer'
+          <div className="absolute bottom-5 right-5 text-sm text-gray-500 bg-white px-4 py-2 rounded-xl border border-gray-200 shadow-sm font-medium">
-        }`}
+            {text.length} characters
-      >
+          </div>
-        {isLoading ? 'Processing...' : 'Next: Assign voices'}
+        </div>
-      </button>
+
+        {showValidation && text.trim() === '' && (
+          <div className="mb-8 p-5 bg-red-50 border-2 border-red-200 text-red-700 rounded-2xl">
+            <div className="flex items-center gap-3">
+              <span className="text-xl">⚠️</span>
+              <p className="font-semibold">Please enter some text before proceeding.</p>
+            </div>
+          </div>
+        )}
+
+        <div className="flex justify-end">
+          <button
+            onClick={handleNext}
+            disabled={isButtonDisabled}
+            className="btn-primary"
+          >
+            {isLoading ? (
+              <span className="flex items-center gap-3">
+                <div className="animate-spin rounded-full h-5 w-5 border-2 border-white border-t-transparent"></div>
+                Processing...
+              </span>
+            ) : (
+              <span className="flex items-center gap-3">
+                Continue
+                <span className="text-lg">→</span>
+              </span>
+            )}
+          </button>
+        </div>
+      </div>
     </div>
   );
 }

frontend/src/components/VoiceAssignmentSection.tsx

@@ -1,14 +1,21 @@
+import { useState, useEffect } from 'react';
 import type { Role } from '../api/tts';
+import { previewVoice, getEngines, setEngine, getVoices } from '../api/tts';
+
+type AgeCategory = 'young' | 'teen' | 'adult' | 'old';
 
 interface VoiceAssignmentSectionProps {
   roles: Role[];
   voiceAssignments: Map<string, string>;
+  ageSettings: Map<string, AgeCategory>;
   onVoiceChange: (roleId: string, voiceId: string) => void;
+  onAgeChange: (roleId: string, age: AgeCategory) => void;
   language: string;
   onLanguageChange: (lang: string) => void;
   speed: number;
   onSpeedChange: (speed: number) => void;
   onGenerate: () => void;
+  onSkipReview?: () => void;
   isGenerating: boolean;
   allRolesAssigned: boolean;
 }
@@ -25,40 +32,272 @@ interface LanguageOption {
   label: string;
 }
 
-// Kokoro voice options as defined in the design document
+// All available Kokoro voice options (54 voices across 9 languages)
 const KOKORO_VOICES: VoiceOption[] = [
+  // American English - Female (11 voices)
+  { id: 'af_alloy', label: 'Alloy (Female, American)', gender: 'female', accent: 'American' },
+  { id: 'af_aoede', label: 'Aoede (Female, American)', gender: 'female', accent: 'American' },
   { id: 'af_bella', label: 'Bella (Female, American)', gender: 'female', accent: 'American' },
+  { id: 'af_heart', label: 'Heart (Female, American)', gender: 'female', accent: 'American' },
+  { id: 'af_jessica', label: 'Jessica (Female, American)', gender: 'female', accent: 'American' },
+  { id: 'af_kore', label: 'Kore (Female, American)', gender: 'female', accent: 'American' },
+  { id: 'af_nicole', label: 'Nicole (Female, American)', gender: 'female', accent: 'American' },
+  { id: 'af_nova', label: 'Nova (Female, American)', gender: 'female', accent: 'American' },
+  { id: 'af_river', label: 'River (Female, American)', gender: 'female', accent: 'American' },
   { id: 'af_sarah', label: 'Sarah (Female, American)', gender: 'female', accent: 'American' },
+  { id: 'af_sky', label: 'Sky (Female, American)', gender: 'female', accent: 'American' },
+  
+  // American English - Male (10 voices)
   { id: 'am_adam', label: 'Adam (Male, American)', gender: 'male', accent: 'American' },
+  { id: 'am_echo', label: 'Echo (Male, American)', gender: 'male', accent: 'American' },
+  { id: 'am_eric', label: 'Eric (Male, American)', gender: 'male', accent: 'American' },
+  { id: 'am_fenrir', label: 'Fenrir (Male, American)', gender: 'male', accent: 'American' },
+  { id: 'am_liam', label: 'Liam (Male, American)', gender: 'male', accent: 'American' },
   { id: 'am_michael', label: 'Michael (Male, American)', gender: 'male', accent: 'American' },
+  { id: 'am_onyx', label: 'Onyx (Male, American)', gender: 'male', accent: 'American' },
+  { id: 'am_puck', label: 'Puck (Male, American)', gender: 'male', accent: 'American' },
+  { id: 'am_santa', label: 'Santa (Male, American)', gender: 'male', accent: 'American' },
+  
+  // British English - Female (4 voices)
+  { id: 'bf_alice', label: 'Alice (Female, British)', gender: 'female', accent: 'British' },
   { id: 'bf_emma', label: 'Emma (Female, British)', gender: 'female', accent: 'British' },
   { id: 'bf_isabella', label: 'Isabella (Female, British)', gender: 'female', accent: 'British' },
+  { id: 'bf_lily', label: 'Lily (Female, British)', gender: 'female', accent: 'British' },
+  
+  // British English - Male (4 voices)
+  { id: 'bm_daniel', label: 'Daniel (Male, British)', gender: 'male', accent: 'British' },
+  { id: 'bm_fable', label: 'Fable (Male, British)', gender: 'male', accent: 'British' },
   { id: 'bm_george', label: 'George (Male, British)', gender: 'male', accent: 'British' },
   { id: 'bm_lewis', label: 'Lewis (Male, British)', gender: 'male', accent: 'British' },
+  
+  // Spanish - Female (1 voice)
+  { id: 'ef_dora', label: 'Dora (Female, Spanish)', gender: 'female', accent: 'Spanish' },
+  
+  // Spanish - Male (2 voices)
+  { id: 'em_alex', label: 'Alex (Male, Spanish)', gender: 'male', accent: 'Spanish' },
+  { id: 'em_santa', label: 'Santa (Male, Spanish)', gender: 'male', accent: 'Spanish' },
+  
+  // French - Female (1 voice)
+  { id: 'ff_siwis', label: 'Siwis (Female, French)', gender: 'female', accent: 'French' },
+  
+  // Hindi - Female (2 voices)
+  { id: 'hf_alpha', label: 'Alpha (Female, Hindi)', gender: 'female', accent: 'Hindi' },
+  { id: 'hf_beta', label: 'Beta (Female, Hindi)', gender: 'female', accent: 'Hindi' },
+  
+  // Hindi - Male (2 voices)
+  { id: 'hm_omega', label: 'Omega (Male, Hindi)', gender: 'male', accent: 'Hindi' },
+  { id: 'hm_psi', label: 'Psi (Male, Hindi)', gender: 'male', accent: 'Hindi' },
+  
+  // Italian - Female (1 voice)
+  { id: 'if_sara', label: 'Sara (Female, Italian)', gender: 'female', accent: 'Italian' },
+  
+  // Italian - Male (1 voice)
+  { id: 'im_nicola', label: 'Nicola (Male, Italian)', gender: 'male', accent: 'Italian' },
+  
+  // Japanese - Female (4 voices)
+  { id: 'jf_alpha', label: 'Alpha (Female, Japanese)', gender: 'female', accent: 'Japanese' },
+  { id: 'jf_gongitsune', label: 'Gongitsune (Female, Japanese)', gender: 'female', accent: 'Japanese' },
+  { id: 'jf_nezumi', label: 'Nezumi (Female, Japanese)', gender: 'female', accent: 'Japanese' },
+  { id: 'jf_tebukuro', label: 'Tebukuro (Female, Japanese)', gender: 'female', accent: 'Japanese' },
+  
+  // Japanese - Male (1 voice)
+  { id: 'jm_kumo', label: 'Kumo (Male, Japanese)', gender: 'male', accent: 'Japanese' },
+  
+  // Portuguese - Female (1 voice)
+  { id: 'pf_dora', label: 'Dora (Female, Portuguese)', gender: 'female', accent: 'Portuguese' },
+  
+  // Portuguese - Male (2 voices)
+  { id: 'pm_alex', label: 'Alex (Male, Portuguese)', gender: 'male', accent: 'Portuguese' },
+  { id: 'pm_santa', label: 'Santa (Male, Portuguese)', gender: 'male', accent: 'Portuguese' },
+  
+  // Chinese/Mandarin - Female (4 voices)
+  { id: 'zf_xiaobei', label: 'Xiaobei (Female, Chinese)', gender: 'female', accent: 'Chinese' },
+  { id: 'zf_xiaoni', label: 'Xiaoni (Female, Chinese)', gender: 'female', accent: 'Chinese' },
+  { id: 'zf_xiaoxiao', label: 'Xiaoxiao (Female, Chinese)', gender: 'female', accent: 'Chinese' },
+  { id: 'zf_xiaoyi', label: 'Xiaoyi (Female, Chinese)', gender: 'female', accent: 'Chinese' },
+  
+  // Chinese/Mandarin - Male (4 voices)
+  { id: 'zm_yunjian', label: 'Yunjian (Male, Chinese)', gender: 'male', accent: 'Chinese' },
+  { id: 'zm_yunxi', label: 'Yunxi (Male, Chinese)', gender: 'male', accent: 'Chinese' },
+  { id: 'zm_yunxia', label: 'Yunxia (Male, Chinese)', gender: 'male', accent: 'Chinese' },
+  { id: 'zm_yunyang', label: 'Yunyang (Male, Chinese)', gender: 'male', accent: 'Chinese' },
 ];
 
-// Language options as defined in the design document
+// Language options - all supported by Kokoro TTS
 const LANGUAGES: LanguageOption[] = [
   { code: 'a', label: 'American English' },
   { code: 'b', label: 'British English' },
-  { code: 'f', label: 'French' },
+  { code: 'e', label: 'Spanish (Español)' },
-  { code: 'j', label: 'Japanese' },
+  { code: 'f', label: 'French (Français)' },
+  { code: 'h', label: 'Hindi (हिन्दी)' },
+  { code: 'i', label: 'Italian (Italiano)' },
+  { code: 'j', label: 'Japanese (日本語)' },
+  { code: 'p', label: 'Portuguese (Português)' },
+  { code: 'z', label: 'Chinese (中文)' },
 ];
 
+// Age category to speed mapping
+const AGE_SPEED_MAP: Record<AgeCategory, number> = {
+  young: 1.15,
+  teen: 1.08,
+  adult: 1.0,
+  old: 0.85,
+};
+
 export default function VoiceAssignmentSection({
   roles,
   voiceAssignments,
+  ageSettings,
   onVoiceChange,
+  onAgeChange,
   language,
   onLanguageChange,
   speed,
   onSpeedChange,
   onGenerate,
+  onSkipReview,
   isGenerating,
   allRolesAssigned,
 }: VoiceAssignmentSectionProps) {
+  const [previewingRole, setPreviewingRole] = useState<string | null>(null);
+  const [audioCache, setAudioCache] = useState<Map<string, string>>(new Map());
+  const [currentEngine, setCurrentEngine] = useState<string>('kokoro');
+  const [availableVoices, setAvailableVoices] = useState<VoiceOption[]>(KOKORO_VOICES);
+  const [isLoadingEngine, setIsLoadingEngine] = useState(false);
+
+  // Load current engine and voices on mount
+  useEffect(() => {
+    const loadEngineInfo = async () => {
+      try {
+        const [enginesData, voicesData] = await Promise.all([
+          getEngines(),
+          getVoices()
+        ]);
+        
+        setCurrentEngine(enginesData.current);
+        
+        // Update available voices based on current engine
+        if (enginesData.current === 'piper' && voicesData.voices.piper) {
+          const piperVoices: VoiceOption[] = voicesData.voices.piper.map(voiceId => ({
+            id: voiceId,
+            label: voiceId.replace(/_/g, ' ').replace(/-/g, ' - '),
+            gender: voiceId.includes('amy') || voiceId.includes('alba') ? 'female' : 'male',
+            accent: voiceId.includes('GB') ? 'British' : 'American'
+          }));
+          setAvailableVoices(piperVoices);
+        } else {
+          setAvailableVoices(KOKORO_VOICES);
+        }
+      } catch (error) {
+        console.error('Failed to load engine info:', error);
+      }
+    };
+    
+    loadEngineInfo();
+  }, []);
+
   const handleVoiceSelect = (roleId: string, voiceId: string) => {
     onVoiceChange(roleId, voiceId);
+    // Clear all cached previews for this role when voice changes
+    setAudioCache(prev => {
+      const newCache = new Map(prev);
+      // Remove all cache entries that start with this roleId
+      Array.from(newCache.keys()).forEach(key => {
+        if (key.startsWith(`${roleId}-`)) {
+          newCache.delete(key);
+        }
+      });
+      return newCache;
+    });
+  };
+
+  const handleAgeSelect = (roleId: string, age: AgeCategory) => {
+    onAgeChange(roleId, age);
+    // Clear all cached previews for this role when age changes
+    setAudioCache(prev => {
+      const newCache = new Map(prev);
+      // Remove all cache entries that start with this roleId
+      Array.from(newCache.keys()).forEach(key => {
+        if (key.startsWith(`${roleId}-`)) {
+          newCache.delete(key);
+        }
+      });
+      return newCache;
+    });
+  };
+
+  const handlePreview = async (roleId: string) => {
+    const voiceId = voiceAssignments.get(roleId);
+    if (!voiceId) return;
+
+    const age = ageSettings.get(roleId) || 'adult';
+    const previewSpeed = AGE_SPEED_MAP[age];
+    const cacheKey = `${roleId}-${voiceId}-${age}`;
+
+    setPreviewingRole(roleId);
+
+    try {
+      // Check cache first
+      let audioUrl = audioCache.get(cacheKey);
+      
+      if (!audioUrl) {
+        // Generate new preview
+        const audioBlob = await previewVoice({
+          voice: voiceId,
+          lang: language,
+          speed: previewSpeed,
+        });
+        
+        audioUrl = URL.createObjectURL(audioBlob);
+        setAudioCache(prev => new Map(prev).set(cacheKey, audioUrl!));
+      }
+
+      // Play the audio
+      if (audioUrl) {
+        const audio = new Audio(audioUrl);
+        audio.onended = () => setPreviewingRole(null);
+        audio.onerror = () => setPreviewingRole(null);
+        await audio.play();
+      }
+    } catch (error) {
+      console.error('Preview failed:', error);
+      setPreviewingRole(null);
+      
+      // Show user-friendly error message
+      if (error instanceof Error) {
+        alert(`Voice preview failed: ${error.message}\n\nIf using Piper TTS, make sure voice models are downloaded. See backend/PIPER_SETUP.md for instructions.`);
+      }
+    }
+  };
+
+  const handleEngineChange = async (engine: string) => {
+    setIsLoadingEngine(true);
+    try {
+      await setEngine(engine);
+      setCurrentEngine(engine);
+      
+      // Load voices for new engine
+      const voicesData = await getVoices();
+      
+      if (engine === 'piper' && voicesData.voices.piper) {
+        const piperVoices: VoiceOption[] = voicesData.voices.piper.map(voiceId => ({
+          id: voiceId,
+          label: voiceId.replace(/_/g, ' ').replace(/-/g, ' - '),
+          gender: voiceId.includes('amy') || voiceId.includes('alba') ? 'female' : 'male',
+          accent: voiceId.includes('GB') ? 'British' : 'American'
+        }));
+        setAvailableVoices(piperVoices);
+      } else {
+        setAvailableVoices(KOKORO_VOICES);
+      }
+      
+      // Clear audio cache when switching engines
+      setAudioCache(new Map());
+    } catch (error) {
+      console.error('Failed to switch engine:', error);
+    } finally {
+      setIsLoadingEngine(false);
+    }
   };
 
   const handleLanguageSelect = (e: React.ChangeEvent<HTMLSelectElement>) => {
@@ -73,93 +312,233 @@ export default function VoiceAssignmentSection({
   const isGenerateDisabled = !allRolesAssigned || isGenerating;
 
   return (
-    <div className="w-full max-w-4xl mx-auto p-4 sm:p-6">
+    <div className="max-w-5xl mx-auto">
-      <h2 className="text-xl sm:text-2xl font-bold mb-4 sm:mb-6">Assign voices to roles</h2>
+      <div className="card-modern p-10 sm:p-12 space-y-10">
+        <div>
+          <h2 className="text-3xl font-bold text-gray-900 mb-3">Assign Voices</h2>
+          <p className="text-lg text-gray-600">Choose a voice for each character in your story.</p>
+        </div>
 
-      {/* Role-to-Voice Mapping Section */}
+        {/* TTS Engine Selector */}
-      <div className="mb-6 sm:mb-8">
+        <div className="p-6 bg-gradient-to-br from-indigo-50 to-purple-50 rounded-2xl border-2 border-indigo-200">
-        <h3 className="text-lg sm:text-xl font-semibold mb-3 sm:mb-4">Voice Assignments</h3>
+          <label className="block text-base font-bold text-gray-900 mb-3">
-        <div className="space-y-3 sm:space-y-4">
+            TTS Engine
-          {roles.map((role) => (
+          </label>
-            <div key={role.id} className="flex flex-col sm:flex-row sm:items-center gap-2 sm:gap-4">
+          <div className="flex gap-4">
-              <label className="font-medium text-gray-700 text-sm sm:text-base sm:w-40">
+            <button
-                {role.label}:
+              onClick={() => handleEngineChange('kokoro')}
-              </label>
+              disabled={isLoadingEngine}
-              <select
+              className={`flex-1 px-6 py-4 rounded-xl font-semibold transition-all duration-200 ${
-                value={voiceAssignments.get(role.id) || ''}
+                currentEngine === 'kokoro'
-                onChange={(e) => handleVoiceSelect(role.id, e.target.value)}
+                  ? 'bg-indigo-600 text-white shadow-lg shadow-indigo-500/30'
-                className="flex-1 p-3 sm:p-2 min-h-[44px] border-2 border-gray-300 rounded-lg focus:border-blue-500 focus:outline-none text-sm sm:text-base touch-manipulation"
+                  : 'bg-white text-gray-700 border-2 border-gray-200 hover:border-indigo-300'
-              >
+              }`}
-                <option value="">Select a voice...</option>
+            >
-                {KOKORO_VOICES.map((voice) => (
+              <div className="text-left">
-                  <option key={voice.id} value={voice.id}>
+                <div className="font-bold">Kokoro TTS</div>
-                    {voice.label}
+                <div className="text-sm opacity-90">High quality, 54 voices</div>
-                  </option>
+              </div>
-                ))}
+            </button>
-              </select>
+            <button
+              onClick={() => handleEngineChange('piper')}
+              disabled={isLoadingEngine}
+              className={`flex-1 px-6 py-4 rounded-xl font-semibold transition-all duration-200 ${
+                currentEngine === 'piper'
+                  ? 'bg-indigo-600 text-white shadow-lg shadow-indigo-500/30'
+                  : 'bg-white text-gray-700 border-2 border-gray-200 hover:border-indigo-300'
+              }`}
+            >
+              <div className="text-left">
+                <div className="font-bold">Piper TTS</div>
+                <div className="text-sm opacity-90">Fast, pitch control</div>
+              </div>
+            </button>
+          </div>
+          {currentEngine === 'piper' && (
+            <div className="mt-3 space-y-2">
+              <div className="p-3 bg-blue-50 border border-blue-200 rounded-lg">
+                <p className="text-sm text-blue-900">
+                  <strong>✨ Pitch Control:</strong> Piper allows you to adjust voice pitch per character (coming soon in UI)
+                </p>
+              </div>
+              <div className="p-3 bg-yellow-50 border border-yellow-300 rounded-lg">
+                <p className="text-sm text-yellow-900">
+                  <strong>⚠️ Setup Required:</strong> Piper voice models must be downloaded manually. 
+                  See <code className="bg-yellow-100 px-1 rounded">backend/PIPER_SETUP.md</code> for instructions.
+                  If voices don't work, you may need to download the model files first.
+                </p>
+              </div>
             </div>
-          ))}
+          )}
+        </div>
+
+        {/* Voice Assignments */}
+        <div className="space-y-5">
+          {roles.map((role, index) => {
+            const selectedAge = ageSettings.get(role.id) || 'adult';
+            const hasVoice = voiceAssignments.has(role.id);
+            const isPreviewing = previewingRole === role.id;
+            
+            return (
+              <div key={role.id} className="p-6 bg-gradient-to-br from-gray-50 to-white rounded-2xl border-2 border-gray-200 hover:border-indigo-300 transition-all duration-200">
+                {/* Header Row */}
+                <div className="flex flex-col sm:flex-row sm:items-center gap-4 mb-4">
+                  <div className="flex items-center gap-4 sm:w-56">
+                    <div className="flex items-center justify-center w-10 h-10 bg-gradient-to-br from-indigo-500 to-purple-600 text-white rounded-xl font-bold text-sm shadow-lg shadow-indigo-500/30">
+                      {index + 1}
+                    </div>
+                    <label className="font-bold text-gray-900 text-lg">
+                      {role.label}
+                    </label>
+                  </div>
+                  <select
+                    value={voiceAssignments.get(role.id) || ''}
+                    onChange={(e) => handleVoiceSelect(role.id, e.target.value)}
+                    className="flex-1 p-4 border-2 border-gray-200 rounded-xl focus:border-indigo-500 focus:ring-4 focus:ring-indigo-100 focus:outline-none bg-white text-base font-medium transition-all duration-200"
+                  >
+                    <option value="">Select a voice...</option>
+                    {availableVoices.map((voice) => (
+                      <option key={voice.id} value={voice.id}>
+                        {voice.label}
+                      </option>
+                    ))}
+                  </select>
+                </div>
+
+                {/* Age Category & Preview Row */}
+                {hasVoice && (
+                  <div className="flex flex-col sm:flex-row gap-4 items-start sm:items-center">
+                    {/* Age Categories */}
+                    <div className="flex-1">
+                      <label className="block text-sm font-semibold text-gray-700 mb-2">
+                        Age Category:
+                      </label>
+                      <div className="flex gap-2 flex-wrap">
+                        {(['young', 'teen', 'adult', 'old'] as AgeCategory[]).map((age) => (
+                          <button
+                            key={age}
+                            onClick={() => handleAgeSelect(role.id, age)}
+                            className={`px-4 py-2 rounded-lg font-semibold text-sm transition-all duration-200 ${
+                              selectedAge === age
+                                ? 'bg-indigo-600 text-white shadow-lg shadow-indigo-500/30'
+                                : 'bg-white text-gray-700 border-2 border-gray-200 hover:border-indigo-300'
+                            }`}
+                          >
+                            {age === 'young' && '👶 Young'}
+                            {age === 'teen' && '🧒 Teen'}
+                            {age === 'adult' && '👤 Adult'}
+                            {age === 'old' && '👴 Old'}
+                          </button>
+                        ))}
+                      </div>
+                      <p className="text-xs text-gray-500 mt-2">
+                        Speed: {AGE_SPEED_MAP[selectedAge]}x
+                      </p>
+                    </div>
+
+                    {/* Preview Button */}
+                    <button
+                      onClick={() => handlePreview(role.id)}
+                      disabled={isPreviewing || isGenerating}
+                      className="px-6 py-3 bg-green-600 text-white font-semibold rounded-xl hover:bg-green-700 disabled:opacity-50 disabled:cursor-not-allowed transition-all duration-200 flex items-center gap-2 shadow-lg shadow-green-500/30"
+                    >
+                      {isPreviewing ? (
+                        <>
+                          <div className="animate-spin rounded-full h-4 w-4 border-2 border-white border-t-transparent"></div>
+                          Playing...
+                        </>
+                      ) : (
+                        <>
+                          <span>🔊</span>
+                          Try Voice
+                        </>
+                      )}
+                    </button>
+                  </div>
+                )}
+              </div>
+            );
+          })}
+        </div>
+
+        {/* Settings Grid */}
+        <div className="grid sm:grid-cols-2 gap-8 pt-4">
+          {/* Language */}
+          <div>
+            <label className="block text-base font-bold text-gray-900 mb-3">
+              Language
+            </label>
+            <select
+              value={language}
+              onChange={handleLanguageSelect}
+              className="w-full p-4 border-2 border-gray-200 rounded-xl focus:border-indigo-500 focus:ring-4 focus:ring-indigo-100 focus:outline-none bg-white text-base font-medium transition-all duration-200"
+            >
+              {LANGUAGES.map((lang) => (
+                <option key={lang.code} value={lang.code}>
+                  {lang.label}
+                </option>
+              ))}
+            </select>
+          </div>
+
+          {/* Speed */}
+          <div>
+            <label className="block text-base font-bold text-gray-900 mb-3">
+              Playback Speed: <span className="text-indigo-600">{speed.toFixed(1)}x</span>
+            </label>
+            <input
+              type="range"
+              min="0.5"
+              max="1.5"
+              step="0.1"
+              value={speed}
+              onChange={handleSpeedChange}
+              className="w-full h-3"
+            />
+            <div className="flex justify-between text-sm text-gray-500 mt-2 font-medium">
+              <span>0.5x</span>
+              <span>1.5x</span>
+            </div>
+          </div>
+        </div>
+
+        {/* Validation Message */}
+        {!allRolesAssigned && !isGenerating && (
+          <div className="p-5 bg-yellow-50 border-2 border-yellow-200 text-yellow-900 rounded-2xl">
+            <p className="font-semibold">⚠️ Please assign voices to all roles before continuing.</p>
+          </div>
+        )}
+
+        {/* Action Buttons */}
+        <div className="flex flex-col sm:flex-row gap-4 justify-end pt-4">
+          {onSkipReview && (
+            <button
+              onClick={onSkipReview}
+              disabled={isGenerateDisabled}
+              className="px-8 py-4 border-2 border-gray-300 text-gray-700 font-semibold rounded-xl hover:bg-gray-50 hover:border-gray-400 disabled:opacity-50 disabled:cursor-not-allowed transition-all duration-200"
+            >
+              Skip Review & Generate
+            </button>
+          )}
+          <button
+            onClick={onGenerate}
+            disabled={isGenerateDisabled}
+            className="btn-primary"
+          >
+            {isGenerating ? (
+              <span className="flex items-center gap-3">
+                <div className="animate-spin rounded-full h-5 w-5 border-2 border-white border-t-transparent"></div>
+                Generating...
+              </span>
+            ) : (
+              <span className="flex items-center gap-3">
+                Continue
+                <span className="text-lg">→</span>
+              </span>
+            )}
+          </button>
         </div>
       </div>
-
-      {/* Language Selector */}
-      <div className="mb-6">
-        <h3 className="text-lg sm:text-xl font-semibold mb-3 sm:mb-4">Language</h3>
-        <select
-          value={language}
-          onChange={handleLanguageSelect}
-          className="w-full p-3 sm:p-2 min-h-[44px] border-2 border-gray-300 rounded-lg focus:border-blue-500 focus:outline-none text-sm sm:text-base touch-manipulation"
-        >
-          {LANGUAGES.map((lang) => (
-            <option key={lang.code} value={lang.code}>
-              {lang.label}
-            </option>
-          ))}
-        </select>
-      </div>
-
-      {/* Speed Slider */}
-      <div className="mb-6 sm:mb-8">
-        <h3 className="text-lg sm:text-xl font-semibold mb-3 sm:mb-4">Playback Speed</h3>
-        <div className="flex items-center gap-2 sm:gap-4">
-          <span className="text-xs sm:text-sm text-gray-600 w-10 sm:w-12">0.5x</span>
-          <input
-            type="range"
-            min="0.5"
-            max="1.5"
-            step="0.1"
-            value={speed}
-            onChange={handleSpeedChange}
-            className="flex-1 h-8 sm:h-auto touch-manipulation"
-          />
-          <span className="text-xs sm:text-sm text-gray-600 w-10 sm:w-12">1.5x</span>
-          <span className="font-semibold text-gray-800 w-12 sm:w-16 text-center text-sm sm:text-base">
-            {speed.toFixed(1)}x
-          </span>
-        </div>
-      </div>
-
-      {/* Generate Button */}
-      <div className="flex justify-center">
-        <button
-          onClick={onGenerate}
-          disabled={isGenerateDisabled}
-          className={`w-full sm:w-auto px-8 py-3 min-h-[44px] rounded-lg font-semibold text-white transition-colors touch-manipulation ${
-            isGenerateDisabled
-              ? 'bg-gray-400 cursor-not-allowed'
-              : 'bg-green-600 hover:bg-green-700 active:bg-green-800 cursor-pointer'
-          }`}
-        >
-          {isGenerating ? 'Generating...' : 'Generate Audiobook'}
-        </button>
-      </div>
-
-      {/* Validation Message */}
-      {!allRolesAssigned && !isGenerating && (
-        <div className="mt-4 p-3 bg-yellow-100 border border-yellow-400 text-yellow-800 rounded text-center text-sm sm:text-base">
-          Please assign voices to all roles before generating the audiobook.
-        </div>
-      )}
     </div>
   );
 }

frontend/src/index.css

@@ -1,15 +1,67 @@
+@import url('https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700;800;900&display=swap');
+
 @tailwind base;
 @tailwind components;
 @tailwind utilities;
 
+* {
+  box-sizing: border-box;
+}
+
 :root {
-  font-family: system-ui, Avenir, Helvetica, Arial, sans-serif;
+  font-family: 'Inter', -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
-  line-height: 1.5;
+  line-height: 1.6;
   font-weight: 400;
+  -webkit-font-smoothing: antialiased;
+  -moz-osx-font-smoothing: grayscale;
 }
 
 body {
   margin: 0;
   min-width: 320px;
   min-height: 100vh;
+  background: linear-gradient(180deg, #f9fafb 0%, #f3f4f6 100%);
+}
+
+@layer utilities {
+  .card-modern {
+    background: white;
+    border-radius: 24px;
+    box-shadow: 0 4px 6px -1px rgba(0, 0, 0, 0.05), 0 2px 4px -1px rgba(0, 0, 0, 0.03);
+    border: 1px solid rgba(0, 0, 0, 0.05);
+    transition: all 0.3s cubic-bezier(0.4, 0, 0.2, 1);
+  }
+  
+  .card-modern:hover {
+    box-shadow: 0 20px 25px -5px rgba(0, 0, 0, 0.08), 0 10px 10px -5px rgba(0, 0, 0, 0.04);
+    transform: translateY(-4px);
+  }
+  
+  .btn-primary {
+    background: linear-gradient(135deg, #6366f1 0%, #8b5cf6 100%);
+    color: white;
+    font-weight: 600;
+    padding: 14px 40px;
+    border-radius: 14px;
+    border: none;
+    cursor: pointer;
+    transition: all 0.3s cubic-bezier(0.4, 0, 0.2, 1);
+    box-shadow: 0 4px 14px rgba(99, 102, 241, 0.4);
+    font-size: 16px;
+  }
+  
+  .btn-primary:hover:not(:disabled) {
+    transform: translateY(-2px);
+    box-shadow: 0 8px 24px rgba(99, 102, 241, 0.5);
+  }
+  
+  .btn-primary:active:not(:disabled) {
+    transform: translateY(0);
+  }
+  
+  .btn-primary:disabled {
+    opacity: 0.6;
+    cursor: not-allowed;
+    transform: none;
+  }
 }

frontend/tailwind.config.js

@@ -5,8 +5,11 @@ export default {
     "./src/**/*.{js,ts,jsx,tsx}",
   ],
   theme: {
-    extend: {},
+    extend: {
+      fontFamily: {
+        sans: ['Inter', 'system-ui', 'sans-serif'],
+      },
+    },
   },
   plugins: [],
 }
-

test_api_directly.py

@@ -0,0 +1,86 @@
+#!/usr/bin/env python3
+"""
+Test the API directly with the full story to verify backend functionality.
+"""
+import requests
+import json
+
+# Read the full story
+with open('Test Story.txt', 'r') as f:
+    story = f.read()
+
+print(f"Story length: {len(story)} characters\n")
+
+# Test 1: Role Detection
+print("=" * 70)
+print("TEST 1: Role Detection")
+print("=" * 70)
+
+response = requests.post(
+    'http://localhost:8002/api/tts/roles',
+    json={'text': story},
+    headers={'Content-Type': 'application/json'}
+)
+
+print(f"Status: {response.status_code}")
+if response.status_code == 200:
+    roles_data = response.json()
+    roles = roles_data['roles']
+    print(f"✓ Detected {len(roles)} roles:")
+    for role in roles:
+        print(f"  - {role['label']}")
+else:
+    print(f"❌ Error: {response.text}")
+    exit(1)
+
+print()
+
+# Test 2: Audio Generation with Multiple Voices
+print("=" * 70)
+print("TEST 2: Audio Generation")
+print("=" * 70)
+
+# Assign different voices to each role
+voice_map = {
+    'Lily': 'af_bella',
+    'Benny': 'am_adam', 
+    'Sammy': 'am_michael',
+    'Narrator': 'af_sarah'
+}
+
+# Build roles array for API
+roles_array = []
+for role in roles:
+    role_id = role['id']
+    voice = voice_map.get(role_id, 'af_bella')
+    roles_array.append({'id': role_id, 'voice': voice})
+    print(f"  {role_id} → {voice}")
+
+print(f"\nGenerating audiobook...")
+
+response = requests.post(
+    'http://localhost:8002/api/tts',
+    json={
+        'text': story,
+        'lang': 'a',
+        'roles': roles_array,
+        'speed': 1.0
+    },
+    headers={'Content-Type': 'application/json'}
+)
+
+print(f"Status: {response.status_code}")
+if response.status_code == 200:
+    # Save the audio file
+    with open('test_output.wav', 'wb') as f:
+        f.write(response.content)
+    print(f"✓ Generated audiobook: {len(response.content)} bytes")
+    print(f"✓ Saved to: test_output.wav")
+    print("\nYou can now play test_output.wav to hear the multi-voice audiobook!")
+else:
+    print(f"❌ Error: {response.text}")
+    exit(1)
+
+print("\n" + "=" * 70)
+print("SUCCESS! Backend is working correctly with full story.")
+print("=" * 70)

test_my_story.py

@@ -0,0 +1,27 @@
+#!/usr/bin/env python3
+import sys
+sys.path.insert(0, 'backend')
+
+import asyncio
+from services.role_detector import RoleDetector
+from services.ollama_service import OllamaService
+
+async def test():
+    # Read the actual story
+    with open('Test Story.txt', 'r') as f:
+        story = f.read()
+    
+    print(f'Story length: {len(story)} characters\n')
+    
+    # Test role detection
+    ollama_service = OllamaService()
+    role_detector = RoleDetector(ollama_service=ollama_service)
+    
+    print('Testing role detection...')
+    roles = await role_detector.detect_roles(story)
+    
+    print(f'\nDetected {len(roles)} roles:')
+    for role in roles:
+        print(f'  - {role["label"]}')
+
+asyncio.run(test())

test_my_story_full.py

@@ -0,0 +1,64 @@
+#!/usr/bin/env python3
+import sys
+sys.path.insert(0, 'backend')
+
+import asyncio
+from services.role_detector import RoleDetector
+from services.tts_service import TTSService
+from services.ollama_service import OllamaService
+
+async def test():
+    # Read the actual story
+    with open('Test Story.txt', 'r') as f:
+        story = f.read()
+    
+    print(f'Story length: {len(story)} characters\n')
+    
+    # Initialize services
+    ollama_service = OllamaService()
+    role_detector = RoleDetector(ollama_service=ollama_service)
+    tts_service = TTSService(ollama_service=ollama_service)
+    
+    # Step 1: Detect roles
+    print('Step 1: Detecting roles...')
+    roles = await role_detector.detect_roles(story)
+    print(f'Detected {len(roles)} roles: {[r["label"] for r in roles]}\n')
+    
+    # Step 2: Assign voices
+    print('Step 2: Assigning voices...')
+    role_voice_map = {
+        'Lily': 'af_bella',
+        'Benny': 'am_adam',
+        'Sammy': 'am_michael',
+        'Narrator': 'af_sarah'
+    }
+    for role, voice in role_voice_map.items():
+        print(f'  {role} → {voice}')
+    print()
+    
+    # Step 3: Test AI segmentation
+    print('Step 3: Testing AI segmentation...')
+    segments = await tts_service.segment_text_with_ai(story, role_voice_map)
+    
+    if segments is None:
+        print('❌ AI segmentation returned None!')
+        print('Falling back to pattern-based segmentation...')
+        segments = tts_service.segment_text(story, role_voice_map)
+    
+    print(f'Generated {len(segments)} segments\n')
+    
+    # Analyze segments
+    speaker_counts = {}
+    for speaker, voice, text in segments:
+        speaker_counts[speaker] = speaker_counts.get(speaker, 0) + 1
+    
+    print('Segments per speaker:')
+    for speaker, count in sorted(speaker_counts.items(), key=lambda x: x[1], reverse=True):
+        print(f'  {speaker}: {count} segments')
+    
+    print('\nFirst 5 segments:')
+    for i, (speaker, voice, text) in enumerate(segments[:5], 1):
+        preview = text[:80] + '...' if len(text) > 80 else text
+        print(f'  {i}. [{speaker}] {preview}')
+
+asyncio.run(test())

test_ollama_quick.py

@@ -0,0 +1,24 @@
+#!/usr/bin/env python3
+import sys
+sys.path.insert(0, 'backend')
+
+import asyncio
+from services.ollama_service import OllamaService
+
+async def test():
+    service = OllamaService()
+    available = await service.is_available()
+    print(f'Ollama available: {available}')
+    
+    if available:
+        text = '''Lily asked, "Have you guys heard about the new stream?"
+Benny's eyes lit up. "Ooh, I love streams!"
+Sammy nodded enthusiastically. "I've been wanting to explore!"'''
+        
+        print(f'\nTesting with sample text ({len(text)} chars)...')
+        speakers = await service.detect_speakers(text)
+        print(f'Detected speakers: {speakers}')
+    else:
+        print('Ollama is not available!')
+
+asyncio.run(test())