new design

.claude/settings.local.json

@@ -1,29 +1,11 @@
 {
   "permissions": {
     "allow": [
-      "Bash(mkdir:*)",
-      "Bash(python:*)",
-      "Bash(rg:*)",
       "WebFetch(domain:huggingface.co)",
-      "WebFetch(domain:huggingface.co)",
-      "WebFetch(domain:huggingface.co)",
-      "Bash(rm:*)",
       "Bash(ls:*)",
+      "Bash(tree:*)",
       "Bash(find:*)",
-      "Bash(npm create:*)",
-      "Bash(npx sv@latest create:*)",
-      "Bash(git pull:*)",
-      "Bash(git add:*)",
-      "Bash(git commit:*)",
-      "Bash(git push:*)",
-      "Bash(grep:*)",
-      "Bash(true)",
-      "Bash(awk:*)",
-      "Bash(git reset:*)",
-      "WebFetch(domain:github.com)",
-      "Bash(timeout:*)",
-      "Bash(git rm:*)",
-      "Bash(chmod:*)"
+      "Bash(mkdir:*)"
     ],
     "deny": []
   }

.gitattributes

@@ -1,35 +0,0 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -16,9 +16,11 @@ parts/
 sdist/
 var/
 wheels/
+share/python-wheels/
 *.egg-info/
 .installed.cfg
 *.egg
+MANIFEST
 
 # Virtual Environment
 venv/
@@ -27,47 +29,86 @@ env/
 .venv
 
 # IDE
-.idea/
 .vscode/
+.idea/
 *.swp
 *.swo
 *~
 .DS_Store
 
-# Logs
-logs/
-*.log
-
-# Data directories
-data/cache/
-data/models/
-data/saves/*.db
-
-# Frontend
-frontend/node_modules/
-frontend/.svelte-kit/
-frontend/build/
-frontend/.env
-frontend/.env.*
-
-# Local settings
-.claude/settings.local.json
-
-# Temporary files
-*.tmp
-*.temp
+# Data and Cache
+data/
+cache/
+*.cache
 .cache/
+tmp/
+temp/
 
 # Model files
 *.bin
 *.pth
 *.pt
-*.gguf
-*.safetensors
 *.onnx
+*.safetensors
+models_cache/
+
+# Generated files
+*.log
+*.png
+*.jpg
+*.jpeg
+*.gif
+*.mp3
+*.wav
+*.glb
+*.obj
+*.fbx
+*.dae
+
+# Secrets
+.env
+.env.local
+secrets.json
 
 # HuggingFace
 .huggingface/
 
+# Gradio
+flagged/
+gradio_cached_examples/
+
+# Testing
+.pytest_cache/
+.coverage
+htmlcov/
+.tox/
+.nox/
+coverage.xml
+*.cover
+.hypothesis/
+
+# Documentation
+docs/_build/
+site/
+
 # OS files
-Thumbs.db
+Thumbs.db
+ehthumbs.db
+Desktop.ini
+.Spotlight-V100
+.Trashes
+
+# Backup files
+*.bak
+*.backup
+*~
+
+# Custom
+/data/users/*
+/data/monsters/*
+/data/models/*
+/data/cache/*
+!/data/users/.gitkeep
+!/data/monsters/.gitkeep
+!/data/models/.gitkeep
+!/data/cache/.gitkeep

CLAUDE.md

@@ -1,235 +0,0 @@
-# CLAUDE.md
-
-This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
-
-## Project Overview
-
-DigiPal is an advanced AI-powered virtual monster companion application built with Streamlit, featuring deep AI conversations using Qwen 2.5 models, Kyutai STT speech recognition, comprehensive monster care systems, sophisticated evolution mechanics, and cutting-edge 3D model generation via OmniGen2 → Hunyuan3D-2.1 → UniRig pipeline. This is a streamlined multi-component system designed for modern deployment with HuggingFace integration.
-
-## Architecture
-
-### Core Technologies
-- **Frontend**: Streamlit with modern cyberpunk UI design
-- **Backend**: FastAPI with WebSocket support for real-time updates
-- **AI Models**: Qwen 2.5-1.5B-Instruct for conversations, Kyutai STT-2.6b-en for speech
-- **3D Pipeline**: OmniGen2 → Hunyuan3D-2.1 → UniRig (text-to-image-to-3D-to-rigged)
-- **Framework**: Python 3.11+ with asyncio for concurrent operations
-- **Database**: SQLite for monster persistence with async operations
-- **Deployment**: Modern architecture with HuggingFace integration, Docker support
-
-### Component Structure
-```
-src/
-├── ai/                         # AI processing components
-│   ├── qwen_processor.py       # Qwen 2.5 conversation engine
-│   └── speech_engine.py        # Kyutai STT speech recognition
-├── core/                       # Core game logic
-│   ├── monster_engine.py       # Monster stats, evolution, persistence
-│   ├── monster_engine_dw1.py   # DW1-aligned monster mechanics (reference)
-│   └── evolution_system.py     # Evolution mechanics
-├── pipelines/                  # 3D generation pipelines
-│   └── opensource_3d_pipeline_v2.py  # Production 3D pipeline: OmniGen2→Hunyuan3D→UniRig
-├── ui/                         # User interface
-│   ├── streamlit_interface.py  # Modern Streamlit interface
-│   └── state_manager.py        # Browser state management
-├── deployment/                 # Deployment optimization
-│   └── zero_gpu_optimizer.py   # Zero GPU resource management
-└── utils/                      # Utilities
-    └── performance_tracker.py  # Performance monitoring
-```
-
-## Development Commands
-
-### Running the Application
-```bash
-# Run complete application (FastAPI + Streamlit)
-python run_digipal.py
-
-# Or run components separately:
-
-# Run FastAPI backend server
-python app.py
-
-# Run Streamlit frontend (in another terminal)
-streamlit run src/ui/streamlit_interface.py
-
-# Run with debug logging
-LOG_LEVEL=DEBUG python app.py
-
-# Run with specific configuration
-API_PORT=8081 python app.py
-
-# Run with MCP enabled
-MCP_ENDPOINT=https://your-mcp-server MCP_API_KEY=your-key python app.py
-```
-
-### Running the Svelte Frontend
-```bash
-# Navigate to frontend directory
-cd frontend
-
-# Install dependencies (first time only)
-npm install
-
-# Run development server
-npm run dev
-
-# Build for production
-npm run build
-
-# Preview production build
-npm run preview
-```
-
-### Docker Development
-```bash
-# Build Docker image
-docker build -t digipal .
-
-# Run Docker container
-docker run -p 7860:7860 digipal
-
-# Run with volume mounting for data persistence
-docker run -p 7860:7860 -v $(pwd)/data:/app/data digipal
-```
-
-### Development Tools
-```bash
-# Code formatting (requires black installation)
-black src/
-
-# Linting (requires ruff installation)  
-ruff src/
-
-# Testing (test suite not yet implemented)
-pytest
-```
-
-## Key Implementation Details
-
-### Monster System
-- **Six-dimensional care system**: health, happiness, hunger, energy, discipline, cleanliness
-- **Real-time stat degradation**: continues even when application is offline
-- **Evolution stages**: egg → baby → child → adult → champion → ultimate
-- **Complex evolution requirements**: age, level, care quality, training, battles, social interaction
-- **Personality types**: friendly, energetic, calm, curious, brave with stat modifiers
-- **DW1 alignment**: Optional mode following Digimon World 1 mechanics
-
-### AI Conversation System
-- **Qwen 2.5 integration** with quantization support (8-bit) for GPU efficiency
-- **Kyutai STT-2.6b-en** for high-quality speech-to-text conversion
-- **Context-aware conversations** with personality-based system prompts
-- **Mood-responsive dialogue** based on current monster stats
-- **Conversation history management** with automatic truncation
-- **Flash Attention 2** optimization when available
-
-### 3D Generation Pipeline
-- **OmniGen2**: Advanced text-to-image generation with multi-view consistency
-- **Hunyuan3D-2.1**: State-of-the-art image-to-3D conversion via official HuggingFace Space API
-- **UniRig**: Automatic 3D model rigging via HuggingFace integration
-- **Complete Pipeline**: text → multi-view images → 3D mesh → rigged model
-- **Fallback Systems**: Graceful degradation when APIs are unavailable
-- **Model caching**: Efficient reuse of generated 3D assets
-- **Async generation**: Non-blocking 3D model creation
-
-### State Management
-- **Async SQLite operations** for monster persistence
-- **Browser state management** for session continuity
-- **Time-based stat updates** calculated from last interaction
-- **Cross-session persistence** maintaining monster state between visits
-
-### Zero GPU Optimization
-- **ZeroGPU decorator usage** with proper function-level application
-- **Resource detection** and optimization for Spaces deployment
-- **Memory management** with CUDA memory tracking
-- **Model quantization** for efficient GPU usage
-- **GPU wrapper functions** for AI model initialization and inference
-
-## Database Schema
-
-Monsters are stored in SQLite with JSON serialization:
-```sql
-CREATE TABLE monsters (
-    id INTEGER PRIMARY KEY AUTOINCREMENT,
-    name TEXT NOT NULL UNIQUE,
-    data TEXT NOT NULL,  -- JSON serialized Monster object
-    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-)
-```
-
-## Environment Variables
-
-### Core Configuration
-- `LOG_LEVEL`: Logging level (DEBUG, INFO, WARNING, ERROR)
-- `SERVER_NAME`: Server hostname (default: 0.0.0.0)
-- `SERVER_PORT`: Server port (default: 7860)
-- `SHARE`: Enable public sharing (true/false)
-- `DEBUG`: Enable debug mode (true/false)
-- `MAX_THREADS`: Maximum Gradio threads (default: 40)
-
-### Feature Toggles (V2)
-- `ENABLE_3D`: Enable 3D generation features (default: true)
-- `ENABLE_AI`: Enable AI conversation features (default: true)
-
-### GPU Configuration
-- `CUDA_VISIBLE_DEVICES`: GPU device selection
-- `TRANSFORMERS_CACHE`: Model cache directory
-- `HF_HOME`: HuggingFace cache directory
-
-### MCP Configuration
-- `MCP_ENDPOINT`: MCP service endpoint URL
-- `MCP_API_KEY`: MCP service authentication key
-
-## Hugging Face Space Configuration
-
-Configured as a Gradio Space with:
-- **SDK**: Gradio 5.34.2
-- **Hardware**: zero-gpu (ZeroGPU for efficient AI inference)
-- **Models**: Qwen/Qwen2.5-1.5B-Instruct, openai/whisper-base
-- **Storage**: medium (for model caching and monster data)
-- **Zero GPU**: @spaces.GPU decorators applied to AI-intensive functions
-
-## ZeroGPU Implementation
-
-The application uses proper ZeroGPU decorator patterns:
-
-```python
-# GPU wrapper functions for AI operations
-@spaces.GPU(duration=120)
-def gpu_generate_response(processor, prompt: str, generation_params: Dict[str, Any]) -> str:
-    # GPU-intensive AI inference
-
-@spaces.GPU(duration=60)  
-def gpu_model_initialization(model_class, model_name: str, **kwargs) -> Any:
-    # GPU-intensive model loading
-```
-
-Key ZeroGPU considerations:
-- Decorators applied at function level, not class level
-- Duration specified based on expected GPU usage time
-- Fallback to CPU operations when GPU not available
-- Wrapper functions handle Spaces environment detection
-
-## MCP (Model Context Protocol) Integration
-
-DigiPal supports MCP for flexible model deployment:
-- **ModelProvider enum**: Includes MCP alongside HUGGINGFACE, LOCAL, and SPACES
-- **MCPFluxWrapper**: Integrates Flux text-to-image models through MCP
-- **Configuration options**: MCP endpoint and API key support
-- **Server mode**: Gradio interface can run as an MCP server
-
-## Project Architecture
-
-### Backend
-- **Unified app.py**: FastAPI server on port 7861 with all features enabled
-- **Gradio Admin**: Running on port 7860 as fallback/admin interface
-- **WebSocket Support**: Real-time updates for stats and model changes
-
-### Frontend
-- **SvelteKit Application**: Located in `/frontend` directory
-- **Voice-First UI**: DigiVice-style interface with voice commands
-- **3D Rendering**: Using Threlte for monster visualization
-- **Cyberpunk-Retro Theme**: Custom styling with neon effects
-
-See [CLAUDE_SVELTE_FRONTEND_GUIDE.md](CLAUDE_SVELTE_FRONTEND_GUIDE.md) for detailed frontend documentation.

DEPLOYMENT.md

@@ -1,213 +0,0 @@
-# DigiPal Deployment Guide
-
-## Quick Start
-
-### Prerequisites
-- Python 3.11+
-- Node.js 18+ (for Svelte frontend, if using)
-- Git
-
-### Installation
-
-1. **Clone the repository:**
-```bash
-git clone <repository-url>
-cd digiPal
-```
-
-2. **Install Python dependencies:**
-```bash
-pip install -r requirements.txt
-```
-
-3. **Set up environment variables (optional):**
-```bash
-export HF_TOKEN="your_huggingface_token"  # For private models/spaces
-export MCP_ENDPOINT="your_mcp_endpoint"   # For MCP integration
-export MCP_API_KEY="your_mcp_key"
-```
-
-### Running DigiPal
-
-#### Option 1: Complete Application (Recommended)
-```bash
-python run_digipal.py
-```
-This starts both the FastAPI backend and Streamlit frontend.
-
-**Access:**
-- **Streamlit UI**: http://localhost:8501
-- **API Backend**: http://localhost:7861
-
-#### Option 2: Manual Startup
-Terminal 1 (Backend):
-```bash
-python app.py
-```
-
-Terminal 2 (Frontend):
-```bash
-streamlit run src/ui/streamlit_interface.py
-```
-
-#### Option 3: Svelte Frontend (Advanced)
-```bash
-# Terminal 1: Start backend
-python app.py
-
-# Terminal 2: Start Svelte frontend
-cd frontend
-npm install
-npm run dev
-```
-
-## Architecture Overview
-
-### Technology Stack
-- **Frontend**: Streamlit (modern cyberpunk UI)
-- **Backend**: FastAPI with WebSocket support
-- **AI Models**: 
-  - Qwen 2.5-1.5B-Instruct (conversations)
-  - Kyutai STT-2.6b-en (speech recognition)
-- **3D Pipeline**: OmniGen2 → Hunyuan3D-2.1 → UniRig
-- **Database**: SQLite with async operations
-
-### API Endpoints
-
-**Monster Management:**
-- `GET /api/monsters` - List all monsters
-- `POST /api/monsters` - Create new monster
-- `GET /api/monsters/{id}` - Get monster details
-- `POST /api/monsters/{id}/action` - Perform care action
-- `POST /api/monsters/{id}/talk` - Send message to monster
-- `POST /api/monsters/{id}/generate-3d` - Generate 3D model
-
-**WebSocket:**
-- `WS /api/monsters/{id}/ws` - Real-time updates
-
-## Configuration
-
-### Environment Variables
-
-| Variable | Description | Default |
-|----------|-------------|---------|
-| `LOG_LEVEL` | Logging level | `INFO` |
-| `API_PORT` | FastAPI backend port | `7861` |
-| `HF_TOKEN` | HuggingFace API token | None |
-| `MCP_ENDPOINT` | MCP service endpoint | None |
-| `MCP_API_KEY` | MCP API key | None |
-
-### Hardware Requirements
-
-**Minimum:**
-- 8GB RAM
-- 4GB free disk space
-- Internet connection (for HuggingFace APIs)
-
-**Recommended:**
-- 16GB RAM
-- NVIDIA GPU with 8GB+ VRAM
-- SSD storage
-- High-speed internet
-
-## 3D Generation Pipeline
-
-The application uses a modern 3D generation pipeline:
-
-1. **Text Input** → User describes their monster
-2. **OmniGen2** → Generates multi-view images
-3. **Hunyuan3D-2.1** → Converts images to 3D mesh
-4. **UniRig** → Automatically rigs the 3D model
-5. **Output** → Fully rigged 3D model ready for animation
-
-### API Integration
-- **OmniGen2**: Via transformers/diffusers pipeline
-- **Hunyuan3D-2.1**: Via official HuggingFace Space API
-- **UniRig**: Via HuggingFace model repository
-
-## Deployment Options
-
-### Local Development
-Use the quick start guide above.
-
-### Docker (Future)
-```bash
-docker build -t digipal .
-docker run -p 7861:7861 -p 8501:8501 digipal
-```
-
-### HuggingFace Spaces
-1. Fork/upload repository to HuggingFace Spaces
-2. Set Space type to "Streamlit"
-3. Configure secrets for HF_TOKEN if needed
-4. Space will auto-deploy
-
-## Troubleshooting
-
-### Common Issues
-
-**Port Already in Use:**
-```bash
-# Change ports
-API_PORT=8081 python app.py
-streamlit run src/ui/streamlit_interface.py --server.port 8502
-```
-
-**Missing Dependencies:**
-```bash
-pip install -r requirements.txt --upgrade
-```
-
-**3D Generation Fails:**
-- Check internet connection
-- Verify HF_TOKEN if using private models
-- Pipeline includes fallback mechanisms
-
-**Streamlit Not Starting:**
-```bash
-pip install streamlit --upgrade
-streamlit --version
-```
-
-### Performance Optimization
-
-**For GPU Systems:**
-- Ensure CUDA is properly installed
-- Models will automatically use GPU when available
-
-**For CPU-Only Systems:**
-- Increase timeout values for 3D generation
-- Consider using smaller model variants
-
-## Monitoring
-
-### Logs
-- Application logs: `logs/digipal.log`
-- Streamlit logs: Console output
-- FastAPI logs: Console output with timestamps
-
-### Health Check
-```bash
-curl http://localhost:7861/health
-```
-
-## Support
-
-For issues and questions:
-1. Check this deployment guide
-2. Review `CLAUDE.md` for development details
-3. Check console logs for error messages
-
-## New Tech Stack Summary
-
-**Replaced:**
-- Gradio → Streamlit (modern UI)
-- Faster Whisper → Kyutai STT-2.6b-en (better accuracy)
-- Complex 3D pipeline → Streamlined OmniGen2→Hunyuan3D→UniRig
-
-**Benefits:**
-- Modern, responsive UI with cyberpunk theme
-- Better speech recognition quality
-- State-of-the-art 3D generation pipeline
-- Simplified deployment and maintenance
-- Better separation of frontend/backend

Dockerfile

@@ -1,38 +0,0 @@
-FROM python:3.11-slim
-
-# Set environment variables
-ENV PYTHONUNBUFFERED=1
-ENV PYTHONDONTWRITEBYTECODE=1
-ENV TRANSFORMERS_CACHE=/app/data/cache
-ENV HF_HOME=/app/data/cache
-
-# Install system dependencies
-RUN apt-get update && apt-get install -y \
-    git \
-    ffmpeg \
-    libsndfile1 \
-    curl \
-    && rm -rf /var/lib/apt/lists/*
-
-# Set working directory
-WORKDIR /app
-
-# Copy requirements and install Python dependencies
-COPY requirements.txt .
-RUN pip install --no-cache-dir -r requirements.txt
-
-# Copy application code
-COPY . .
-
-# Create necessary directories
-RUN mkdir -p data/saves data/models data/cache logs config
-
-# Expose ports for FastAPI backend and Streamlit frontend
-EXPOSE 7861 8501
-
-# Health check - check API server on port 7861
-HEALTHCHECK --interval=30s --timeout=30s --start-period=60s --retries=3 \
-    CMD curl -f http://localhost:7861/health || exit 1
-
-# Run the complete application (FastAPI + Streamlit)
-CMD ["python", "run_digipal.py"]

PROJECT_ARCHITECTURE.md

@@ -1,367 +0,0 @@
-# DigiPal Project Architecture & Documentation
-
-## 🏗️ System Overview
-
-DigiPal is a unified AI monster companion application that combines multiple technologies into a single, cohesive system. The architecture is designed to be modular, scalable, and deployable on Hugging Face Spaces with Zero GPU support.
-
-```
-┌─────────────────────────────────────────────────────────────────┐
-│                        DIGIPAL ECOSYSTEM                        │
-├─────────────────────────────────────────────────────────────────┤
-│                                                                 │
-│  ┌─────────────────┐    ┌─────────────────┐    ┌──────────────┐ │
-│  │   Svelte UI     │    │   FastAPI       │    │   Gradio     │ │
-│  │   (Frontend)    │◄──►│   (Backend)     │◄──►│   (Admin)    │ │
-│  │   Port: 5173    │    │   Port: 7861    │    │   Port: 7860  │ │
-│  └─────────────────┘    └─────────────────┘    └──────────────┘ │
-│           │                       │                       │     │
-│           └───────────────────────┼───────────────────────┘     │
-│                                   │                             │
-│  ┌─────────────────────────────────┼─────────────────────────────┐ │
-│  │                    CORE SYSTEMS                              │ │
-│  │  ┌─────────────┐ ┌─────────────┐ ┌─────────────┐            │ │
-│  │  │   Monster   │ │ Evolution   │ │   State     │            │ │
-│  │  │   Engine    │ │   System    │ │  Manager    │            │ │
-│  │  └─────────────┘ └─────────────┘ └─────────────┘            │ │
-│  └─────────────────────────────────────────────────────────────┘ │
-│                                   │                             │
-│  ┌─────────────────────────────────┼─────────────────────────────┐ │
-│  │                    AI SYSTEMS                                │ │
-│  │  ┌─────────────┐ ┌─────────────┐ ┌─────────────┐            │ │
-│  │  │   Qwen      │ │   Speech    │ │   3D        │            │ │
-│  │  │ Processor   │ │   Engine    │ │ Generation  │            │ │
-│  │  └─────────────┘ └─────────────┘ └─────────────┘            │ │
-│  └─────────────────────────────────────────────────────────────┘ │
-│                                   │                             │
-│  ┌─────────────────────────────────┼─────────────────────────────┐ │
-│  │                 DEPLOYMENT & OPTIMIZATION                    │ │
-│  │  ┌─────────────┐ ┌─────────────┐ ┌─────────────┐            │ │
-│  │  │   Zero GPU  │ │ Performance │ │   Spaces    │            │ │
-│  │  │  Optimizer  │ │  Tracker    │ │ Integration │            │ │
-│  │  └─────────────┘ └─────────────┘ └─────────────┘            │ │
-│  └─────────────────────────────────────────────────────────────┘ │
-└────────────────────────────────────���────────────────────────────┘
-```
-
-## 🚀 How It All Works Together
-
-### 1. **Unified Entry Point: `app.py`**
-The main application orchestrates everything:
-
-```python
-# app.py - The Master Controller
-├── FastAPI Server (Port 7861) - REST API & WebSocket
-├── Gradio Interface (Port 7860) - Admin Panel & Fallback UI
-└── Svelte Frontend (Port 5173) - Modern Web Interface
-```
-
-**Key Features:**
-- **Single Command**: `python app.py` starts everything
-- **Threading**: Gradio runs in separate thread, FastAPI in main thread
-- **Unified State**: All components share the same monster data
-- **Zero GPU Ready**: Automatically detects and optimizes for Hugging Face Spaces
-
-### 2. **Component Breakdown**
-
-#### **Frontend Layer**
-```
-Svelte UI (Port 5173)
-├── Modern, responsive web interface
-├── Real-time monster interactions
-├── 3D model viewer
-├── Voice chat interface
-└── Mini-games and training
-```
-
-#### **Backend Layer**
-```
-FastAPI (Port 7861)
-├── REST API endpoints
-├── WebSocket connections
-├── Monster management
-├── AI processing coordination
-└── 3D generation requests
-```
-
-#### **Admin Layer**
-```
-Gradio (Port 7860)
-├── Admin panel for debugging
-├── Fallback UI if Svelte fails
-├── System monitoring
-├── Direct monster creation
-└── Performance metrics
-```
-
-## 🔧 Core Systems Architecture
-
-### **Monster Engine** (`src/core/monster_engine.py`)
-```python
-class Monster:
-    ├── Stats (health, happiness, hunger, energy)
-    ├── Personality (traits, relationship level)
-    ├── Lifecycle (age, stage, evolution)
-    ├── Conversation history
-    └── 3D model data
-```
-
-### **Evolution System** (`src/core/evolution_system.py`)
-```python
-class EvolutionSystem:
-    ├── Evolution requirements
-    ├── Stage progression logic
-    ├── Special evolution conditions
-    └── Evolution history tracking
-```
-
-### **State Management** (`src/ui/state_manager.py`)
-```python
-class AdvancedStateManager:
-    ├── SQLite database persistence
-    ├── Monster save/load operations
-    ├── Conversation history storage
-    └── Performance metrics tracking
-```
-
-## 🤖 AI Systems Architecture
-
-### **Qwen Processor** (`src/ai/qwen_processor.py`)
-```python
-class QwenProcessor:
-    ├── Text generation for monster responses
-    ├── Personality-aware conversations
-    ├── Emotional impact calculation
-    └── Fallback responses when AI unavailable
-```
-
-### **Speech Engine** (`src/ai/speech_engine.py`)
-```python
-class AdvancedSpeechEngine:
-    ├── Voice-to-text processing
-    ├── Text-to-speech synthesis
-    ├── Real-time audio streaming
-    └── Multiple language support
-```
-
-### **3D Generation** (`src/pipelines/`)
-```python
-# Multiple 3D generation options:
-├── hunyuan3d_pipeline.py - Tencent's Hunyuan3D
-├── opensource_3d_pipeline_v2.py - Production pipeline
-└── Integration with Hugging Face Spaces
-```
-
-## 🚀 Deployment Architecture
-
-### **Local Development**
-```
-┌─────────────┐    ┌─────────────┐    ┌─────────────┐
-│   Svelte    │    │   FastAPI   │    │   Gradio    │
-│   (5173)    │◄──►│   (7861)    │◄──►│   (7860)    │
-└─────────────┘    └─────────────┘    └─────────────┘
-```
-
-### **Hugging Face Spaces Deployment**
-```
-┌─────────────────────────────────────────────────┐
-│              HUGGING FACE SPACES                │
-│  ┌─────────────┐    ┌─────────────┐            │
-│  │   Gradio    │    │   FastAPI   │            │
-│  │   (7860)    │◄──►│   (7861)    │            │
-│  └─────────────┘    └─────────────┘            │
-│           │                     │               │
-│           └─────────────────────┘               │
-│                                                 │
-│  ┌─────────────────────────────────────────────┐ │
-│  │           ZERO GPU OPTIMIZATION             │ │
-│  │  • Dynamic GPU allocation                   │ │
-│  │  • CPU fallback for AI models               │ │
-│  │  • Memory optimization                      │ │
-│  │  • Spaces.GPU decorators                    │ │
-│  └─────────────────────────────────────────────┘ │
-└─────────────────────────────────────────────────┘
-```
-
-## 🔄 Data Flow
-
-### **Monster Creation Flow**
-```
-1. User Input (Svelte/Gradio)
-   ↓
-2. FastAPI Endpoint (/api/monsters)
-   ↓
-3. Monster Engine (Create Monster)
-   ↓
-4. State Manager (Save to Database)
-   ↓
-5. Response (Monster Data + 3D Model)
-```
-
-### **Conversation Flow**
-```
-1. User Message (Text/Voice)
-   ↓
-2. Speech Engine (if voice)
-   ↓
-3. Qwen Processor (AI Response)
-   ↓
-4. Monster State Update
-   ↓
-5. State Manager (Save)
-   ↓
-6. WebSocket Update (Real-time)
-```
-
-### **3D Generation Flow**
-```
-1. Monster Creation/Evolution
-   ↓
-2. 3D Pipeline Selection
-   ↓
-3. Multi-view Image Generation
-   ↓
-4. 3D Model Creation
-   ↓
-5. Texture Generation
-   ↓
-6. Model Optimization
-   ↓
-7. Database Storage
-```
-
-## 🎯 Key Features by Component
-
-### **Svelte Frontend**
-- ✅ Modern, responsive UI
-- ✅ Real-time WebSocket updates
-- ✅ Voice chat interface
-- ✅ 3D model viewer
-- ✅ Mini-games
-- ✅ Mobile-friendly design
-
-### **FastAPI Backend**
-- ✅ RESTful API endpoints
-- ✅ WebSocket real-time updates
-- ✅ Monster CRUD operations
-- ✅ AI processing coordination
-- ✅ 3D generation requests
-- ✅ Performance monitoring
-
-### **Gradio Admin**
-- ✅ Admin panel interface
-- ✅ System monitoring
-- ✅ Direct monster management
-- ✅ Fallback UI
-- ✅ Debugging tools
-
-### **AI Systems**
-- ✅ Qwen 2.5 text generation
-- ✅ Speech-to-text processing
-- ✅ Text-to-speech synthesis
-- ✅ Multiple 3D generation pipelines
-- ✅ Fallback responses
-
-### **Core Systems**
-- ✅ Monster lifecycle management
-- ✅ Evolution system
-- ✅ Personality simulation
-- ✅ State persistence
-- ✅ Performance tracking
-
-## 🚀 Getting Started
-
-### **Local Development**
-```bash
-# 1. Install dependencies
-pip install -r requirements.txt
-
-# 2. Start the application
-python app.py
-
-# 3. Access interfaces:
-# - Svelte UI: http://localhost:5173
-# - API: http://localhost:7861
-# - Gradio Admin: http://localhost:7860
-```
-
-### **Hugging Face Spaces**
-```bash
-# 1. Push to repository
-git push origin main
-
-# 2. Spaces automatically deploys
-# 3. Access via Spaces URL
-```
-
-## 🔧 Configuration
-
-### **Environment Variables**
-```bash
-# Server Configuration
-SERVER_NAME=0.0.0.0
-SERVER_PORT=7860
-API_PORT=7861
-
-# AI Configuration
-MCP_ENDPOINT=your_mcp_endpoint
-MCP_API_KEY=your_api_key
-
-# Performance
-MAX_THREADS=40
-LOG_LEVEL=INFO
-```
-
-### **Zero GPU Optimization**
-```python
-# Automatic detection and optimization
-├── GPU available → Use CUDA
-├── CPU only → Optimize for CPU
-├── Memory constraints → Load smaller models
-└── Spaces environment → Apply @spaces.GPU decorators
-```
-
-## 📊 Performance Monitoring
-
-### **Metrics Tracked**
-- Total interactions
-- Average response time
-- User satisfaction
-- AI model performance
-- 3D generation success rate
-- Memory usage
-- GPU utilization
-
-### **Optimization Features**
-- Dynamic model loading
-- Memory-efficient processing
-- Caching strategies
-- Background updates
-- Graceful fallbacks
-
-## 🎯 Why This Architecture?
-
-### **Unified Experience**
-- Single entry point (`app.py`)
-- Shared state across all components
-- Consistent monster data
-- Real-time synchronization
-
-### **Scalability**
-- Modular component design
-- Independent scaling of services
-- Load balancing ready
-- Cloud deployment optimized
-
-### **Reliability**
-- Multiple UI options (Svelte + Gradio)
-- Fallback mechanisms
-- Error handling
-- Graceful degradation
-
-### **Developer Experience**
-- Clear separation of concerns
-- Well-documented APIs
-- Easy testing
-- Hot reloading support
-
-This architecture ensures that DigiPal is both powerful and maintainable, with all the advanced features you've requested while keeping the codebase organized and easy to understand. 

QUICK_UI_TEST.md

@@ -1,63 +0,0 @@
-# 🎨 Quick UI Test Guide
-
-## See the New DigiPal UI Now!
-
-### Option 1: UI Only Preview (Fastest)
-```bash
-python test_ui.py
-```
-This shows you the new cyberpunk Streamlit interface without needing the backend.
-
-### Option 2: Full Application
-```bash
-python run_digipal.py
-```
-This runs both backend and frontend for full functionality.
-
-## What You'll See
-
-### 🎨 **Modern Cyberpunk Theme:**
-- Dark gradient backgrounds with neon accents
-- Glowing cyan and magenta color scheme
-- Orbitron and Rajdhani fonts for sci-fi feel
-- Animated neon effects on titles and buttons
-
-### 🖥️ **Interface Features:**
-- **Welcome Screen**: Feature overview with holographic styling
-- **Sidebar**: Monster management with neon buttons
-- **Monster Stats**: Holographic containers with progress bars
-- **Chat Interface**: Cyberpunk-styled conversation area
-- **3D Generation**: Modern controls for model creation
-
-### 🚀 **Interactive Elements:**
-- Hover effects on buttons with glow animations
-- Gradient backgrounds that shift and pulse
-- Neon text effects with shadows
-- Holographic containers with backdrop blur
-
-## Access URLs
-
-After starting:
-- **Streamlit UI**: http://localhost:8501
-- **API Backend**: http://localhost:7861 (if running full app)
-
-## Notes
-
-- The UI test mode shows the interface but backend features won't work
-- Create a monster in the sidebar to see the full interface
-- All the cyberpunk styling and animations will be visible
-- The design is optimized for both desktop and tablet viewing
-
-## Troubleshooting
-
-**If Streamlit won't start:**
-```bash
-pip install streamlit --upgrade
-```
-
-**If you see port conflicts:**
-```bash
-STREAMLIT_PORT=8502 python test_ui.py
-```
-
-Enjoy the new futuristic DigiPal experience! 🐉✨

README.md

@@ -1,127 +1,197 @@
 ---
-title: DigiPal Advanced Monster Companion
-emoji: 🐉
+title: DigiPal - AI Monster Companion
+emoji: 🤖  
 colorFrom: purple
-colorTo: blue
-sdk: streamlit
-sdk_version: 1.25.0
-app_file: streamlit_app.py
+colorTo: green
+sdk: gradio
+sdk_version: 4.16.0
+app_file: app.py
 pinned: false
 license: mit
+hardware: zero-gpu
+hf_oauth: true
+hf_oauth_scopes:
+  - read-repos
+  - write-repos
+hf_oauth_expiration_minutes: 480
 models:
-  - Qwen/Qwen2.5-1.5B-Instruct
   - kyutai/stt-2.6b-en
-  - shitao/OmniGen-v1
+  - Qwen/Qwen2.5-0.5B-Instruct
+  - OmniGen2/OmniGen2
   - tencent/Hunyuan3D-2.1
-  - VAST-AI/UniRig
-datasets: []
 tags:
-  - gaming
+  - game
+  - 3d
+  - voice
+  - monster
   - ai-companion
-  - monster-raising
-  - conversation
-  - speech-recognition
-  - 3d-generation
-  - text-to-3d
-  - cyberpunk
-  - streamlit
-suggested_hardware: zero-a10g
-suggested_storage: medium
+  - digital-pet
 ---
 
-# 🐉 DigiPal - Advanced AI Monster Companion
+# 🤖 DigiPal: AI-Powered Digital Monster Companion
 
-**The most advanced AI-powered virtual monster companion with cutting-edge 3D generation!**
+<div align="center">
+  
+[![Hugging Face Spaces](https://img.shields.io/badge/🤗%20Hugging%20Face-Spaces-blue)](https://huggingface.co/spaces/your-username/DigiPal)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/)
 
-## 🚀 Revolutionary Features
+[Demo](https://huggingface.co/spaces/your-username/DigiPal) | [Report Bug](https://github.com/your-username/DigiPal/issues) | [Request Feature](https://github.com/your-username/DigiPal/issues)
 
-- 🤖 **Advanced AI Conversations** with Qwen 2.5-1.5B-Instruct
-- 🎤 **High-Quality Speech Recognition** with Kyutai STT-2.6b-en  
-- 🎨 **State-of-the-Art 3D Generation** via OmniGen2 → Hunyuan3D-2.1 → UniRig
-- 📊 **Complex Care System** inspired by Digimon World mechanics
-- 🧬 **Dynamic Evolution** based on care quality and interaction
-- 💬 **Personality-Driven Responses** with emotional intelligence
-- 🎮 **Cyberpunk UI** with neon effects and holographic styling
+</div>
 
-## 🛠️ Technology Stack
+## 🌟 Overview
 
-### AI Models
-- **Conversations**: Qwen 2.5-1.5B-Instruct (quantized for efficiency)
-- **Speech-to-Text**: Kyutai STT-2.6b-en (latest multilingual model)
-- **Text-to-Image**: OmniGen2 (multi-view generation)
-- **Image-to-3D**: Hunyuan3D-2.1 (official Tencent model)
-- **3D Rigging**: UniRig (automatic model rigging)
+DigiPal brings the nostalgic charm of digital pet games into the AI era. Create, train, and evolve unique digital monsters using cutting-edge AI models. Inspired by classic games like Digimon World, DigiPal combines voice interaction, real-time 3D generation, and engaging gameplay mechanics.
 
-### Architecture
-- **Frontend**: Streamlit with cyberpunk theme
-- **Backend**: Integrated FastAPI services
-- **Database**: SQLite with async operations
-- **3D Pipeline**: Complete text → image → 3D → rigged workflow
+### ✨ Key Features
 
-## 🎯 3D Generation Pipeline
+- 🎙️ **Voice Interaction**: Create monsters by describing them with your voice
+- 🖼️ **AI-Powered Generation**: Unique monster designs generated in real-time
+- 🦾 **3D Models**: Automatic conversion from 2D to rigged 3D models
+- 🎮 **Classic Gameplay**: Training, evolution, and care mechanics
+- 💾 **Persistent Storage**: Your monsters are saved across sessions
+- 🤖 **Emoji Communication**: Monsters speak in emojis and numbers
+- 🌐 **Zero GPU Optimized**: Runs efficiently on HuggingFace Spaces
 
-The crown jewel of DigiPal is its revolutionary 3D generation system:
+## 🚀 Getting Started
 
-1. **Text Description** → User describes their monster
-2. **OmniGen2** → Generates consistent multi-view images  
-3. **Hunyuan3D-2.1** → Converts images to high-quality 3D mesh
-4. **UniRig** → Automatically rigs the model for animation
-5. **Result** → Fully rigged 3D model ready for games/animation
+### Online Demo
 
-## 🎮 How to Use
+Visit our [HuggingFace Space](https://huggingface.co/spaces/your-username/DigiPal) to try DigiPal instantly!
 
-1. **Create Your Monster**: Choose name and personality type
-2. **Care & Interact**: Feed, train, play, and talk with your companion
-3. **Watch Evolution**: Your monster grows based on care quality
-4. **Generate 3D Model**: Create a unique 3D representation
-5. **Download & Use**: Get your rigged model for other applications
+### Local Installation
 
-## 🎨 Monster Care System
+```bash
+# Clone the repository
+git clone https://github.com/your-username/DigiPal.git
+cd DigiPal
 
-- **Six Core Stats**: Health, Happiness, Hunger, Energy, Discipline, Cleanliness
-- **Real-Time Degradation**: Stats change even when you're away
-- **Evolution Stages**: Egg → Baby → Child → Adult → Champion → Ultimate
-- **Personality Types**: Friendly, Energetic, Calm, Curious, Brave
-- **Complex Requirements**: Age, level, care quality all matter
+# Install dependencies
+pip install -r requirements.txt
 
-## 💫 Technical Highlights
+# Run the application
+python app.py
+```
 
-- **Zero GPU Optimization**: Efficient model loading and inference
-- **Graceful Fallbacks**: Pipeline continues even if some APIs fail
-- **Real-Time Updates**: WebSocket integration for live stat changes
-- **Model Caching**: Intelligent reuse of generated assets
-- **Cross-Platform**: Works on desktop, tablet, and mobile
+## 🎮 How to Play
 
-## 🔧 Development
+### 1. Create Your Monster
 
-### Local Setup
-```bash
-git clone <repository>
-cd digiPal
-pip install -r requirements.txt
+**Voice Control:**
+- Click the microphone button
+- Describe your ideal monster
+- Example: "Create a fire-breathing dragon with blue scales"
 
-# Run complete application
-python run_digipal.py
+**Visual Control:**
+- Upload reference images
+- Draw your monster concept
+- Use the camera for real-world inspiration
 
-# Or run Streamlit only
-streamlit run streamlit_app.py
-```
+### 2. Train & Evolve
 
-### Environment Variables
-```bash
-HF_TOKEN=your_token          # For private models
-MCP_ENDPOINT=your_endpoint   # For MCP integration
-LOG_LEVEL=INFO              # Logging level
-```
+- Choose training types: Strength, Defense, Speed, Intelligence
+- Complete training sessions to improve stats
+- Meet evolution requirements to unlock new forms
+
+### 3. Care System
+
+- **Feed**: Keep hunger above 30%
+- **Play**: Maintain happiness above 40%
+- **Rest**: Manage fatigue levels
+- **Medicine**: Heal when health drops
+
+### 4. Monster Communication
+
+Your monster communicates using emojis and numbers:
+- 🤖💚 = Happy state
+- 🍖❓ = Hungry
+- 😴💤 = Tired
+- Numbers represent HP and happiness percentages
+
+## 🏗️ Architecture
+
+### AI Pipeline
+
+1. **Speech Recognition**: Kyutai STT for voice commands
+2. **Text Generation**: Qwen2.5 for monster traits
+3. **Image Generation**: OmniGen2 for visual creation
+4. **3D Conversion**: Hunyuan3D for model generation
+5. **Rigging**: Automatic skeleton and animation
+
+### Technology Stack
 
-## 📝 License
+- **Frontend**: Gradio with cyberpunk theming
+- **Backend**: Python with HuggingFace Spaces
+- **AI Models**: State-of-the-art transformers
+- **Storage**: Persistent HF Spaces storage
+- **Optimization**: Zero GPU with intelligent fallbacks
 
-MIT License - Feel free to use, modify, and distribute!
+## 📊 Game Mechanics
+
+### Stats System
+- **HP**: Health points (10-999)
+- **Attack**: Offensive power (5-500)
+- **Defense**: Defensive capability (5-500)
+- **Speed**: Movement and reaction (5-500)
+- **Special**: Magic/unique abilities (5-500)
+
+### Evolution Stages
+1. **Rookie**: Starting form
+2. **Champion**: First evolution (150+ total stats)
+3. **Ultimate**: Advanced form (300+ total stats)
+4. **Mega**: Final evolution (500+ total stats)
+
+### Personality Types
+- Brave, Timid, Aggressive, Gentle
+- Playful, Serious, Loyal, Independent
+- Each affects training preferences and dialogue
+
+## 🛠️ Advanced Features
+
+### Custom Modifications
+
+Modify `core/game_mechanics.py` to:
+- Add new evolution paths
+- Create custom training types
+- Implement new care mechanics
+
+### Model Swapping
+
+Replace AI models in `models/` directory:
+- Use different STT models
+- Try alternative image generators
+- Experiment with 3D converters
 
 ## 🤝 Contributing
 
-Contributions welcome! This project pushes the boundaries of AI companions and 3D generation.
+We welcome contributions! Please see our [Contributing Guide](CONTRIBUTING.md) for details.
+
+1. Fork the repository
+2. Create your feature branch (`git checkout -b feature/AmazingFeature`)
+3. Commit changes (`git commit -m 'Add AmazingFeature'`)
+4. Push to branch (`git push origin feature/AmazingFeature`)
+5. Open a Pull Request
+
+## 📄 License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+## 🙏 Acknowledgments
+
+- Inspired by Digimon World series
+- Built with HuggingFace ecosystem
+- Community feedback and contributions
+- Open-source AI model creators
+
+## 📞 Contact & Support
+
+- **Issues**: [GitHub Issues](https://github.com/your-username/DigiPal/issues)
+- **Discussions**: [HuggingFace Community](https://huggingface.co/spaces/your-username/DigiPal/discussions)
+- **Email**: your-email@example.com
 
 ---
 
-*Experience the future of AI companions with DigiPal! 🐉✨*
+<div align="center">
+Made with ❤️ by the DigiPal Team
+</div>

app.py

@@ -1,468 +1,419 @@
-"""
-DigiPal - Advanced AI Monster Companion with 3D Generation
-Unified application with all features enabled by default
-"""
-
-import asyncio
-import json
-import logging
+import gradio as gr
+import spaces
 import os
-import sys
-from pathlib import Path
-from typing import Dict, Any, Optional, List
-from datetime import datetime
-import uvicorn
-from fastapi import FastAPI, WebSocket, WebSocketDisconnect, HTTPException
-from fastapi.middleware.cors import CORSMiddleware
-from fastapi.responses import JSONResponse
-from pydantic import BaseModel
+import json
 import torch
-from contextlib import asynccontextmanager
-
-# Add src to path
-sys.path.insert(0, os.path.join(os.path.dirname(__file__), 'src'))
-
-# Configure logging
-logging.basicConfig(
-    level=logging.INFO,
-    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
-)
-logger = logging.getLogger(__name__)
-
-# Environment configuration - All features enabled by default
-ENV_CONFIG = {
-    "LOG_LEVEL": os.getenv("LOG_LEVEL", "INFO"),
-    "SERVER_NAME": os.getenv("SERVER_NAME", "0.0.0.0"),
-    "STREAMLIT_PORT": int(os.getenv("STREAMLIT_PORT", "8501")),
-    "API_PORT": int(os.getenv("API_PORT", "7861")),
-    "SHARE": os.getenv("SHARE", "false").lower() == "true",
-    "DEBUG": os.getenv("DEBUG", "false").lower() == "true",
-    "MAX_THREADS": int(os.getenv("MAX_THREADS", "40")),
-    "MCP_ENDPOINT": os.getenv("MCP_ENDPOINT", ""),
-    "MCP_API_KEY": os.getenv("MCP_API_KEY", ""),
-    "HF_TOKEN": os.getenv("HF_TOKEN", "")
-}
-
-# HuggingFace Spaces detection
-IS_SPACES = os.getenv("SPACE_ID") is not None
-
-# API Models
-class CreateMonsterRequest(BaseModel):
-    name: str
-    personality: str
+import gc
+from datetime import datetime
+from pathlib import Path
 
-class MonsterActionRequest(BaseModel):
-    action: str
-    params: Dict[str, Any] = {}
+# Initialize directories
+DATA_DIR = Path("/data") if os.path.exists("/data") else Path("./data")
+DATA_DIR.mkdir(exist_ok=True)
+(DATA_DIR / "users").mkdir(exist_ok=True)
+(DATA_DIR / "monsters").mkdir(exist_ok=True)
+(DATA_DIR / "models").mkdir(exist_ok=True)
+(DATA_DIR / "cache").mkdir(exist_ok=True)
 
-class MonsterTalkRequest(BaseModel):
-    message: str
+# Import modules (to be created)
+from core.ai_pipeline import MonsterGenerationPipeline
+from core.game_mechanics import GameMechanics
+from core.state_manager import StateManager
+from core.auth_manager import AuthManager
+from ui.themes import get_cyberpunk_theme, CYBERPUNK_CSS
+from ui.interfaces import create_voice_interface, create_visual_interface
 
-class Generate3DRequest(BaseModel):
-    description: Optional[str] = None
+# Initialize with GPU optimization
+@spaces.GPU(duration=300)
+def initialize_systems():
+    """Initialize all core systems with GPU"""
+    pipeline = MonsterGenerationPipeline()
+    return pipeline
 
-# Import core modules after environment setup
+# Initialize core systems
 try:
-    from src.core.monster_engine import Monster, MonsterPersonalityType as PersonalityType
-    from src.core.evolution_system import EvolutionSystem
-    from src.ai.qwen_processor import QwenProcessor, ModelConfig
-    from src.ai.speech_engine import AdvancedSpeechEngine as SpeechEngine, SpeechConfig
-    from src.ui.state_manager import AdvancedStateManager as StateManager
-    from src.deployment.zero_gpu_optimizer import get_optimal_device
-    from src.pipelines.opensource_3d_pipeline_v2 import (
-        ProductionPipeline, 
-        ProductionConfig
-    )
-    
-    # UI imports - now using Streamlit (separate process)
-    # from src.ui.streamlit_interface import main as streamlit_main
-except ImportError as e:
-    logger.error(f"Failed to import required modules: {e}")
-    sys.exit(1)
-
-# Initialize FastAPI app
-app = FastAPI(title="DigiPal API", version="1.0.0")
-
-# Add CORS middleware for frontend communication
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],  # In production, replace with specific origins
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
-
-# Global state management
-class AppState:
-    def __init__(self):
-        self.monsters: Dict[str, Monster] = {}
-        self.state_manager = StateManager()
-        self.qwen_processor = None
-        self.speech_engine = None
-        self.evolution_system = EvolutionSystem()
-        self.pipeline_3d = None
-        self.active_connections: Dict[str, WebSocket] = {}
-        self.initialized = False
-        
-    async def initialize(self):
-        """Initialize AI components and pipelines"""
-        if self.initialized:
-            return
-            
-        logger.info("Initializing AI components...")
-        
-        # Initialize AI processors
-        try:
-            # Create Qwen processor config based on available resources
-            qwen_config = ModelConfig(
-                model_name="Qwen/Qwen2.5-1.5B-Instruct",  # Smaller model for Spaces
-                max_memory_gb=4.0,  # Conservative memory usage
-                inference_speed="fast",  # Fast inference for Spaces
-                use_quantization=True,
-                use_flash_attention=True
-            )
-            
-            self.qwen_processor = QwenProcessor(qwen_config)
-            
-            # Create speech engine config for Kyutai STT
-            speech_config = SpeechConfig(
-                model_name="kyutai/stt-2.6b-en",  # Kyutai STT model
-                device="auto",  # Auto-detect device
-                torch_dtype="float32",  # Use float32 for better compatibility
-                use_vad=True,
-                vad_aggressiveness=2,
-                use_pipeline=True  # Use pipeline for easier integration
-            )
-            
-            self.speech_engine = SpeechEngine(speech_config)
-            
-            # Initialize 3D pipeline
-            logger.info("Using production pipeline for 3D generation")
-            pipeline_config = ProductionConfig(
-                hf_token=ENV_CONFIG.get("HF_TOKEN"),  # Use proper HF_TOKEN
-                device="cuda" if torch.cuda.is_available() else "cpu"
-            )
-            
-            self.pipeline_3d = ProductionPipeline(pipeline_config)
-            
-            self.initialized = True
-            logger.info("All components initialized successfully")
-            
-        except Exception as e:
-            logger.error(f"Failed to initialize components: {e}")
-            raise
-
-# Create global app state
-app_state = AppState()
-
-# Lifespan event handler
-@asynccontextmanager
-async def lifespan(app: FastAPI):
-    """Lifespan event handler for FastAPI"""
-    # Startup
-    await app_state.initialize()
-    yield
-    # Shutdown
-    pass
-
-# Update app with lifespan
-app.router.lifespan_context = lifespan
-
-# WebSocket connection manager
-class ConnectionManager:
-    def __init__(self):
-        self.active_connections: Dict[str, WebSocket] = {}
-        
-    async def connect(self, websocket: WebSocket, monster_id: str):
-        await websocket.accept()
-        self.active_connections[monster_id] = websocket
-        
-    def disconnect(self, monster_id: str):
-        if monster_id in self.active_connections:
-            del self.active_connections[monster_id]
-            
-    async def send_update(self, monster_id: str, data: dict):
-        if monster_id in self.active_connections:
-            try:
-                await self.active_connections[monster_id].send_json(data)
-            except:
-                self.disconnect(monster_id)
+    pipeline = initialize_systems()
+except Exception as e:
+    print(f"GPU initialization failed, falling back to CPU: {e}")
+    pipeline = MonsterGenerationPipeline(device="cpu")
 
-manager = ConnectionManager()
+game_mechanics = GameMechanics()
+state_manager = StateManager(DATA_DIR)
+auth_manager = AuthManager()
 
-# API Endpoints
-@app.get("/health")
-async def health_check():
-    """Health check endpoint"""
-    return {"status": "healthy", "initialized": app_state.initialized}
-
-@app.get("/api/monsters")
-async def list_monsters():
-    """List all available saved monsters"""
-    try:
-        saved_monsters = await app_state.state_manager.list_saved_monsters()
-        return {"monsters": saved_monsters}
-    except Exception as e:
-        logger.error(f"Error listing monsters: {e}")
-        raise HTTPException(status_code=500, detail=str(e))
-
-@app.post("/api/monsters")
-async def create_monster(request: CreateMonsterRequest):
-    """Create a new monster"""
-    try:
-        # Create new monster
-        personality = PersonalityType[request.personality.upper()]
-        monster = Monster(name=request.name, personality=personality)
-        
-        # Save to state
-        app_state.monsters[monster.id] = monster
-        
-        # Save to database
-        await app_state.state_manager.save_monster(monster)
-        
-        return {
-            "id": monster.id,
-            "name": monster.name,
-            "personality": monster.personality.value,
-            "stage": monster.stage.value,
-            "stats": monster.get_stats()
-        }
-    except Exception as e:
-        logger.error(f"Error creating monster: {e}")
-        raise HTTPException(status_code=500, detail=str(e))
-
-@app.get("/api/monsters/{monster_id}")
-async def get_monster(monster_id: str):
-    """Load a specific monster's full state"""
-    try:
-        # Check if already loaded
-        if monster_id in app_state.monsters:
-            monster = app_state.monsters[monster_id]
-        else:
-            # Load from database
-            monster = await app_state.state_manager.load_monster_by_id(monster_id)
-            if not monster:
-                raise HTTPException(status_code=404, detail="Monster not found")
-            app_state.monsters[monster_id] = monster
-        
+# Main generation function
+@spaces.GPU(duration=180)
+def generate_monster(oauth_profile, audio_input=None, text_input=None, reference_images=None, 
+                    training_focus="balanced", care_level="normal"):
+    """Generate a new monster with AI pipeline"""
+    
+    if oauth_profile is None:
         return {
-            "id": monster.id,
-            "name": monster.name,
-            "personality": monster.personality.value,
-            "stage": monster.stage.value,
-            "stats": monster.get_stats(),
-            "model_url": monster.model_url,
-            "conversation_history": monster.conversation_history[-10:]  # Last 10 messages
+            "message": "🔒 Please log in to create monsters!",
+            "image": None,
+            "model_3d": None,
+            "stats": None,
+            "dialogue": None
         }
-    except HTTPException:
-        raise
-    except Exception as e:
-        logger.error(f"Error loading monster: {e}")
-        raise HTTPException(status_code=500, detail=str(e))
-
-@app.post("/api/monsters/{monster_id}/action")
-async def perform_action(monster_id: str, request: MonsterActionRequest):
-    """Perform a care action on the monster"""
+    
+    user_id = oauth_profile.username if hasattr(oauth_profile, 'username') else str(oauth_profile)
+    
     try:
-        if monster_id not in app_state.monsters:
-            raise HTTPException(status_code=404, detail="Monster not found")
-        
-        monster = app_state.monsters[monster_id]
-        result = {}
-        
-        # Handle different actions
-        if request.action == "feed":
-            food_type = request.params.get("food_type", "balanced")
-            result = monster.feed(food_type)
-        elif request.action == "train":
-            training_type = request.params.get("training_type", "strength")
-            result = monster.train(training_type)
-        elif request.action == "play":
-            result = monster.play()
-        elif request.action == "clean":
-            result = monster.clean()
-        elif request.action == "heal":
-            result = monster.heal()
-        elif request.action == "discipline":
-            result = monster.discipline()
-        elif request.action == "rest":
-            result = monster.rest()
-        else:
-            raise HTTPException(status_code=400, detail=f"Unknown action: {request.action}")
-        
-        # Save state
-        await app_state.state_manager.save_monster(monster)
+        # Generate monster using AI pipeline
+        result = pipeline.generate_monster(
+            audio_input=audio_input,
+            text_input=text_input,
+            reference_images=reference_images,
+            user_id=user_id
+        )
         
-        # Send real-time update
-        await manager.send_update(monster_id, {
-            "type": "stats_update",
-            "stats": monster.get_stats(),
-            "stage": monster.stage.value
+        # Create game monster from AI result
+        monster = game_mechanics.create_monster(result, {
+            "training_focus": training_focus,
+            "care_level": care_level
         })
         
+        # Save to persistent storage
+        state_manager.save_monster(user_id, monster)
+        
+        # Prepare response
         return {
-            "success": True,
-            "result": result,
-            "stats": monster.get_stats()
+            "message": f"✨ {monster.name} has been created!",
+            "image": result.get('image'),
+            "model_3d": result.get('model_3d'),
+            "stats": monster.get_stats_display(),
+            "dialogue": result.get('dialogue', "🤖💚1️⃣0️⃣0️⃣")
         }
-    except HTTPException:
-        raise
-    except Exception as e:
-        logger.error(f"Error performing action: {e}")
-        raise HTTPException(status_code=500, detail=str(e))
-
-@app.post("/api/monsters/{monster_id}/talk")
-async def talk_to_monster(monster_id: str, request: MonsterTalkRequest):
-    """Send a text message to the monster"""
-    try:
-        if monster_id not in app_state.monsters:
-            raise HTTPException(status_code=404, detail="Monster not found")
-        
-        monster = app_state.monsters[monster_id]
-        
-        # Use MCP if available, otherwise use local processor
-        if ENV_CONFIG["MCP_ENDPOINT"] and hasattr(app_state.qwen_processor, 'use_mcp'):
-            response = await app_state.qwen_processor.generate_response_mcp(
-                monster, request.message
-            )
-        else:
-            response = app_state.qwen_processor.generate_response(
-                monster, request.message
-            )
-        
-        # Update conversation history
-        monster.conversation_history.append({
-            "role": "user",
-            "content": request.message,
-            "timestamp": datetime.now().isoformat()
-        })
-        monster.conversation_history.append({
-            "role": "assistant", 
-            "content": response,
-            "timestamp": datetime.now().isoformat()
-        })
-        
-        # Save state
-        await app_state.state_manager.save_monster(monster)
         
+    except Exception as e:
+        print(f"Error generating monster: {str(e)}")
+        # Use fallback generation
+        fallback_result = pipeline.fallback_generation(text_input or "friendly digital creature")
         return {
-            "response": response,
-            "stats": monster.get_stats()
+            "message": "⚡ Created using quick generation mode",
+            "image": fallback_result.get('image'),
+            "model_3d": None,
+            "stats": fallback_result.get('stats'),
+            "dialogue": "🤖❓9️⃣9️⃣"
         }
-    except HTTPException:
-        raise
-    except Exception as e:
-        logger.error(f"Error talking to monster: {e}")
-        raise HTTPException(status_code=500, detail=str(e))
 
-@app.post("/api/monsters/{monster_id}/generate-3d")
-async def generate_3d_model(monster_id: str, request: Generate3DRequest):
-    """Trigger 3D model generation for the monster"""
-    try:
-        if monster_id not in app_state.monsters:
-            raise HTTPException(status_code=404, detail="Monster not found")
-        
-        monster = app_state.monsters[monster_id]
-        
-        # Generate description if not provided
-        if not request.description:
-            description = f"A {monster.personality.value} {monster.stage.value} digital monster"
-        else:
-            description = request.description
-        
-        # Generate 3D model
-        logger.info(f"Generating 3D model for {monster.name}: {description}")
-        model_path = await app_state.pipeline_3d.generate_3d_model(
-            prompt=description,
-            output_path=f"data/models/{monster_id}/model.glb"
+# Training function
+def train_monster(oauth_profile, training_type, intensity):
+    """Train the active monster"""
+    
+    if oauth_profile is None:
+        return "🔒 Please log in to train monsters!", None, None
+    
+    user_id = oauth_profile.username if hasattr(oauth_profile, 'username') else str(oauth_profile)
+    current_monster = state_manager.get_current_monster(user_id)
+    
+    if not current_monster:
+        return "❌ No active monster to train!", None, None
+    
+    # Apply training
+    result = game_mechanics.train_monster(current_monster, training_type, intensity)
+    
+    if result['success']:
+        state_manager.update_monster(user_id, current_monster)
+        return (
+            result['message'],
+            current_monster.get_stats_display(),
+            result.get('evolution_check')
         )
-        
-        # Update monster with model URL
-        monster.model_url = f"/models/{monster_id}/{Path(model_path).name}"
-        await app_state.state_manager.save_monster(monster)
-        
-        # Send update via WebSocket
-        await manager.send_update(monster_id, {
-            "type": "model_update",
-            "model_url": monster.model_url
-        })
-        
-        return {
-            "success": True,
-            "model_url": monster.model_url
-        }
-    except HTTPException:
-        raise
-    except Exception as e:
-        logger.error(f"Error generating 3D model: {e}")
-        raise HTTPException(status_code=500, detail=str(e))
+    else:
+        return result['message'], None, None
 
-@app.websocket("/api/monsters/{monster_id}/ws")
-async def websocket_endpoint(websocket: WebSocket, monster_id: str):
-    """WebSocket endpoint for real-time updates"""
-    await manager.connect(websocket, monster_id)
+# Care functions
+def feed_monster(oauth_profile, food_type):
+    """Feed the active monster"""
     
-    try:
-        # Send initial stats
-        if monster_id in app_state.monsters:
-            monster = app_state.monsters[monster_id]
-            await websocket.send_json({
-                "type": "initial_state",
-                "stats": monster.get_stats(),
-                "stage": monster.stage.value,
-                "model_url": monster.model_url
-            })
+    if oauth_profile is None:
+        return "🔒 Please log in to care for monsters!"
+    
+    user_id = oauth_profile.username if hasattr(oauth_profile, 'username') else str(oauth_profile)
+    current_monster = state_manager.get_current_monster(user_id)
+    
+    if not current_monster:
+        return "❌ No active monster to feed!"
+    
+    result = game_mechanics.feed_monster(current_monster, food_type)
+    state_manager.update_monster(user_id, current_monster)
+    
+    return result['message']
+
+# Build the Gradio interface
+with gr.Blocks(
+    theme=get_cyberpunk_theme(),
+    css=CYBERPUNK_CSS,
+    title="DigiPal - Digital Monster Companion"
+) as demo:
+    
+    # Header with cyberpunk styling
+    gr.HTML("""
+        <div class="cyber-header">
+            <h1 class="glitch-text">🤖 DigiPal 🤖</h1>
+            <p class="cyber-subtitle">Your AI-Powered Digital Monster Companion</p>
+            <div class="pulse-line"></div>
+        </div>
+    """)
+    
+    # Authentication
+    with gr.Row():
+        login_btn = gr.LoginButton("🔐 Connect to Digital World", size="lg")
+        logout_btn = gr.LogoutButton("🔌 Disconnect", size="sm")
+        user_display = gr.Markdown("", elem_classes=["user-status"])
+    
+    # Main interface tabs
+    with gr.Tabs(elem_classes=["cyber-tabs"]):
+        
+        # Monster Creation Tab
+        with gr.TabItem("🧬 Create Monster", elem_classes=["cyber-tab-content"]):
+            with gr.Row():
+                # Input Column
+                with gr.Column(scale=1):
+                    gr.Markdown("### 🎙️ Voice Input")
+                    audio_input = gr.Audio(
+                        label="Describe your monster",
+                        sources=["microphone", "upload"],
+                        type="filepath",
+                        elem_classes=["cyber-input"]
+                    )
+                    
+                    gr.Markdown("### 💬 Text Input")
+                    text_input = gr.Textbox(
+                        label="Or type a description",
+                        placeholder="Describe your ideal digital monster...",
+                        lines=3,
+                        elem_classes=["cyber-input"]
+                    )
+                    
+                    gr.Markdown("### 🖼️ Reference Images")
+                    reference_images = gr.File(
+                        label="Upload reference images (optional)",
+                        file_count="multiple",
+                        file_types=["image"],
+                        elem_classes=["cyber-input"]
+                    )
+                    
+                    with gr.Row():
+                        training_focus = gr.Radio(
+                            choices=["balanced", "strength", "defense", "speed", "intelligence"],
+                            label="Training Focus",
+                            value="balanced",
+                            elem_classes=["cyber-radio"]
+                        )
+                    
+                    generate_btn = gr.Button(
+                        "⚡ Generate Monster",
+                        variant="primary",
+                        size="lg",
+                        elem_classes=["cyber-button", "generate-button"]
+                    )
+                
+                # Output Column
+                with gr.Column(scale=1):
+                    generation_message = gr.Markdown("", elem_classes=["cyber-message"])
+                    
+                    monster_image = gr.Image(
+                        label="Monster Appearance",
+                        type="pil",
+                        elem_classes=["monster-display"]
+                    )
+                    
+                    monster_model = gr.Model3D(
+                        label="3D Model",
+                        height=400,
+                        elem_classes=["monster-display"]
+                    )
+                    
+                    monster_dialogue = gr.Textbox(
+                        label="Monster Says",
+                        interactive=False,
+                        elem_classes=["cyber-dialogue"]
+                    )
+                    
+                    monster_stats = gr.JSON(
+                        label="Stats",
+                        elem_classes=["cyber-stats"]
+                    )
         
-        # Keep connection alive and handle stat degradation
-        while True:
-            await asyncio.sleep(30)  # Update every 30 seconds
-            
-            if monster_id in app_state.monsters:
-                monster = app_state.monsters[monster_id]
-                monster.update_time_based_stats()
+        # Monster Status Tab
+        with gr.TabItem("📊 Monster Status", elem_classes=["cyber-tab-content"]):
+            with gr.Row():
+                with gr.Column():
+                    current_monster_display = gr.Model3D(
+                        label="Your Digital Monster",
+                        height=400,
+                        elem_classes=["monster-display"]
+                    )
+                    
+                    monster_communication = gr.Textbox(
+                        label="Monster Communication",
+                        placeholder="Your monster speaks in emojis and numbers...",
+                        interactive=False,
+                        elem_classes=["cyber-dialogue"]
+                    )
                 
-                await websocket.send_json({
-                    "type": "stats_update",
-                    "stats": monster.get_stats(),
-                    "stage": monster.stage.value
-                })
+                with gr.Column():
+                    stats_display = gr.JSON(
+                        label="Current Stats",
+                        elem_classes=["cyber-stats"]
+                    )
+                    
+                    care_metrics = gr.JSON(
+                        label="Care Status",
+                        elem_classes=["cyber-stats"]
+                    )
+                    
+                    evolution_progress = gr.HTML(
+                        elem_classes=["evolution-display"]
+                    )
+                    
+                    refresh_btn = gr.Button(
+                        "🔄 Refresh Status",
+                        elem_classes=["cyber-button"]
+                    )
+        
+        # Training Tab
+        with gr.TabItem("💪 Training", elem_classes=["cyber-tab-content"]):
+            with gr.Row():
+                with gr.Column():
+                    training_type = gr.Radio(
+                        choices=["Strength", "Defense", "Speed", "Intelligence", "Special"],
+                        label="Training Type",
+                        value="Strength",
+                        elem_classes=["cyber-radio"]
+                    )
+                    
+                    training_intensity = gr.Slider(
+                        minimum=1,
+                        maximum=10,
+                        value=5,
+                        step=1,
+                        label="Training Intensity",
+                        elem_classes=["cyber-slider"]
+                    )
+                    
+                    train_btn = gr.Button(
+                        "🏋️ Start Training",
+                        variant="primary",
+                        elem_classes=["cyber-button"]
+                    )
                 
-    except WebSocketDisconnect:
-        manager.disconnect(monster_id)
-
-# Streamlit interface runs separately
-# Use: streamlit run src/ui/streamlit_interface.py
-
-# Main entry point
-if __name__ == "__main__":
-    # Create necessary directories
-    os.makedirs("data/saves", exist_ok=True)
-    os.makedirs("data/models", exist_ok=True)
-    os.makedirs("data/cache", exist_ok=True)
-    os.makedirs("logs", exist_ok=True)
-    
-    # Log startup info
-    logger.info("=" * 60)
-    logger.info("DigiPal - Advanced AI Monster Companion")
-    logger.info("=" * 60)
-    logger.info(f"Environment: {'HuggingFace Spaces' if IS_SPACES else 'Local'}")
-    logger.info(f"FastAPI Backend Port: {ENV_CONFIG['API_PORT']}")
-    logger.info(f"Streamlit UI: Run separately on port {ENV_CONFIG['STREAMLIT_PORT']}")
-    logger.info(f"MCP Enabled: {bool(ENV_CONFIG['MCP_ENDPOINT'])}")
-    logger.info("=" * 60)
+                with gr.Column():
+                    training_result = gr.Textbox(
+                        label="Training Result",
+                        interactive=False,
+                        elem_classes=["cyber-output"]
+                    )
+                    
+                    updated_stats = gr.JSON(
+                        label="Updated Stats",
+                        elem_classes=["cyber-stats"]
+                    )
+                    
+                    evolution_check = gr.HTML(
+                        elem_classes=["evolution-display"]
+                    )
+        
+        # Care Tab
+        with gr.TabItem("❤️ Care", elem_classes=["cyber-tab-content"]):
+            with gr.Row():
+                with gr.Column():
+                    gr.Markdown("### 🍖 Feeding")
+                    food_type = gr.Radio(
+                        choices=["Meat", "Fish", "Vegetable", "Treat", "Medicine"],
+                        label="Select Food",
+                        value="Meat",
+                        elem_classes=["cyber-radio"]
+                    )
+                    
+                    feed_btn = gr.Button(
+                        "🍽️ Feed Monster",
+                        elem_classes=["cyber-button"]
+                    )
+                    
+                    feeding_result = gr.Textbox(
+                        label="Feeding Result",
+                        interactive=False,
+                        elem_classes=["cyber-output"]
+                    )
+                
+                with gr.Column():
+                    gr.Markdown("### 🎮 Interaction")
+                    
+                    play_btn = gr.Button(
+                        "🎾 Play",
+                        elem_classes=["cyber-button"]
+                    )
+                    
+                    praise_btn = gr.Button(
+                        "👏 Praise",
+                        elem_classes=["cyber-button"]
+                    )
+                    
+                    scold_btn = gr.Button(
+                        "👎 Scold",
+                        elem_classes=["cyber-button"]
+                    )
+                    
+                    interaction_result = gr.Textbox(
+                        label="Monster Response",
+                        interactive=False,
+                        elem_classes=["cyber-output"]
+                    )
     
-    # Start FastAPI server only
-    # Streamlit interface runs separately via: streamlit run src/ui/streamlit_interface.py
-    logger.info("Starting FastAPI backend server...")
-    logger.info(f"Streamlit UI: Run 'streamlit run src/ui/streamlit_interface.py' in another terminal")
+    # Event handlers
+    generate_btn.click(
+        fn=generate_monster,
+        inputs=[
+            gr.State(lambda: gr.Request().username if hasattr(gr.Request(), 'username') else None),
+            audio_input,
+            text_input,
+            reference_images,
+            training_focus,
+            gr.State("normal")  # care_level
+        ],
+        outputs=[
+            generation_message,
+            monster_image,
+            monster_model,
+            monster_stats,
+            monster_dialogue
+        ]
+    )
     
-    config = uvicorn.Config(
-        app,
-        host=ENV_CONFIG["SERVER_NAME"],
-        port=ENV_CONFIG["API_PORT"],
-        log_level=ENV_CONFIG["LOG_LEVEL"].lower()
+    train_btn.click(
+        fn=train_monster,
+        inputs=[
+            gr.State(lambda: gr.Request().username if hasattr(gr.Request(), 'username') else None),
+            training_type,
+            training_intensity
+        ],
+        outputs=[
+            training_result,
+            updated_stats,
+            evolution_check
+        ]
     )
-    server = uvicorn.Server(config)
     
-    # Run FastAPI server
-    asyncio.run(server.serve())
+    feed_btn.click(
+        fn=feed_monster,
+        inputs=[
+            gr.State(lambda: gr.Request().username if hasattr(gr.Request(), 'username') else None),
+            food_type
+        ],
+        outputs=[feeding_result]
+    )
+
+# Launch the app
+if __name__ == "__main__":
+    demo.queue(
+        default_concurrency_limit=10,
+        max_size=100
+    ).launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        show_api=False,
+        show_error=True
+    )

core/ai_pipeline.py

@@ -0,0 +1,309 @@
+import spaces
+import torch
+import gc
+import os
+from typing import Optional, List, Dict, Any
+from datetime import datetime
+from pathlib import Path
+import numpy as np
+from PIL import Image
+import tempfile
+
+# Model imports (to be implemented)
+from models.stt_processor import KyutaiSTTProcessor
+from models.text_generator import QwenTextGenerator  
+from models.image_generator import OmniGenImageGenerator
+from models.model_3d_generator import Hunyuan3DGenerator
+from models.rigging_processor import UniRigProcessor
+from utils.fallbacks import FallbackManager
+from utils.caching import ModelCache
+
+class MonsterGenerationPipeline:
+    """Main AI pipeline for monster generation"""
+    
+    def __init__(self, device: str = "cuda"):
+        self.device = device if torch.cuda.is_available() else "cpu"
+        self.cache = ModelCache()
+        self.fallback_manager = FallbackManager()
+        self.models = {}
+        self.model_loaded = {
+            'stt': False,
+            'text_gen': False,
+            'image_gen': False,
+            '3d_gen': False,
+            'rigging': False
+        }
+        
+        # Pipeline configuration
+        self.config = {
+            'max_retries': 3,
+            'timeout': 180,
+            'enable_caching': True,
+            'low_vram_mode': True
+        }
+    
+    def _cleanup_memory(self):
+        """Clear GPU memory"""
+        if self.device == "cuda":
+            torch.cuda.empty_cache()
+            torch.cuda.synchronize()
+        gc.collect()
+    
+    def _lazy_load_model(self, model_type: str):
+        """Lazy loading with memory optimization"""
+        if self.model_loaded[model_type]:
+            return self.models[model_type]
+        
+        # Clear memory before loading new model
+        self._cleanup_memory()
+        
+        try:
+            if model_type == 'stt':
+                self.models['stt'] = KyutaiSTTProcessor(device=self.device)
+            elif model_type == 'text_gen':
+                self.models['text_gen'] = QwenTextGenerator(device=self.device)
+            elif model_type == 'image_gen':
+                self.models['image_gen'] = OmniGenImageGenerator(device=self.device)
+            elif model_type == '3d_gen':
+                self.models['3d_gen'] = Hunyuan3DGenerator(device=self.device)
+            elif model_type == 'rigging':
+                self.models['rigging'] = UniRigProcessor(device=self.device)
+            
+            self.model_loaded[model_type] = True
+            return self.models[model_type]
+            
+        except Exception as e:
+            print(f"Failed to load {model_type}: {e}")
+            return None
+    
+    def _unload_model(self, model_type: str):
+        """Unload model to free memory"""
+        if model_type in self.models and self.model_loaded[model_type]:
+            if hasattr(self.models[model_type], 'to'):
+                self.models[model_type].to('cpu')
+            del self.models[model_type]
+            self.model_loaded[model_type] = False
+            self._cleanup_memory()
+    
+    @spaces.GPU(duration=300)
+    def generate_monster(self, 
+                        audio_input: Optional[str] = None,
+                        text_input: Optional[str] = None,
+                        reference_images: Optional[List] = None,
+                        user_id: str = None) -> Dict[str, Any]:
+        """Main monster generation pipeline"""
+        
+        generation_log = {
+            'user_id': user_id,
+            'timestamp': datetime.now().isoformat(),
+            'stages_completed': [],
+            'fallbacks_used': [],
+            'success': False
+        }
+        
+        try:
+            # Stage 1: Speech to Text (if audio provided)
+            description = ""
+            if audio_input and os.path.exists(audio_input):
+                try:
+                    stt_model = self._lazy_load_model('stt')
+                    if stt_model:
+                        description = stt_model.transcribe(audio_input)
+                        generation_log['stages_completed'].append('stt')
+                    else:
+                        raise Exception("STT model failed to load")
+                except Exception as e:
+                    print(f"STT failed: {e}")
+                    description = text_input or "Create a friendly digital monster"
+                    generation_log['fallbacks_used'].append('stt')
+                finally:
+                    # Unload STT to free memory
+                    self._unload_model('stt')
+            else:
+                description = text_input or "Create a friendly digital monster"
+            
+            # Stage 2: Generate monster characteristics
+            monster_traits = {}
+            monster_dialogue = ""
+            try:
+                text_gen = self._lazy_load_model('text_gen')
+                if text_gen:
+                    monster_traits = text_gen.generate_traits(description)
+                    monster_dialogue = text_gen.generate_dialogue(monster_traits)
+                    generation_log['stages_completed'].append('text_gen')
+                else:
+                    raise Exception("Text generation model failed to load")
+            except Exception as e:
+                print(f"Text generation failed: {e}")
+                monster_traits, monster_dialogue = self.fallback_manager.handle_text_gen_failure(description)
+                generation_log['fallbacks_used'].append('text_gen')
+            finally:
+                self._unload_model('text_gen')
+            
+            # Stage 3: Generate monster image
+            monster_image = None
+            try:
+                image_gen = self._lazy_load_model('image_gen')
+                if image_gen:
+                    # Create enhanced prompt from traits
+                    image_prompt = self._create_image_prompt(description, monster_traits)
+                    monster_image = image_gen.generate(
+                        prompt=image_prompt,
+                        reference_images=reference_images,
+                        width=512,
+                        height=512
+                    )
+                    generation_log['stages_completed'].append('image_gen')
+                else:
+                    raise Exception("Image generation model failed to load")
+            except Exception as e:
+                print(f"Image generation failed: {e}")
+                monster_image = self.fallback_manager.handle_image_gen_failure(description)
+                generation_log['fallbacks_used'].append('image_gen')
+            finally:
+                self._unload_model('image_gen')
+            
+            # Stage 4: Convert to 3D model
+            model_3d = None
+            model_3d_path = None
+            try:
+                model_3d_gen = self._lazy_load_model('3d_gen')
+                if model_3d_gen and monster_image:
+                    model_3d = model_3d_gen.image_to_3d(monster_image)
+                    # Save 3D model
+                    model_3d_path = self._save_3d_model(model_3d, user_id)
+                    generation_log['stages_completed'].append('3d_gen')
+                else:
+                    raise Exception("3D generation failed")
+            except Exception as e:
+                print(f"3D generation failed: {e}")
+                model_3d = self.fallback_manager.handle_3d_gen_failure(monster_image)
+                generation_log['fallbacks_used'].append('3d_gen')
+            finally:
+                self._unload_model('3d_gen')
+            
+            # Stage 5: Add rigging (optional, can be skipped for performance)
+            rigged_model = model_3d
+            if model_3d and self.config.get('enable_rigging', False):
+                try:
+                    rigging_proc = self._lazy_load_model('rigging')
+                    if rigging_proc:
+                        rigged_model = rigging_proc.rig_mesh(model_3d)
+                        generation_log['stages_completed'].append('rigging')
+                except Exception as e:
+                    print(f"Rigging failed: {e}")
+                    generation_log['fallbacks_used'].append('rigging')
+                finally:
+                    self._unload_model('rigging')
+            
+            # Prepare download files
+            download_files = self._prepare_download_files(
+                rigged_model or model_3d, 
+                monster_image,
+                user_id
+            )
+            
+            generation_log['success'] = True
+            
+            return {
+                'description': description,
+                'traits': monster_traits,
+                'dialogue': monster_dialogue,
+                'image': monster_image,
+                'model_3d': model_3d_path,
+                'download_files': download_files,
+                'generation_log': generation_log,
+                'status': 'success'
+            }
+            
+        except Exception as e:
+            generation_log['error'] = str(e)
+            print(f"Pipeline error: {e}")
+            return self.fallback_generation(description or "digital monster", generation_log)
+    
+    def _create_image_prompt(self, base_description: str, traits: Dict) -> str:
+        """Create enhanced prompt for image generation"""
+        prompt_parts = [base_description]
+        
+        if traits:
+            if 'appearance' in traits:
+                prompt_parts.append(traits['appearance'])
+            if 'personality' in traits:
+                prompt_parts.append(f"with {traits['personality']} personality")
+            if 'color_scheme' in traits:
+                prompt_parts.append(f"featuring {traits['color_scheme']} colors")
+        
+        prompt_parts.extend([
+            "digital monster",
+            "creature design",
+            "game character",
+            "high quality",
+            "detailed"
+        ])
+        
+        return ", ".join(prompt_parts)
+    
+    def _save_3d_model(self, model_3d, user_id: str) -> str:
+        """Save 3D model to persistent storage"""
+        if not model_3d:
+            return None
+            
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        filename = f"monster_{user_id}_{timestamp}.glb"
+        
+        # Use HuggingFace Spaces persistent storage
+        if os.path.exists("/data"):
+            filepath = f"/data/models/{filename}"
+        else:
+            filepath = f"./data/models/{filename}"
+        
+        os.makedirs(os.path.dirname(filepath), exist_ok=True)
+        
+        # Save model (implementation depends on model format)
+        # This is a placeholder - actual implementation would depend on model format
+        with open(filepath, 'wb') as f:
+            if hasattr(model_3d, 'export'):
+                model_3d.export(f)
+            else:
+                # Fallback: save as binary data
+                f.write(str(model_3d).encode())
+        
+        return filepath
+    
+    def _prepare_download_files(self, model_3d, image, user_id: str) -> List[str]:
+        """Prepare downloadable files for user"""
+        files = []
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        
+        # Save image
+        if image:
+            if isinstance(image, Image.Image):
+                image_path = f"/tmp/monster_{user_id}_{timestamp}.png"
+                image.save(image_path)
+                files.append(image_path)
+            elif isinstance(image, np.ndarray):
+                image_path = f"/tmp/monster_{user_id}_{timestamp}.png"
+                Image.fromarray(image).save(image_path)
+                files.append(image_path)
+        
+        # Save 3D model in multiple formats if available
+        if model_3d:
+            # GLB format
+            glb_path = f"/tmp/monster_{user_id}_{timestamp}.glb"
+            files.append(glb_path)
+            
+            # OBJ format (optional)
+            obj_path = f"/tmp/monster_{user_id}_{timestamp}.obj"
+            files.append(obj_path)
+        
+        return files
+    
+    def fallback_generation(self, description: str, generation_log: Dict) -> Dict[str, Any]:
+        """Complete fallback generation when pipeline fails"""
+        return self.fallback_manager.complete_fallback_generation(description, generation_log)
+    
+    def cleanup(self):
+        """Clean up all loaded models"""
+        for model_type in list(self.models.keys()):
+            self._unload_model(model_type)
+        self._cleanup_memory()

core/auth_manager.py

@@ -0,0 +1,101 @@
+from typing import Optional, Dict, Any
+from datetime import datetime, timedelta
+import secrets
+import json
+from pathlib import Path
+
+class AuthManager:
+    """Manages authentication for HuggingFace Spaces OAuth"""
+    
+    def __init__(self):
+        # OAuth scopes for HuggingFace Spaces
+        self.oauth_scopes = [
+            "read-repos",
+            "write-repos"
+        ]
+        
+        # Session management
+        self.sessions = {}
+        self.session_timeout = timedelta(hours=8)
+    
+    def get_oauth_config(self) -> Dict[str, Any]:
+        """Get OAuth configuration for HuggingFace Spaces"""
+        return {
+            "provider": "huggingface",
+            "scopes": self.oauth_scopes,
+            "expiration_minutes": 480,  # 8 hours
+            "allow_anonymous": False
+        }
+    
+    def validate_session(self, session_token: str) -> Optional[Dict[str, Any]]:
+        """Validate a session token"""
+        if session_token in self.sessions:
+            session = self.sessions[session_token]
+            if datetime.now() < session['expires']:
+                # Update last access
+                session['last_access'] = datetime.now()
+                return session['user_data']
+        return None
+    
+    def create_session(self, oauth_profile: Dict[str, Any]) -> str:
+        """Create a new session for authenticated user"""
+        session_token = secrets.token_urlsafe(32)
+        
+        self.sessions[session_token] = {
+            'user_data': {
+                'username': oauth_profile.get('preferred_username', oauth_profile.get('username')),
+                'name': oauth_profile.get('name', 'Anonymous'),
+                'avatar_url': oauth_profile.get('picture', oauth_profile.get('avatar_url')),
+                'auth_time': datetime.now().isoformat()
+            },
+            'created': datetime.now(),
+            'expires': datetime.now() + self.session_timeout,
+            'last_access': datetime.now()
+        }
+        
+        return session_token
+    
+    def cleanup_expired_sessions(self):
+        """Remove expired sessions"""
+        current_time = datetime.now()
+        expired_tokens = [
+            token for token, session in self.sessions.items()
+            if current_time > session['expires']
+        ]
+        
+        for token in expired_tokens:
+            del self.sessions[token]
+    
+    def get_user_permissions(self, username: str) -> Dict[str, bool]:
+        """Get user permissions"""
+        # In HuggingFace Spaces, all authenticated users have same permissions
+        return {
+            'can_create_monster': True,
+            'can_train': True,
+            'can_evolve': True,
+            'can_battle': True,
+            'can_export': True,
+            'max_monsters': 10,
+            'max_daily_generations': 50
+        }
+    
+    def log_user_action(self, username: str, action: str, details: Dict = None):
+        """Log user actions for analytics"""
+        # This would typically write to a database or analytics service
+        # For HF Spaces, we'll just print for now
+        log_entry = {
+            'timestamp': datetime.now().isoformat(),
+            'username': username,
+            'action': action,
+            'details': details or {}
+        }
+        print(f"User Action: {json.dumps(log_entry)}")
+    
+    def format_oauth_button_config(self) -> Dict[str, Any]:
+        """Format configuration for Gradio LoginButton"""
+        return {
+            "value": "Connect to Digital World",
+            "size": "lg",
+            "icon": "🔐",
+            "variant": "primary"
+        }

core/game_mechanics.py

@@ -0,0 +1,496 @@
+import json
+import random
+from datetime import datetime, timedelta
+from typing import Dict, List, Any, Optional
+from dataclasses import dataclass, asdict
+import numpy as np
+
+@dataclass
+class Monster:
+    """Monster data class"""
+    name: str
+    species: str
+    stage: str  # rookie, champion, ultimate, mega
+    stats: Dict[str, int]
+    care_state: Dict[str, float]
+    personality: Dict[str, Any]
+    birth_time: datetime
+    evolution_time: Optional[datetime] = None
+    training_count: int = 0
+    battle_count: int = 0
+    happiness_events: List[str] = None
+    image_path: Optional[str] = None
+    model_3d_path: Optional[str] = None
+    
+    def __post_init__(self):
+        if self.happiness_events is None:
+            self.happiness_events = []
+    
+    def to_dict(self) -> Dict:
+        """Convert monster to dictionary for storage"""
+        data = asdict(self)
+        data['birth_time'] = self.birth_time.isoformat()
+        if self.evolution_time:
+            data['evolution_time'] = self.evolution_time.isoformat()
+        return data
+    
+    @classmethod
+    def from_dict(cls, data: Dict) -> 'Monster':
+        """Create monster from dictionary"""
+        data['birth_time'] = datetime.fromisoformat(data['birth_time'])
+        if data.get('evolution_time'):
+            data['evolution_time'] = datetime.fromisoformat(data['evolution_time'])
+        return cls(**data)
+    
+    def get_stats_display(self) -> Dict[str, Any]:
+        """Get formatted stats for display"""
+        return {
+            "name": self.name,
+            "species": self.species,
+            "stage": self.stage,
+            "level": self._calculate_level(),
+            "stats": {
+                "HP": f"{self.stats['hp']}/999",
+                "ATK": f"{self.stats['attack']}/500",
+                "DEF": f"{self.stats['defense']}/500",
+                "SPD": f"{self.stats['speed']}/500",
+                "SPC": f"{self.stats['special']}/500"
+            },
+            "care": {
+                "Hunger": f"{self.care_state['hunger']:.0f}%",
+                "Happiness": f"{self.care_state['happiness']:.0f}%",
+                "Fatigue": f"{self.care_state['fatigue']:.0f}%",
+                "Health": f"{self.care_state['health']:.0f}%"
+            },
+            "age": self._calculate_age()
+        }
+    
+    def _calculate_level(self) -> int:
+        """Calculate monster level based on stats and experience"""
+        total_stats = sum(self.stats.values())
+        base_level = total_stats // 50
+        exp_bonus = (self.training_count + self.battle_count) // 10
+        return min(99, base_level + exp_bonus + 1)
+    
+    def _calculate_age(self) -> str:
+        """Calculate monster age"""
+        age = datetime.now() - self.birth_time
+        if age.days > 0:
+            return f"{age.days} days"
+        elif age.seconds > 3600:
+            return f"{age.seconds // 3600} hours"
+        else:
+            return f"{age.seconds // 60} minutes"
+
+
+class GameMechanics:
+    """Core game mechanics inspired by Digimon World 1"""
+    
+    def __init__(self):
+        # Stat ranges and limits
+        self.stat_limits = {
+            'hp': (10, 999),
+            'attack': (5, 500),
+            'defense': (5, 500),
+            'speed': (5, 500),
+            'special': (5, 500)
+        }
+        
+        # Care thresholds
+        self.care_thresholds = {
+            'hunger': {'critical': 20, 'low': 40, 'good': 70},
+            'happiness': {'critical': 20, 'low': 40, 'good': 70},
+            'fatigue': {'good': 30, 'tired': 60, 'exhausted': 80},
+            'health': {'critical': 30, 'low': 50, 'good': 80}
+        }
+        
+        # Training effectiveness modifiers
+        self.training_modifiers = {
+            'strength': {'attack': 1.5, 'defense': 0.8, 'speed': 0.7},
+            'defense': {'attack': 0.7, 'defense': 1.5, 'hp': 1.2},
+            'speed': {'speed': 1.5, 'attack': 0.9, 'special': 0.8},
+            'intelligence': {'special': 1.5, 'defense': 0.9, 'hp': 0.8},
+            'balanced': {'attack': 1.0, 'defense': 1.0, 'speed': 1.0, 'special': 1.0}
+        }
+        
+        # Evolution requirements (simplified)
+        self.evolution_requirements = {
+            'champion': {
+                'min_stats': 150,  # Total stats
+                'min_care': 60,    # Average care percentage
+                'min_age': 1,      # Days
+                'training_count': 10
+            },
+            'ultimate': {
+                'min_stats': 300,
+                'min_care': 70,
+                'min_age': 3,
+                'training_count': 30
+            },
+            'mega': {
+                'min_stats': 500,
+                'min_care': 80,
+                'min_age': 7,
+                'training_count': 50
+            }
+        }
+    
+    def create_monster(self, generation_result: Dict[str, Any], user_preferences: Dict = None) -> Monster:
+        """Create a new monster from AI generation results"""
+        
+        traits = generation_result.get('traits', {})
+        preferences = user_preferences or {}
+        
+        # Generate base stats based on traits and preferences
+        base_stats = self._generate_base_stats(traits, preferences.get('training_focus', 'balanced'))
+        
+        # Initialize care state
+        care_state = {
+            'hunger': 80.0,
+            'happiness': 90.0,
+            'fatigue': 10.0,
+            'health': 100.0
+        }
+        
+        # Determine personality from traits
+        personality = self._determine_personality(traits)
+        
+        # Create monster name
+        name = traits.get('name', self._generate_name(traits))
+        
+        # Create monster instance
+        monster = Monster(
+            name=name,
+            species=traits.get('species', 'DigiPal'),
+            stage='rookie',
+            stats=base_stats,
+            care_state=care_state,
+            personality=personality,
+            birth_time=datetime.now(),
+            image_path=generation_result.get('image'),
+            model_3d_path=generation_result.get('model_3d')
+        )
+        
+        return monster
+    
+    def _generate_base_stats(self, traits: Dict, focus: str) -> Dict[str, int]:
+        """Generate base stats based on traits and focus"""
+        # Base values
+        base = {
+            'hp': random.randint(50, 100),
+            'attack': random.randint(15, 35),
+            'defense': random.randint(15, 35),
+            'speed': random.randint(15, 35),
+            'special': random.randint(15, 35)
+        }
+        
+        # Apply focus modifiers
+        if focus in self.training_modifiers:
+            for stat, modifier in self.training_modifiers[focus].items():
+                if stat in base:
+                    base[stat] = int(base[stat] * modifier)
+        
+        # Apply trait-based modifiers
+        if traits.get('element') == 'fire':
+            base['attack'] += 10
+            base['special'] += 5
+        elif traits.get('element') == 'water':
+            base['defense'] += 10
+            base['hp'] += 20
+        elif traits.get('element') == 'earth':
+            base['defense'] += 15
+            base['hp'] += 10
+        elif traits.get('element') == 'wind':
+            base['speed'] += 15
+            base['special'] += 5
+        
+        # Ensure stats are within limits
+        for stat in base:
+            base[stat] = max(self.stat_limits[stat][0], 
+                           min(self.stat_limits[stat][1], base[stat]))
+        
+        return base
+    
+    def _determine_personality(self, traits: Dict) -> Dict[str, Any]:
+        """Determine monster personality from traits"""
+        personality_traits = [
+            'brave', 'timid', 'aggressive', 'gentle', 
+            'playful', 'serious', 'loyal', 'independent'
+        ]
+        
+        # Select primary trait
+        primary = traits.get('personality', random.choice(personality_traits))
+        
+        # Generate personality profile
+        return {
+            'primary': primary,
+            'likes': self._generate_likes(primary),
+            'dislikes': self._generate_dislikes(primary),
+            'training_preference': self._get_training_preference(primary),
+            'battle_style': self._get_battle_style(primary)
+        }
+    
+    def _generate_name(self, traits: Dict) -> str:
+        """Generate a name if not provided"""
+        prefixes = ['Digi', 'Cyber', 'Tech', 'Neo', 'Alpha', 'Beta']
+        suffixes = ['mon', 'pal', 'byte', 'bit', 'tron', 'x']
+        
+        prefix = random.choice(prefixes)
+        suffix = random.choice(suffixes)
+        
+        return f"{prefix}{suffix}"
+    
+    def _generate_likes(self, personality: str) -> List[str]:
+        """Generate things the monster likes based on personality"""
+        likes_map = {
+            'brave': ['battles', 'challenges', 'meat'],
+            'timid': ['quiet places', 'vegetables', 'praise'],
+            'aggressive': ['training', 'meat', 'battles'],
+            'gentle': ['praise', 'vegetables', 'playing'],
+            'playful': ['games', 'treats', 'attention'],
+            'serious': ['training', 'discipline', 'fish'],
+            'loyal': ['praise', 'companionship', 'meat'],
+            'independent': ['exploration', 'variety', 'fish']
+        }
+        return likes_map.get(personality, ['food', 'play', 'rest'])
+    
+    def _generate_dislikes(self, personality: str) -> List[str]:
+        """Generate things the monster dislikes based on personality"""
+        dislikes_map = {
+            'brave': ['running away', 'vegetables', 'rest'],
+            'timid': ['battles', 'loud noises', 'scolding'],
+            'aggressive': ['vegetables', 'rest', 'gentle training'],
+            'gentle': ['battles', 'scolding', 'meat'],
+            'playful': ['discipline', 'vegetables', 'being ignored'],
+            'serious': ['games', 'treats', 'slacking'],
+            'loyal': ['being alone', 'scolding', 'betrayal'],
+            'independent': ['clingy behavior', 'routine', 'vegetables']
+        }
+        return dislikes_map.get(personality, ['scolding', 'hunger', 'fatigue'])
+    
+    def _get_training_preference(self, personality: str) -> str:
+        """Get preferred training type based on personality"""
+        preferences = {
+            'brave': 'strength',
+            'timid': 'defense',
+            'aggressive': 'strength',
+            'gentle': 'intelligence',
+            'playful': 'speed',
+            'serious': 'balanced',
+            'loyal': 'defense',
+            'independent': 'speed'
+        }
+        return preferences.get(personality, 'balanced')
+    
+    def _get_battle_style(self, personality: str) -> str:
+        """Get battle style based on personality"""
+        styles = {
+            'brave': 'offensive',
+            'timid': 'defensive',
+            'aggressive': 'berserker',
+            'gentle': 'support',
+            'playful': 'trickster',
+            'serious': 'tactical',
+            'loyal': 'guardian',
+            'independent': 'adaptive'
+        }
+        return styles.get(personality, 'balanced')
+    
+    def train_monster(self, monster: Monster, training_type: str, intensity: int) -> Dict[str, Any]:
+        """Train the monster to improve stats"""
+        
+        # Check if monster can train
+        if monster.care_state['fatigue'] > self.care_thresholds['fatigue']['exhausted']:
+            return {
+                'success': False,
+                'message': f"{monster.name} is too tired to train! 😴💤",
+                'stat_changes': {}
+            }
+        
+        if monster.care_state['hunger'] < self.care_thresholds['hunger']['low']:
+            return {
+                'success': False,
+                'message': f"{monster.name} is too hungry to train! 🍖❓",
+                'stat_changes': {}
+            }
+        
+        # Calculate stat gains
+        base_gain = intensity * 2
+        stat_gains = {}
+        
+        # Apply training type modifiers
+        training_type = training_type.lower()
+        if training_type in self.training_modifiers:
+            for stat, modifier in self.training_modifiers[training_type].items():
+                if stat in monster.stats:
+                    gain = int(base_gain * modifier * random.uniform(0.8, 1.2))
+                    
+                    # Personality bonus
+                    if training_type == monster.personality['training_preference']:
+                        gain = int(gain * 1.2)
+                    
+                    # Apply gain with stat limits
+                    old_value = monster.stats[stat]
+                    new_value = min(self.stat_limits[stat][1], old_value + gain)
+                    actual_gain = new_value - old_value
+                    
+                    if actual_gain > 0:
+                        monster.stats[stat] = new_value
+                        stat_gains[stat] = actual_gain
+        
+        # Update care state
+        fatigue_gain = intensity * 5 + random.randint(0, 10)
+        happiness_gain = 5 if training_type == monster.personality['training_preference'] else 2
+        
+        monster.care_state['fatigue'] = min(100, monster.care_state['fatigue'] + fatigue_gain)
+        monster.care_state['happiness'] = min(100, monster.care_state['happiness'] + happiness_gain)
+        monster.care_state['hunger'] = max(0, monster.care_state['hunger'] - intensity * 2)
+        
+        # Update training count
+        monster.training_count += 1
+        
+        # Check for evolution
+        evolution_check = self.check_evolution(monster)
+        
+        # Generate response message
+        if stat_gains:
+            gains_text = ", ".join([f"{stat.upper()} +{gain}" for stat, gain in stat_gains.items()])
+            message = f"💪 Training complete! {gains_text}"
+        else:
+            message = f"📈 {monster.name} has reached stat limits in this area!"
+        
+        return {
+            'success': True,
+            'message': message,
+            'stat_changes': stat_gains,
+            'fatigue_gained': fatigue_gain,
+            'evolution_check': evolution_check
+        }
+    
+    def check_evolution(self, monster: Monster) -> Optional[Dict[str, Any]]:
+        """Check if monster meets evolution requirements"""
+        
+        current_stage = monster.stage
+        next_stage = None
+        
+        if current_stage == 'rookie':
+            next_stage = 'champion'
+        elif current_stage == 'champion':
+            next_stage = 'ultimate'
+        elif current_stage == 'ultimate':
+            next_stage = 'mega'
+        else:
+            return None
+        
+        requirements = self.evolution_requirements.get(next_stage)
+        if not requirements:
+            return None
+        
+        # Check requirements
+        total_stats = sum(monster.stats.values())
+        avg_care = sum(monster.care_state.values()) / len(monster.care_state)
+        age_days = (datetime.now() - monster.birth_time).days
+        
+        meets_requirements = (
+            total_stats >= requirements['min_stats'] and
+            avg_care >= requirements['min_care'] and
+            age_days >= requirements['min_age'] and
+            monster.training_count >= requirements['training_count']
+        )
+        
+        if meets_requirements:
+            return {
+                'can_evolve': True,
+                'next_stage': next_stage,
+                'message': f"✨ {monster.name} is ready to evolve to {next_stage}!"
+            }
+        else:
+            return {
+                'can_evolve': False,
+                'next_stage': next_stage,
+                'progress': {
+                    'stats': f"{total_stats}/{requirements['min_stats']}",
+                    'care': f"{avg_care:.0f}%/{requirements['min_care']}%",
+                    'age': f"{age_days}/{requirements['min_age']} days",
+                    'training': f"{monster.training_count}/{requirements['training_count']}"
+                }
+            }
+    
+    def feed_monster(self, monster: Monster, food_type: str) -> Dict[str, Any]:
+        """Feed the monster"""
+        
+        food_effects = {
+            'meat': {'hunger': 40, 'happiness': 10, 'health': 5},
+            'fish': {'hunger': 35, 'happiness': 15, 'health': 10},
+            'vegetable': {'hunger': 30, 'happiness': 5, 'health': 15},
+            'treat': {'hunger': 20, 'happiness': 30, 'health': 0},
+            'medicine': {'hunger': 0, 'happiness': -10, 'health': 50}
+        }
+        
+        effects = food_effects.get(food_type.lower(), food_effects['meat'])
+        
+        # Apply personality preferences
+        likes_food = food_type.lower() in [like.lower() for like in monster.personality.get('likes', [])]
+        dislikes_food = food_type.lower() in [dislike.lower() for dislike in monster.personality.get('dislikes', [])]
+        
+        if likes_food:
+            effects['happiness'] *= 2
+        elif dislikes_food:
+            effects['happiness'] = -abs(effects['happiness'])
+        
+        # Update care state
+        old_hunger = monster.care_state['hunger']
+        monster.care_state['hunger'] = min(100, monster.care_state['hunger'] + effects['hunger'])
+        monster.care_state['happiness'] = max(0, min(100, monster.care_state['happiness'] + effects['happiness']))
+        monster.care_state['health'] = min(100, monster.care_state['health'] + effects['health'])
+        
+        # Generate response
+        if likes_food:
+            message = f"😋 {monster.name} loves {food_type}! 💖"
+        elif dislikes_food:
+            message = f"😒 {monster.name} doesn't like {food_type}... 💔"
+        elif old_hunger < 30:
+            message = f"🍽️ {monster.name} was very hungry! Much better now! 😊"
+        else:
+            message = f"🍴 {monster.name} enjoyed the {food_type}! 👍"
+        
+        return {
+            'success': True,
+            'message': message,
+            'effects': effects,
+            'current_state': monster.care_state
+        }
+    
+    def update_care_state(self, monster: Monster, time_passed: timedelta) -> Dict[str, Any]:
+        """Update monster care state based on time passed"""
+        
+        # Calculate hours passed
+        hours = time_passed.total_seconds() / 3600
+        
+        # Decrease hunger and happiness over time
+        monster.care_state['hunger'] = max(0, monster.care_state['hunger'] - hours * 5)
+        monster.care_state['happiness'] = max(0, monster.care_state['happiness'] - hours * 2)
+        
+        # Decrease fatigue over time (rest)
+        monster.care_state['fatigue'] = max(0, monster.care_state['fatigue'] - hours * 10)
+        
+        # Health changes based on other stats
+        if monster.care_state['hunger'] < 20:
+            monster.care_state['health'] = max(0, monster.care_state['health'] - hours * 3)
+        elif monster.care_state['happiness'] < 20:
+            monster.care_state['health'] = max(0, monster.care_state['health'] - hours * 1)
+        
+        # Check for critical states
+        alerts = []
+        if monster.care_state['hunger'] < self.care_thresholds['hunger']['critical']:
+            alerts.append("🍖 Your monster is starving!")
+        if monster.care_state['happiness'] < self.care_thresholds['happiness']['critical']:
+            alerts.append("😢 Your monster is very unhappy!")
+        if monster.care_state['health'] < self.care_thresholds['health']['critical']:
+            alerts.append("🏥 Your monster needs medical attention!")
+        
+        return {
+            'updated_state': monster.care_state,
+            'alerts': alerts,
+            'time_since_update': str(time_passed)
+        }

core/state_manager.py

@@ -0,0 +1,280 @@
+import json
+import os
+from pathlib import Path
+from datetime import datetime, timedelta
+from typing import Dict, List, Optional, Any
+import shutil
+from core.game_mechanics import Monster
+
+class StateManager:
+    """Manages persistent state for users and monsters"""
+    
+    def __init__(self, data_dir: Path):
+        self.data_dir = Path(data_dir)
+        self.users_dir = self.data_dir / "users"
+        self.monsters_dir = self.data_dir / "monsters"
+        self.cache_dir = self.data_dir / "cache"
+        
+        # Create directories if they don't exist
+        for dir_path in [self.users_dir, self.monsters_dir, self.cache_dir]:
+            dir_path.mkdir(parents=True, exist_ok=True)
+        
+        # In-memory cache for active sessions
+        self.active_sessions = {}
+        self.last_save_time = {}
+    
+    def get_user_dir(self, user_id: str) -> Path:
+        """Get or create user directory"""
+        user_dir = self.users_dir / user_id
+        user_dir.mkdir(exist_ok=True)
+        return user_dir
+    
+    def save_monster(self, user_id: str, monster: Monster) -> bool:
+        """Save monster to persistent storage"""
+        try:
+            user_dir = self.get_user_dir(user_id)
+            
+            # Save monster data
+            monster_file = user_dir / f"monster_{monster.name}_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json"
+            with open(monster_file, 'w') as f:
+                json.dump(monster.to_dict(), f, indent=2)
+            
+            # Update current monster reference
+            current_file = user_dir / "current_monster.json"
+            current_data = {
+                'monster_file': str(monster_file.name),
+                'monster_name': monster.name,
+                'last_updated': datetime.now().isoformat()
+            }
+            with open(current_file, 'w') as f:
+                json.dump(current_data, f, indent=2)
+            
+            # Update user profile
+            self._update_user_profile(user_id, monster)
+            
+            # Cache in memory
+            self.active_sessions[user_id] = {
+                'monster': monster,
+                'last_access': datetime.now()
+            }
+            
+            return True
+            
+        except Exception as e:
+            print(f"Error saving monster: {e}")
+            return False
+    
+    def get_current_monster(self, user_id: str) -> Optional[Monster]:
+        """Get the current active monster for a user"""
+        
+        # Check memory cache first
+        if user_id in self.active_sessions:
+            session = self.active_sessions[user_id]
+            if datetime.now() - session['last_access'] < timedelta(minutes=30):
+                session['last_access'] = datetime.now()
+                return session['monster']
+        
+        # Load from disk
+        try:
+            user_dir = self.get_user_dir(user_id)
+            current_file = user_dir / "current_monster.json"
+            
+            if not current_file.exists():
+                return None
+            
+            with open(current_file, 'r') as f:
+                current_data = json.load(f)
+            
+            monster_file = user_dir / current_data['monster_file']
+            if not monster_file.exists():
+                return None
+            
+            with open(monster_file, 'r') as f:
+                monster_data = json.load(f)
+            
+            monster = Monster.from_dict(monster_data)
+            
+            # Update cache
+            self.active_sessions[user_id] = {
+                'monster': monster,
+                'last_access': datetime.now()
+            }
+            
+            return monster
+            
+        except Exception as e:
+            print(f"Error loading monster: {e}")
+            return None
+    
+    def update_monster(self, user_id: str, monster: Monster) -> bool:
+        """Update existing monster data"""
+        
+        # Update in memory
+        if user_id in self.active_sessions:
+            self.active_sessions[user_id]['monster'] = monster
+            self.active_sessions[user_id]['last_access'] = datetime.now()
+        
+        # Save periodically (every 5 minutes) or if important changes
+        should_save = False
+        current_time = datetime.now()
+        
+        if user_id not in self.last_save_time:
+            should_save = True
+        else:
+            time_since_save = current_time - self.last_save_time[user_id]
+            if time_since_save > timedelta(minutes=5):
+                should_save = True
+        
+        # Always save on evolution or critical states
+        if monster.care_state['health'] < 30 or monster.care_state['hunger'] < 20:
+            should_save = True
+        
+        if should_save:
+            self.last_save_time[user_id] = current_time
+            return self.save_monster(user_id, monster)
+        
+        return True
+    
+    def get_user_monsters(self, user_id: str) -> List[Dict[str, Any]]:
+        """Get all monsters for a user"""
+        try:
+            user_dir = self.get_user_dir(user_id)
+            monsters = []
+            
+            for file_path in user_dir.glob("monster_*.json"):
+                if file_path.name != "current_monster.json":
+                    with open(file_path, 'r') as f:
+                        monster_data = json.load(f)
+                        monsters.append({
+                            'file': file_path.name,
+                            'name': monster_data.get('name'),
+                            'species': monster_data.get('species'),
+                            'stage': monster_data.get('stage'),
+                            'birth_time': monster_data.get('birth_time')
+                        })
+            
+            # Sort by birth time (newest first)
+            monsters.sort(key=lambda x: x['birth_time'], reverse=True)
+            return monsters
+            
+        except Exception as e:
+            print(f"Error getting user monsters: {e}")
+            return []
+    
+    def _update_user_profile(self, user_id: str, monster: Monster):
+        """Update user profile with monster statistics"""
+        try:
+            user_dir = self.get_user_dir(user_id)
+            profile_file = user_dir / "profile.json"
+            
+            # Load existing profile or create new
+            if profile_file.exists():
+                with open(profile_file, 'r') as f:
+                    profile = json.load(f)
+            else:
+                profile = {
+                    'user_id': user_id,
+                    'created': datetime.now().isoformat(),
+                    'monsters_created': 0,
+                    'total_training_sessions': 0,
+                    'achievements': []
+                }
+            
+            # Update statistics
+            profile['monsters_created'] = profile.get('monsters_created', 0) + 1
+            profile['last_active'] = datetime.now().isoformat()
+            profile['current_monster'] = monster.name
+            
+            # Check for achievements
+            new_achievements = self._check_achievements(profile, monster)
+            profile['achievements'].extend(new_achievements)
+            
+            # Save profile
+            with open(profile_file, 'w') as f:
+                json.dump(profile, f, indent=2)
+                
+        except Exception as e:
+            print(f"Error updating user profile: {e}")
+    
+    def _check_achievements(self, profile: Dict, monster: Monster) -> List[Dict[str, Any]]:
+        """Check for new achievements"""
+        achievements = []
+        current_achievements = {a['id'] for a in profile.get('achievements', [])}
+        
+        # First monster achievement
+        if profile['monsters_created'] == 1 and 'first_monster' not in current_achievements:
+            achievements.append({
+                'id': 'first_monster',
+                'name': 'Digital Pioneer',
+                'description': 'Created your first digital monster',
+                'icon': '🥇',
+                'unlocked': datetime.now().isoformat()
+            })
+        
+        # Multiple monsters achievement
+        if profile['monsters_created'] == 5 and 'monster_collector' not in current_achievements:
+            achievements.append({
+                'id': 'monster_collector',
+                'name': 'Monster Collector',
+                'description': 'Created 5 digital monsters',
+                'icon': '🏆',
+                'unlocked': datetime.now().isoformat()
+            })
+        
+        # Perfect care achievement
+        if all(monster.care_state[stat] >= 90 for stat in ['hunger', 'happiness', 'health']):
+            if 'perfect_care' not in current_achievements:
+                achievements.append({
+                    'id': 'perfect_care',
+                    'name': 'Perfect Caretaker',
+                    'description': 'Achieved perfect care status',
+                    'icon': '💖',
+                    'unlocked': datetime.now().isoformat()
+                })
+        
+        return achievements
+    
+    def get_user_profile(self, user_id: str) -> Optional[Dict[str, Any]]:
+        """Get user profile"""
+        try:
+            user_dir = self.get_user_dir(user_id)
+            profile_file = user_dir / "profile.json"
+            
+            if profile_file.exists():
+                with open(profile_file, 'r') as f:
+                    return json.load(f)
+            return None
+            
+        except Exception as e:
+            print(f"Error loading user profile: {e}")
+            return None
+    
+    def cleanup_old_sessions(self):
+        """Clean up old sessions from memory"""
+        current_time = datetime.now()
+        expired_users = []
+        
+        for user_id, session in self.active_sessions.items():
+            if current_time - session['last_access'] > timedelta(hours=1):
+                expired_users.append(user_id)
+        
+        for user_id in expired_users:
+            # Save before removing from cache
+            if 'monster' in self.active_sessions[user_id]:
+                self.save_monster(user_id, self.active_sessions[user_id]['monster'])
+            del self.active_sessions[user_id]
+    
+    def export_user_data(self, user_id: str) -> Optional[str]:
+        """Export all user data as a zip file"""
+        try:
+            user_dir = self.get_user_dir(user_id)
+            export_path = self.cache_dir / f"export_{user_id}_{datetime.now().strftime('%Y%m%d_%H%M%S')}"
+            
+            # Create zip archive
+            shutil.make_archive(str(export_path), 'zip', user_dir)
+            
+            return f"{export_path}.zip"
+            
+        except Exception as e:
+            print(f"Error exporting user data: {e}")
+            return None

docs/HUNYUAN3D_INTEGRATION.md

@@ -1,264 +0,0 @@
-# Hunyuan3D-2.1 Integration for DigiPal
-
-## Overview
-
-The Hunyuan3D pipeline integrates Tencent's state-of-the-art Hunyuan3D-2.1 model into DigiPal, providing advanced 3D generation capabilities for monster creation. This pipeline offers multiple generation modes, high-quality outputs, and seamless integration with the existing DigiPal monster system.
-
-## Features
-
-### Core Capabilities
-
-1. **Text-to-3D Generation**
-   - Generate 3D models from text descriptions
-   - Automatic concept image generation
-   - Two-stage process: shape generation + texture generation
-
-2. **Image-to-3D Generation**
-   - Convert single images to 3D models
-   - Automatic background removal
-   - Foreground ratio control for optimal results
-
-3. **Multi-View Generation**
-   - Generate from front, back, left, and right views
-   - Higher accuracy than single image input
-   - Ideal for complex monster designs
-
-### Generation Modes
-
-- **Turbo Mode**: Fastest generation, suitable for prototypes and baby monsters
-- **Fast Mode**: Balanced speed and quality, ideal for most use cases
-- **Standard Mode**: Best quality, recommended for final assets
-
-### Export Formats
-
-- **GLB** (recommended): GLTF binary format with embedded textures
-- **OBJ**: Wavefront format for compatibility
-- **PLY**: Point cloud format
-- **STL**: For 3D printing applications
-
-### Texture Options
-
-- **RGB**: Standard color textures
-- **PBR**: Physically-based rendering with metallic, roughness, and normal maps
-
-## Installation
-
-1. Ensure you have the required dependencies:
-```bash
-pip install gradio_client>=0.8.0 trimesh>=4.0.0 aiohttp>=3.9.0
-```
-
-2. The pipeline is located at: `src/pipelines/hunyuan3d_pipeline.py`
-
-## Configuration
-
-Create a configuration file or use the default settings:
-
-```python
-from src.pipelines.hunyuan3d_pipeline import Hunyuan3DConfig, GenerationMode
-
-config = Hunyuan3DConfig(
-    space_id="Tencent/Hunyuan3D-2",  # Official HF Space
-    default_mode=GenerationMode.FAST,
-    texture_method=TextureMethod.RGB,
-    export_format=ExportFormat.GLB,
-    target_polycount=30000,
-    enable_optimization=True
-)
-```
-
-## Usage Examples
-
-### Basic Text-to-3D Generation
-
-```python
-from src.pipelines.hunyuan3d_pipeline import Hunyuan3DPipeline, GenerationMode
-
-# Initialize pipeline
-pipeline = Hunyuan3DPipeline()
-
-# Generate from text
-result = await pipeline.generate_from_text(
-    prompt="cute blue dragon with big eyes and small wings",
-    name="BlueDragon",
-    mode=GenerationMode.FAST
-)
-
-if result["success"]:
-    print(f"Model saved at: {result['paths']['processed_model']}")
-```
-
-### Image-to-3D Generation
-
-```python
-# Generate from a single image
-result = await pipeline.generate_from_image(
-    image_path="dragon_concept.png",
-    name="DragonFromImage",
-    mode=GenerationMode.STANDARD
-)
-```
-
-### Multi-View Generation
-
-```python
-# Generate from multiple views for better accuracy
-views = {
-    "front": "dragon_front.png",
-    "back": "dragon_back.png",
-    "left": "dragon_left.png",
-    "right": "dragon_right.png"
-}
-
-result = await pipeline.generate_from_multi_view(
-    image_paths=views,
-    name="DragonMultiView",
-    mode=GenerationMode.STANDARD
-)
-```
-
-### DigiPal Monster Integration
-
-```python
-from src.pipelines.hunyuan3d_pipeline import DigiPalHunyuan3DIntegration
-
-# Initialize integration
-integration = DigiPalHunyuan3DIntegration()
-
-# Generate model for a DigiPal monster
-result = await integration.generate_monster_model(
-    monster=my_monster,  # DW1Monster instance
-    force_regenerate=False
-)
-```
-
-## Integration with DigiPal System
-
-### Automatic Monster Generation
-
-The pipeline automatically creates appropriate prompts based on monster attributes:
-
-- **Stage**: Determines model complexity (baby → ultimate)
-- **Personality**: Influences visual style and pose
-- **Species Type**: Affects color scheme and texture
-- **Stats**: High offense adds claws, high defense adds armor, etc.
-
-### Evolution Support
-
-Generate complete evolution sequences:
-
-```python
-# Generate all evolution stages
-results = await integration.generate_evolution_sequence(
-    monster=my_monster,
-    stages=["baby", "child", "adult", "perfect", "ultimate"]
-)
-```
-
-### Caching System
-
-- Models are automatically cached to avoid regeneration
-- Cache key based on monster ID and evolution stage
-- Force regeneration available when needed
-
-## Performance Optimization
-
-### Model Optimization
-
-- Automatic mesh simplification to target polycount
-- Geometry cleanup (degenerate faces, duplicates)
-- UV optimization for efficient texture mapping
-- Watertight mesh generation for rigging
-
-### Generation Speed
-
-- **Turbo Mode**: ~30-60 seconds
-- **Fast Mode**: ~1-2 minutes
-- **Standard Mode**: ~2-4 minutes
-
-### Batch Processing
-
-Generate multiple models concurrently:
-
-```python
-tasks = [
-    {"prompt": "fire dragon", "name": "FireDragon"},
-    {"prompt": "water turtle", "name": "WaterTurtle"},
-    {"prompt": "electric mouse", "name": "ElectricMouse"}
-]
-
-results = await pipeline.batch_generate(
-    tasks,
-    max_concurrent=2  # Process 2 at a time
-)
-```
-
-## Comparison with Other Pipelines
-
-| Feature | Hunyuan3D | Meshy AI | Open Source |
-|---------|-----------|----------|-------------|
-| Text-to-3D | ✓ | ✓ | ✓ |
-| Image-to-3D | ✓ | Limited | ✓ |
-| Multi-View | ✓ | ✗ | ✓ |
-| Speed | Fast | Medium | Slow |
-| Quality | High | High | Medium |
-| PBR Textures | ✓ | ✓ | Limited |
-| API Cost | Free* | Paid | Free |
-| Auto-Rigging | ✗ | ✓ | ✓ |
-
-*Free via Hugging Face Spaces, subject to usage limits
-
-## Best Practices
-
-### Prompt Engineering
-
-1. **Be Specific**: Include details about size, color, features
-2. **Use T-Pose**: Add "T-pose" for better rigging compatibility
-3. **Neutral Background**: Specify "neutral background" for cleaner results
-4. **Game Asset**: Include "game character" or "game asset" for optimization
-
-### Quality Settings
-
-- Use **Turbo** mode for rapid prototyping
-- Use **Fast** mode for development and testing
-- Use **Standard** mode for final production assets
-
-### Multi-View Tips
-
-- Ensure consistent lighting across all views
-- Use the same background for all images
-- Maintain the same scale and position
-- Remove shadows for better reconstruction
-
-## Troubleshooting
-
-### Common Issues
-
-1. **Connection Failed**: Check internet connection and HF Space availability
-2. **Generation Timeout**: Reduce quality settings or use Turbo mode
-3. **Low Quality Output**: Use Standard mode or provide better input images
-4. **Missing Textures**: Ensure texture_method is set correctly
-
-### Error Handling
-
-The pipeline includes comprehensive error handling:
-- Automatic retries with exponential backoff
-- Graceful fallbacks for failed generations
-- Detailed error messages in results
-
-## Future Enhancements
-
-- [ ] Animation generation support
-- [ ] Advanced rigging integration
-- [ ] Real-time preview during generation
-- [ ] Custom texture painting
-- [ ] Physics simulation setup
-- [ ] LOD (Level of Detail) generation
-
-## API Reference
-
-See the inline documentation in `src/pipelines/hunyuan3d_pipeline.py` for detailed API reference.
-
-## Credits
-
-This integration uses Tencent's Hunyuan3D-2.1 model, available through Hugging Face Spaces. Special thanks to the Tencent team for making this technology accessible.

frontend/app.html

@@ -1,12 +0,0 @@
-<!doctype html>
-<html lang="en">
-  <head>
-    <meta charset="utf-8" />
-    <link rel="icon" href="%sveltekit.assets%/favicon.png" />
-    <meta name="viewport" content="width=device-width, initial-scale=1" />
-    %sveltekit.head%
-  </head>
-  <body data-sveltekit-preload-data="hover" class="bg-black text-white">
-    <div style="display: contents">%sveltekit.body%</div>
-  </body>
-</html>

frontend/frontend/.gitignore

@@ -1,23 +0,0 @@
-node_modules
-
-# Output
-.output
-.vercel
-.netlify
-.wrangler
-/.svelte-kit
-/build
-
-# OS
-.DS_Store
-Thumbs.db
-
-# Env
-.env
-.env.*
-!.env.example
-!.env.test
-
-# Vite
-vite.config.js.timestamp-*
-vite.config.ts.timestamp-*

frontend/frontend/.npmrc

@@ -1 +0,0 @@
-engine-strict=true

frontend/frontend/README.md

@@ -1,38 +0,0 @@
-# sv
-
-Everything you need to build a Svelte project, powered by [`sv`](https://github.com/sveltejs/cli).
-
-## Creating a project
-
-If you're seeing this, you've probably already done this step. Congrats!
-
-```bash
-# create a new project in the current directory
-npx sv create
-
-# create a new project in my-app
-npx sv create my-app
-```
-
-## Developing
-
-Once you've created a project and installed dependencies with `npm install` (or `pnpm install` or `yarn`), start a development server:
-
-```bash
-npm run dev
-
-# or start the server and open the app in a new browser tab
-npm run dev -- --open
-```
-
-## Building
-
-To create a production version of your app:
-
-```bash
-npm run build
-```
-
-You can preview the production build with `npm run preview`.
-
-> To deploy your app, you may need to install an [adapter](https://svelte.dev/docs/kit/adapters) for your target environment.

frontend/frontend/package.json

@@ -1,23 +0,0 @@
-{
-	"name": "frontend",
-	"private": true,
-	"version": "0.0.1",
-	"type": "module",
-	"scripts": {
-		"dev": "vite dev",
-		"build": "vite build",
-		"preview": "vite preview",
-		"prepare": "svelte-kit sync || echo ''",
-		"check": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json",
-		"check:watch": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json --watch"
-	},
-	"devDependencies": {
-		"@sveltejs/adapter-auto": "^6.0.0",
-		"@sveltejs/kit": "^2.16.0",
-		"@sveltejs/vite-plugin-svelte": "^5.0.0",
-		"svelte": "^5.0.0",
-		"svelte-check": "^4.0.0",
-		"typescript": "^5.0.0",
-		"vite": "^6.2.6"
-	}
-}

frontend/frontend/src/app.d.ts

@@ -1,13 +0,0 @@
-// See https://svelte.dev/docs/kit/types#app.d.ts
-// for information about these interfaces
-declare global {
-	namespace App {
-		// interface Error {}
-		// interface Locals {}
-		// interface PageData {}
-		// interface PageState {}
-		// interface Platform {}
-	}
-}
-
-export {};

frontend/frontend/src/app.html

@@ -1,12 +0,0 @@
-<!doctype html>
-<html lang="en">
-	<head>
-		<meta charset="utf-8" />
-		<link rel="icon" href="%sveltekit.assets%/favicon.png" />
-		<meta name="viewport" content="width=device-width, initial-scale=1" />
-		%sveltekit.head%
-	</head>
-	<body data-sveltekit-preload-data="hover">
-		<div style="display: contents">%sveltekit.body%</div>
-	</body>
-</html>

frontend/frontend/src/routes/+page.svelte

@@ -1,2 +0,0 @@
-<h1>Welcome to SvelteKit</h1>
-<p>Visit <a href="https://svelte.dev/docs/kit">svelte.dev/docs/kit</a> to read the documentation</p>

frontend/frontend/svelte.config.js

@@ -1,18 +0,0 @@
-import adapter from '@sveltejs/adapter-auto';
-import { vitePreprocess } from '@sveltejs/vite-plugin-svelte';
-
-/** @type {import('@sveltejs/kit').Config} */
-const config = {
-	// Consult https://svelte.dev/docs/kit/integrations
-	// for more information about preprocessors
-	preprocess: vitePreprocess(),
-
-	kit: {
-		// adapter-auto only supports some environments, see https://svelte.dev/docs/kit/adapter-auto for a list.
-		// If your environment is not supported, or you settled on a specific environment, switch out the adapter.
-		// See https://svelte.dev/docs/kit/adapters for more information about adapters.
-		adapter: adapter()
-	}
-};
-
-export default config;

frontend/frontend/tsconfig.json

@@ -1,19 +0,0 @@
-{
-	"extends": "./.svelte-kit/tsconfig.json",
-	"compilerOptions": {
-		"allowJs": true,
-		"checkJs": true,
-		"esModuleInterop": true,
-		"forceConsistentCasingInFileNames": true,
-		"resolveJsonModule": true,
-		"skipLibCheck": true,
-		"sourceMap": true,
-		"strict": true,
-		"moduleResolution": "bundler"
-	}
-	// Path aliases are handled by https://svelte.dev/docs/kit/configuration#alias
-	// except $lib which is handled by https://svelte.dev/docs/kit/configuration#files
-	//
-	// If you want to overwrite includes/excludes, make sure to copy over the relevant includes/excludes
-	// from the referenced tsconfig.json - TypeScript does not merge them in
-}

frontend/frontend/vite.config.ts

@@ -1,6 +0,0 @@
-import { sveltekit } from '@sveltejs/kit/vite';
-import { defineConfig } from 'vite';
-
-export default defineConfig({
-	plugins: [sveltekit()]
-});

frontend/package.json

@@ -1,31 +0,0 @@
-{
-  "name": "digipal-frontend",
-  "version": "1.0.0",
-  "private": true,
-  "scripts": {
-    "dev": "vite dev",
-    "build": "vite build",
-    "preview": "vite preview",
-    "check": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json",
-    "check:watch": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json --watch"
-  },
-  "devDependencies": {
-    "@sveltejs/adapter-auto": "^3.0.0",
-    "@sveltejs/kit": "^2.0.0",
-    "@sveltejs/vite-plugin-svelte": "^3.0.0",
-    "@types/three": "^0.160.0",
-    "svelte": "^4.2.7",
-    "svelte-check": "^3.6.0",
-    "tslib": "^2.4.1",
-    "typescript": "^5.0.0",
-    "vite": "^5.0.3"
-  },
-  "dependencies": {
-    "@threlte/core": "^7.1.0",
-    "@threlte/extras": "^8.7.5",
-    "three": "^0.160.1",
-    "tailwindcss": "^3.4.0",
-    "autoprefixer": "^10.4.16",
-    "postcss": "^8.4.32"
-  }
-}

frontend/postcss.config.js

@@ -1,6 +0,0 @@
-export default {
-  plugins: {
-    tailwindcss: {},
-    autoprefixer: {},
-  },
-}

frontend/src/app.css

@@ -1,153 +0,0 @@
-@import url('https://fonts.googleapis.com/css2?family=Press+Start+2P&family=Inter:wght@400;500;600;700&display=swap');
-@tailwind base;
-@tailwind components;
-@tailwind utilities;
-
-@layer base {
-  body {
-    @apply bg-black text-white;
-  }
-}
-
-@layer components {
-  /* CRT effect */
-  .crt-effect {
-    position: relative;
-    overflow: hidden;
-  }
-  
-  .crt-effect::before {
-    content: " ";
-    display: block;
-    position: absolute;
-    top: 0;
-    left: 0;
-    bottom: 0;
-    right: 0;
-    background: linear-gradient(
-      rgba(18, 16, 16, 0) 50%,
-      rgba(0, 0, 0, 0.25) 50%
-    );
-    background-size: 100% 2px;
-    z-index: 2;
-    pointer-events: none;
-    animation: scan-lines 8s linear infinite;
-  }
-  
-  .crt-effect::after {
-    content: " ";
-    display: block;
-    position: absolute;
-    top: 0;
-    left: 0;
-    bottom: 0;
-    right: 0;
-    background: rgba(18, 16, 16, 0.1);
-    opacity: 0;
-    z-index: 2;
-    pointer-events: none;
-    animation: flicker 0.15s infinite;
-  }
-  
-  /* Holographic button */
-  .holographic-button {
-    @apply relative px-4 py-2 font-pixel text-xs uppercase tracking-wider;
-    background: linear-gradient(45deg, #00CED1, #FF6B00, #00CED1);
-    background-size: 200% 200%;
-    animation: hologram 3s ease-in-out infinite;
-    clip-path: polygon(10% 0%, 100% 0%, 90% 100%, 0% 100%);
-  }
-  
-  .holographic-button:hover {
-    @apply brightness-125;
-  }
-  
-  /* Device frame */
-  .device-frame {
-    @apply relative bg-digipal-gray rounded-3xl p-8 shadow-2xl;
-    background-image: 
-      radial-gradient(circle at 20% 80%, #FF6B00 0%, transparent 50%),
-      radial-gradient(circle at 80% 20%, #00CED1 0%, transparent 50%),
-      radial-gradient(circle at 40% 40%, #2D2D2D 0%, transparent 50%);
-  }
-  
-  /* D-pad button */
-  .dpad-button {
-    @apply bg-gray-800 hover:bg-gray-700 active:bg-gray-900 transition-colors;
-    @apply border-2 border-gray-600;
-  }
-  
-  /* Action button */
-  .action-button {
-    @apply rounded-full bg-gradient-to-br from-gray-700 to-gray-900;
-    @apply hover:from-gray-600 hover:to-gray-800 active:from-gray-800 active:to-black;
-    @apply transition-all duration-150 transform active:scale-95;
-    @apply shadow-lg;
-  }
-}
-
-@keyframes flicker {
-  0% {
-    opacity: 0.27861;
-  }
-  5% {
-    opacity: 0.34769;
-  }
-  10% {
-    opacity: 0.23604;
-  }
-  15% {
-    opacity: 0.90626;
-  }
-  20% {
-    opacity: 0.18128;
-  }
-  25% {
-    opacity: 0.83891;
-  }
-  30% {
-    opacity: 0.65583;
-  }
-  35% {
-    opacity: 0.67807;
-  }
-  40% {
-    opacity: 0.26559;
-  }
-  45% {
-    opacity: 0.84693;
-  }
-  50% {
-    opacity: 0.96019;
-  }
-  55% {
-    opacity: 0.08594;
-  }
-  60% {
-    opacity: 0.20313;
-  }
-  65% {
-    opacity: 0.71988;
-  }
-  70% {
-    opacity: 0.53455;
-  }
-  75% {
-    opacity: 0.37288;
-  }
-  80% {
-    opacity: 0.71428;
-  }
-  85% {
-    opacity: 0.70419;
-  }
-  90% {
-    opacity: 0.7003;
-  }
-  95% {
-    opacity: 0.36108;
-  }
-  100% {
-    opacity: 0.24387;
-  }
-}

frontend/src/routes/+layout.svelte

@@ -1,5 +0,0 @@
-<script>
-  import '../app.css';
-</script>
-
-<slot />

frontend/src/routes/+page.svelte

@@ -1,14 +0,0 @@
-<script lang="ts">
-  import Device from '$lib/components/Device.svelte';
-  import { monsterStore } from '$lib/stores/monsterStore';
-  import { onMount } from 'svelte';
-  
-  onMount(() => {
-    // Initialize the app
-    monsterStore.initialize();
-  });
-</script>
-
-<main class="min-h-screen flex items-center justify-center bg-gradient-to-br from-gray-900 via-black to-gray-900">
-  <Device />
-</main>

frontend/svelte.config.js

@@ -1,14 +0,0 @@
-import adapter from '@sveltejs/adapter-auto';
-import { vitePreprocess } from '@sveltejs/vite-plugin-svelte';
-
-/** @type {import('@sveltejs/kit').Config} */
-const config = {
-  // Consult https://kit.svelte.dev/docs/integrations#preprocessors
-  preprocess: vitePreprocess(),
-
-  kit: {
-    adapter: adapter()
-  }
-};
-
-export default config;

frontend/tailwind.config.js

@@ -1,58 +0,0 @@
-/** @type {import('tailwindcss').Config} */
-export default {
-  content: ['./src/**/*.{html,js,svelte,ts}'],
-  theme: {
-    extend: {
-      colors: {
-        'digipal-orange': '#FF6B00',
-        'digipal-teal': '#00CED1',
-        'digipal-gray': '#2D2D2D',
-        'neon-magenta': '#FF00FF',
-        'neon-cyan': '#00FFFF',
-      },
-      fontFamily: {
-        'pixel': ['Press Start 2P', 'monospace'],
-        'modern': ['Inter', 'sans-serif'],
-      },
-      animation: {
-        'scan-lines': 'scan-lines 8s linear infinite',
-        'glitch': 'glitch 2s ease-in-out infinite alternate',
-        'hologram': 'hologram 3s ease-in-out infinite',
-      },
-      keyframes: {
-        'scan-lines': {
-          '0%': { transform: 'translateY(0)' },
-          '100%': { transform: 'translateY(100%)' },
-        },
-        'glitch': {
-          '0%': { 
-            textShadow: '0.05em 0 0 #00fffc, -0.03em -0.04em 0 #fc00ff, 0.025em 0.04em 0 #fffc00' 
-          },
-          '15%': { 
-            textShadow: '0.05em 0 0 #00fffc, -0.03em -0.04em 0 #fc00ff, 0.025em 0.04em 0 #fffc00' 
-          },
-          '16%': { 
-            textShadow: '-0.05em -0.025em 0 #00fffc, 0.025em 0.035em 0 #fc00ff, -0.05em -0.05em 0 #fffc00' 
-          },
-          '49%': { 
-            textShadow: '-0.05em -0.025em 0 #00fffc, 0.025em 0.035em 0 #fc00ff, -0.05em -0.05em 0 #fffc00' 
-          },
-          '50%': { 
-            textShadow: '0.05em 0.035em 0 #00fffc, 0.03em 0 0 #fc00ff, 0 -0.04em 0 #fffc00' 
-          },
-          '99%': { 
-            textShadow: '0.05em 0.035em 0 #00fffc, 0.03em 0 0 #fc00ff, 0 -0.04em 0 #fffc00' 
-          },
-          '100%': { 
-            textShadow: '-0.05em 0 0 #00fffc, -0.025em -0.04em 0 #fc00ff, -0.04em -0.025em 0 #fffc00' 
-          },
-        },
-        'hologram': {
-          '0%, 100%': { opacity: '1' },
-          '50%': { opacity: '0.7' },
-        },
-      },
-    },
-  },
-  plugins: [],
-}

frontend/tsconfig.json

@@ -1,13 +0,0 @@
-{
-  "extends": "./.svelte-kit/tsconfig.json",
-  "compilerOptions": {
-    "allowJs": true,
-    "checkJs": true,
-    "esModuleInterop": true,
-    "forceConsistentCasingInFileNames": true,
-    "resolveJsonModule": true,
-    "skipLibCheck": true,
-    "sourceMap": true,
-    "strict": true
-  }
-}

frontend/vite.config.ts

@@ -1,18 +0,0 @@
-import { sveltekit } from '@sveltejs/kit/vite';
-import { defineConfig } from 'vite';
-
-export default defineConfig({
-  plugins: [sveltekit()],
-  server: {
-    proxy: {
-      '/api': {
-        target: 'http://localhost:7861',
-        changeOrigin: true
-      },
-      '/api/ws': {
-        target: 'ws://localhost:7861',
-        ws: true
-      }
-    }
-  }
-});

game/__init__.py

@@ -0,0 +1 @@
+# Game module initialization

models/__init__.py

@@ -0,0 +1 @@
+# Model processors initialization

models/image_generator.py

@@ -0,0 +1,253 @@
+import torch
+from diffusers import DiffusionPipeline
+from PIL import Image
+import numpy as np
+from typing import Optional, List, Union
+import gc
+
+class OmniGenImageGenerator:
+    """Image generation using OmniGen2 model"""
+    
+    def __init__(self, device: str = "cuda"):
+        self.device = device if torch.cuda.is_available() else "cpu"
+        self.pipeline = None
+        self.model_id = "OmniGen2/OmniGen2"  # Placeholder - actual model path may differ
+        
+        # Generation parameters
+        self.default_width = 512
+        self.default_height = 512
+        self.num_inference_steps = 30
+        self.guidance_scale = 7.5
+        
+        # Memory optimization
+        self.enable_attention_slicing = True
+        self.enable_vae_slicing = True
+        self.enable_cpu_offload = self.device == "cuda"
+    
+    def load_model(self):
+        """Lazy load the image generation model"""
+        if self.pipeline is None:
+            try:
+                # Determine torch dtype
+                torch_dtype = torch.float16 if self.device == "cuda" else torch.float32
+                
+                # Load pipeline with optimizations
+                self.pipeline = DiffusionPipeline.from_pretrained(
+                    self.model_id,
+                    torch_dtype=torch_dtype,
+                    use_safetensors=True,
+                    variant="fp16" if self.device == "cuda" else None
+                )
+                
+                # Apply optimizations
+                if self.device == "cuda":
+                    if self.enable_cpu_offload:
+                        self.pipeline.enable_sequential_cpu_offload()
+                    else:
+                        self.pipeline = self.pipeline.to(self.device)
+                    
+                    if self.enable_attention_slicing:
+                        self.pipeline.enable_attention_slicing(1)
+                    
+                    if self.enable_vae_slicing:
+                        self.pipeline.enable_vae_slicing()
+                else:
+                    self.pipeline = self.pipeline.to(self.device)
+                
+                # Compile for faster inference (if available)
+                if hasattr(torch, 'compile') and self.device == "cuda":
+                    try:
+                        self.pipeline.unet = torch.compile(self.pipeline.unet, mode="reduce-overhead")
+                    except:
+                        pass  # Compilation is optional
+                
+            except Exception as e:
+                print(f"Failed to load image generation model: {e}")
+                # Try fallback to stable diffusion
+                try:
+                    self.model_id = "runwayml/stable-diffusion-v1-5"
+                    self._load_fallback_model()
+                except:
+                    raise
+    
+    def _load_fallback_model(self):
+        """Load fallback Stable Diffusion model"""
+        from diffusers import StableDiffusionPipeline
+        
+        torch_dtype = torch.float16 if self.device == "cuda" else torch.float32
+        
+        self.pipeline = StableDiffusionPipeline.from_pretrained(
+            self.model_id,
+            torch_dtype=torch_dtype,
+            use_safetensors=True
+        )
+        
+        if self.device == "cuda" and self.enable_cpu_offload:
+            self.pipeline.enable_sequential_cpu_offload()
+        else:
+            self.pipeline = self.pipeline.to(self.device)
+    
+    def generate(self, 
+                prompt: str,
+                reference_images: Optional[List[Union[str, Image.Image]]] = None,
+                negative_prompt: Optional[str] = None,
+                width: Optional[int] = None,
+                height: Optional[int] = None,
+                num_images: int = 1,
+                seed: Optional[int] = None) -> Union[Image.Image, List[Image.Image]]:
+        """Generate monster image from prompt"""
+        
+        try:
+            # Load model if needed
+            self.load_model()
+            
+            # Set dimensions
+            width = width or self.default_width
+            height = height or self.default_height
+            
+            # Ensure dimensions are multiples of 8
+            width = (width // 8) * 8
+            height = (height // 8) * 8
+            
+            # Enhance prompt for monster generation
+            enhanced_prompt = self._enhance_prompt(prompt)
+            
+            # Default negative prompt for quality
+            if negative_prompt is None:
+                negative_prompt = (
+                    "low quality, blurry, distorted, disfigured, "
+                    "bad anatomy, wrong proportions, ugly, duplicate, "
+                    "morbid, mutilated, extra limbs, malformed"
+                )
+            
+            # Set seed for reproducibility
+            generator = None
+            if seed is not None:
+                generator = torch.Generator(device=self.device).manual_seed(seed)
+            
+            # Generate images
+            with torch.no_grad():
+                if hasattr(self.pipeline, '__call__'):
+                    # Standard diffusion pipeline
+                    images = self.pipeline(
+                        prompt=enhanced_prompt,
+                        negative_prompt=negative_prompt,
+                        width=width,
+                        height=height,
+                        num_inference_steps=self.num_inference_steps,
+                        guidance_scale=self.guidance_scale,
+                        num_images_per_prompt=num_images,
+                        generator=generator
+                    ).images
+                else:
+                    # OmniGen specific generation (if different API)
+                    images = self._omnigen_generate(
+                        enhanced_prompt, 
+                        reference_images,
+                        width, 
+                        height, 
+                        num_images
+                    )
+            
+            # Clean up memory
+            if self.device == "cuda":
+                torch.cuda.empty_cache()
+            
+            # Return single image or list
+            if num_images == 1:
+                return images[0]
+            return images
+            
+        except Exception as e:
+            print(f"Image generation error: {e}")
+            # Return fallback image
+            return self._generate_fallback_image(width, height)
+    
+    def _enhance_prompt(self, base_prompt: str) -> str:
+        """Enhance prompt for better monster generation"""
+        enhancements = [
+            "digital art",
+            "creature design", 
+            "game character",
+            "detailed",
+            "vibrant colors",
+            "fantasy creature",
+            "high quality",
+            "professional artwork"
+        ]
+        
+        # Combine base prompt with enhancements
+        enhanced = f"{base_prompt}, {', '.join(enhancements)}"
+        
+        return enhanced
+    
+    def _omnigen_generate(self, prompt: str, reference_images: Optional[List], 
+                         width: int, height: int, num_images: int) -> List[Image.Image]:
+        """OmniGen specific generation with multimodal inputs"""
+        # This would be implemented based on OmniGen's specific API
+        # For now, fall back to standard generation
+        return self.pipeline(
+            prompt=prompt,
+            width=width,
+            height=height,
+            num_images_per_prompt=num_images
+        ).images
+    
+    def _generate_fallback_image(self, width: int, height: int) -> Image.Image:
+        """Generate a fallback monster image"""
+        # Create a simple procedural monster image
+        img_array = np.zeros((height, width, 3), dtype=np.uint8)
+        
+        # Add some basic shapes and colors
+        center_x, center_y = width // 2, height // 2
+        radius = min(width, height) // 3
+        
+        # Create circular body
+        y, x = np.ogrid[:height, :width]
+        mask = (x - center_x)**2 + (y - center_y)**2 <= radius**2
+        
+        # Random monster color
+        color = np.random.randint(50, 200, size=3)
+        img_array[mask] = color
+        
+        # Add eyes
+        eye_y = center_y - radius // 3
+        eye_left_x = center_x - radius // 3
+        eye_right_x = center_x + radius // 3
+        eye_radius = radius // 8
+        
+        # Left eye
+        eye_mask = (x - eye_left_x)**2 + (y - eye_y)**2 <= eye_radius**2
+        img_array[eye_mask] = [255, 255, 255]
+        
+        # Right eye  
+        eye_mask = (x - eye_right_x)**2 + (y - eye_y)**2 <= eye_radius**2
+        img_array[eye_mask] = [255, 255, 255]
+        
+        # Convert to PIL Image
+        return Image.fromarray(img_array)
+    
+    def edit_image(self, 
+                  image: Union[str, Image.Image],
+                  prompt: str,
+                  mask: Optional[Union[str, Image.Image]] = None) -> Image.Image:
+        """Edit existing image (for future monster customization)"""
+        # This would implement image editing capabilities
+        raise NotImplementedError("Image editing not yet implemented")
+    
+    def to(self, device: str):
+        """Move pipeline to specified device"""
+        self.device = device
+        if self.pipeline:
+            if device == "cuda" and self.enable_cpu_offload:
+                self.pipeline.enable_sequential_cpu_offload()
+            else:
+                self.pipeline = self.pipeline.to(device)
+    
+    def __del__(self):
+        """Cleanup when object is destroyed"""
+        if self.pipeline:
+            del self.pipeline
+        gc.collect()
+        if torch.cuda.is_available():
+            torch.cuda.empty_cache()

models/model_3d_generator.py

@@ -0,0 +1,283 @@
+import torch
+import numpy as np
+from PIL import Image
+import trimesh
+import tempfile
+from typing import Union, Optional, Dict, Any
+from pathlib import Path
+import os
+
+class Hunyuan3DGenerator:
+    """3D model generation using Hunyuan3D-2.1"""
+    
+    def __init__(self, device: str = "cuda"):
+        self.device = device if torch.cuda.is_available() else "cpu"
+        self.model = None
+        self.preprocessor = None
+        
+        # Model configuration
+        self.model_id = "tencent/Hunyuan3D-2.1"
+        self.lite_model_id = "tencent/Hunyuan3D-2.1-Lite"  # For low VRAM
+        
+        # Generation parameters
+        self.num_inference_steps = 50
+        self.guidance_scale = 7.5
+        self.resolution = 256  # 3D resolution
+        
+        # Use lite model for low VRAM
+        self.use_lite = self.device == "cpu" or not self._check_vram()
+    
+    def _check_vram(self) -> bool:
+        """Check if we have enough VRAM for full model"""
+        if not torch.cuda.is_available():
+            return False
+        
+        try:
+            vram = torch.cuda.get_device_properties(0).total_memory
+            # Need at least 12GB for full model
+            return vram > 12 * 1024 * 1024 * 1024
+        except:
+            return False
+    
+    def load_model(self):
+        """Lazy load the 3D generation model"""
+        if self.model is None:
+            try:
+                # Import Hunyuan3D components
+                from transformers import AutoModel, AutoProcessor
+                
+                model_id = self.lite_model_id if self.use_lite else self.model_id
+                
+                # Load preprocessor
+                self.preprocessor = AutoProcessor.from_pretrained(model_id)
+                
+                # Load model with optimizations
+                torch_dtype = torch.float16 if self.device == "cuda" else torch.float32
+                
+                self.model = AutoModel.from_pretrained(
+                    model_id,
+                    torch_dtype=torch_dtype,
+                    low_cpu_mem_usage=True,
+                    device_map="auto" if self.device == "cuda" else None
+                )
+                
+                if self.device == "cpu":
+                    self.model = self.model.to(self.device)
+                
+                # Enable optimizations
+                if hasattr(self.model, 'enable_attention_slicing'):
+                    self.model.enable_attention_slicing()
+                
+            except Exception as e:
+                print(f"Failed to load Hunyuan3D model: {e}")
+                # Model loading failed, will use fallback
+                self.model = "fallback"
+    
+    def image_to_3d(self, 
+                   image: Union[str, Image.Image, np.ndarray],
+                   remove_background: bool = True,
+                   texture_resolution: int = 1024) -> Union[str, trimesh.Trimesh]:
+        """Convert 2D image to 3D model"""
+        
+        try:
+            # Load model if needed
+            if self.model is None:
+                self.load_model()
+            
+            # If model loading failed, use fallback
+            if self.model == "fallback":
+                return self._generate_fallback_3d(image)
+            
+            # Prepare image
+            if isinstance(image, str):
+                image = Image.open(image)
+            elif isinstance(image, np.ndarray):
+                image = Image.fromarray(image)
+            
+            # Ensure RGB
+            if image.mode != 'RGB':
+                image = image.convert('RGB')
+            
+            # Resize for processing
+            image = image.resize((512, 512), Image.Resampling.LANCZOS)
+            
+            # Remove background if requested
+            if remove_background:
+                image = self._remove_background(image)
+            
+            # Process with model
+            with torch.no_grad():
+                # Preprocess image
+                inputs = self.preprocessor(images=image, return_tensors="pt").to(self.device)
+                
+                # Generate 3D
+                outputs = self.model.generate(
+                    **inputs,
+                    num_inference_steps=self.num_inference_steps,
+                    guidance_scale=self.guidance_scale,
+                    texture_resolution=texture_resolution
+                )
+                
+                # Extract mesh
+                mesh = self._extract_mesh(outputs)
+            
+            # Save mesh
+            mesh_path = self._save_mesh(mesh)
+            
+            return mesh_path
+            
+        except Exception as e:
+            print(f"3D generation error: {e}")
+            return self._generate_fallback_3d(image)
+    
+    def _remove_background(self, image: Image.Image) -> Image.Image:
+        """Remove background from image"""
+        try:
+            # Try using rembg if available
+            from rembg import remove
+            return remove(image)
+        except:
+            # Fallback: simple background removal
+            # Convert to RGBA
+            image = image.convert("RGBA")
+            
+            # Simple white background removal
+            datas = image.getdata()
+            new_data = []
+            
+            for item in datas:
+                # Remove white-ish backgrounds
+                if item[0] > 230 and item[1] > 230 and item[2] > 230:
+                    new_data.append((255, 255, 255, 0))
+                else:
+                    new_data.append(item)
+            
+            image.putdata(new_data)
+            return image
+    
+    def _extract_mesh(self, model_outputs: Dict[str, Any]) -> trimesh.Trimesh:
+        """Extract mesh from model outputs"""
+        # This would depend on actual Hunyuan3D output format
+        # Placeholder implementation
+        
+        if 'vertices' in model_outputs and 'faces' in model_outputs:
+            vertices = model_outputs['vertices'].cpu().numpy()
+            faces = model_outputs['faces'].cpu().numpy()
+            
+            # Create trimesh object
+            mesh = trimesh.Trimesh(vertices=vertices, faces=faces)
+            
+            # Add texture if available
+            if 'texture' in model_outputs:
+                # Apply texture to mesh
+                pass
+            
+            return mesh
+        else:
+            # Create a simple mesh if outputs are different
+            return self._create_simple_mesh()
+    
+    def _create_simple_mesh(self) -> trimesh.Trimesh:
+        """Create a simple placeholder mesh"""
+        # Create a simple sphere as placeholder
+        mesh = trimesh.creation.icosphere(subdivisions=3, radius=1.0)
+        
+        # Add some variation
+        mesh.vertices += np.random.normal(0, 0.05, mesh.vertices.shape)
+        
+        # Smooth the mesh
+        mesh = mesh.smoothed()
+        
+        return mesh
+    
+    def _generate_fallback_3d(self, image: Union[Image.Image, np.ndarray]) -> str:
+        """Generate fallback 3D model when main model fails"""
+        
+        # Create a simple 3D representation based on image
+        if isinstance(image, np.ndarray):
+            image = Image.fromarray(image)
+        elif isinstance(image, str):
+            image = Image.open(image)
+        
+        # Analyze image for basic shape
+        image_array = np.array(image.resize((64, 64)))
+        
+        # Create height map from image brightness
+        gray = np.mean(image_array, axis=2)
+        height_map = gray / 255.0
+        
+        # Create mesh from height map
+        mesh = self._heightmap_to_mesh(height_map)
+        
+        # Save and return path
+        return self._save_mesh(mesh)
+    
+    def _heightmap_to_mesh(self, heightmap: np.ndarray) -> trimesh.Trimesh:
+        """Convert heightmap to 3D mesh"""
+        h, w = heightmap.shape
+        
+        # Create vertices
+        vertices = []
+        faces = []
+        
+        # Create vertex grid
+        for i in range(h):
+            for j in range(w):
+                x = (j - w/2) / w * 2
+                y = (i - h/2) / h * 2
+                z = heightmap[i, j] * 0.5
+                vertices.append([x, y, z])
+        
+        # Create faces
+        for i in range(h-1):
+            for j in range(w-1):
+                # Two triangles per grid square
+                v1 = i * w + j
+                v2 = v1 + 1
+                v3 = v1 + w
+                v4 = v3 + 1
+                
+                faces.append([v1, v2, v3])
+                faces.append([v2, v4, v3])
+        
+        vertices = np.array(vertices)
+        faces = np.array(faces)
+        
+        # Create mesh
+        mesh = trimesh.Trimesh(vertices=vertices, faces=faces)
+        
+        # Apply smoothing
+        mesh = mesh.smoothed()
+        
+        return mesh
+    
+    def _save_mesh(self, mesh: trimesh.Trimesh) -> str:
+        """Save mesh to file"""
+        # Create temporary file
+        with tempfile.NamedTemporaryFile(suffix='.glb', delete=False) as tmp:
+            mesh_path = tmp.name
+        
+        # Export mesh
+        mesh.export(mesh_path)
+        
+        return mesh_path
+    
+    def text_to_3d(self, text_prompt: str) -> str:
+        """Generate 3D model from text description"""
+        # First generate image, then convert to 3D
+        # This would require image generator integration
+        raise NotImplementedError("Text to 3D requires image generation first")
+    
+    def to(self, device: str):
+        """Move model to specified device"""
+        self.device = device
+        if self.model and self.model != "fallback":
+            self.model.to(device)
+    
+    def __del__(self):
+        """Cleanup when object is destroyed"""
+        if self.model and self.model != "fallback":
+            del self.model
+        if self.preprocessor:
+            del self.preprocessor
+        torch.cuda.empty_cache()

models/rigging_processor.py

@@ -0,0 +1,546 @@
+import numpy as np
+import trimesh
+from typing import Union, Dict, List, Tuple, Optional
+import tempfile
+from pathlib import Path
+
+class UniRigProcessor:
+    """Automatic rigging for 3D models using simplified UniRig approach"""
+    
+    def __init__(self, device: str = "cuda"):
+        self.device = device
+        self.model = None
+        
+        # Rigging parameters
+        self.bone_detection_threshold = 0.1
+        self.max_bones = 20
+        self.min_bones = 5
+        
+        # Animation presets for monsters
+        self.animation_presets = {
+            'idle': self._create_idle_animation,
+            'walk': self._create_walk_animation,
+            'attack': self._create_attack_animation,
+            'happy': self._create_happy_animation
+        }
+    
+    def load_model(self):
+        """Load rigging model (placeholder for actual implementation)"""
+        # In production, this would load the actual UniRig model
+        # For now, we'll use procedural rigging
+        self.model = "procedural"
+    
+    def rig_mesh(self, 
+                mesh: Union[str, trimesh.Trimesh],
+                mesh_type: str = "monster") -> Dict[str, any]:
+        """Add rigging to a 3D mesh"""
+        
+        try:
+            # Load mesh if path provided
+            if isinstance(mesh, str):
+                mesh = trimesh.load(mesh)
+            
+            # Ensure model is loaded
+            if self.model is None:
+                self.load_model()
+            
+            # Analyze mesh structure
+            mesh_analysis = self._analyze_mesh(mesh)
+            
+            # Generate skeleton
+            skeleton = self._generate_skeleton(mesh, mesh_analysis)
+            
+            # Compute bone weights
+            weights = self._compute_bone_weights(mesh, skeleton)
+            
+            # Create rigged model
+            rigged_model = {
+                'mesh': mesh,
+                'skeleton': skeleton,
+                'weights': weights,
+                'animations': self._create_default_animations(skeleton),
+                'metadata': {
+                    'mesh_type': mesh_type,
+                    'bone_count': len(skeleton['bones']),
+                    'vertex_count': len(mesh.vertices)
+                }
+            }
+            
+            # Save rigged model
+            output_path = self._save_rigged_model(rigged_model)
+            
+            return output_path
+            
+        except Exception as e:
+            print(f"Rigging error: {e}")
+            # Return original mesh if rigging fails
+            return self._save_mesh_without_rigging(mesh)
+    
+    def _analyze_mesh(self, mesh: trimesh.Trimesh) -> Dict[str, any]:
+        """Analyze mesh structure for rigging"""
+        
+        # Get mesh bounds and center
+        bounds = mesh.bounds
+        center = mesh.centroid
+        
+        # Analyze mesh topology
+        analysis = {
+            'bounds': bounds,
+            'center': center,
+            'height': bounds[1][2] - bounds[0][2],
+            'width': bounds[1][0] - bounds[0][0],
+            'depth': bounds[1][1] - bounds[0][1],
+            'is_symmetric': self._check_symmetry(mesh),
+            'detected_limbs': self._detect_limbs(mesh),
+            'mesh_type': self._classify_mesh_type(mesh)
+        }
+        
+        return analysis
+    
+    def _check_symmetry(self, mesh: trimesh.Trimesh) -> bool:
+        """Check if mesh is roughly symmetric"""
+        # Simple check: compare left and right halves
+        vertices = mesh.vertices
+        center_x = mesh.centroid[0]
+        
+        left_verts = vertices[vertices[:, 0] < center_x]
+        right_verts = vertices[vertices[:, 0] > center_x]
+        
+        # Check if similar number of vertices on each side
+        ratio = len(left_verts) / (len(right_verts) + 1)
+        return 0.8 < ratio < 1.2
+    
+    def _detect_limbs(self, mesh: trimesh.Trimesh) -> List[Dict]:
+        """Detect potential limbs in the mesh"""
+        # Simplified limb detection using vertex clustering
+        from sklearn.cluster import DBSCAN
+        
+        limbs = []
+        
+        try:
+            # Cluster vertices to find distinct parts
+            clustering = DBSCAN(eps=0.1, min_samples=10).fit(mesh.vertices)
+            
+            # Analyze each cluster
+            for label in set(clustering.labels_):
+                if label == -1:  # Noise
+                    continue
+                
+                cluster_verts = mesh.vertices[clustering.labels_ == label]
+                
+                # Check if cluster could be a limb
+                cluster_bounds = np.array([cluster_verts.min(axis=0), cluster_verts.max(axis=0)])
+                dimensions = cluster_bounds[1] - cluster_bounds[0]
+                
+                # Limbs are typically elongated
+                if max(dimensions) / (min(dimensions) + 0.001) > 2:
+                    limbs.append({
+                        'center': cluster_verts.mean(axis=0),
+                        'direction': dimensions,
+                        'size': len(cluster_verts)
+                    })
+        except:
+            # Fallback if clustering fails
+            pass
+        
+        return limbs
+    
+    def _classify_mesh_type(self, mesh: trimesh.Trimesh) -> str:
+        """Classify the type of creature mesh"""
+        analysis = {
+            'height': mesh.bounds[1][2] - mesh.bounds[0][2],
+            'width': mesh.bounds[1][0] - mesh.bounds[0][0],
+            'depth': mesh.bounds[1][1] - mesh.bounds[0][1]
+        }
+        
+        # Simple classification based on proportions
+        aspect_ratio = analysis['height'] / max(analysis['width'], analysis['depth'])
+        
+        if aspect_ratio > 1.5:
+            return 'bipedal'  # Tall creatures
+        elif aspect_ratio < 0.7:
+            return 'quadruped'  # Wide creatures
+        else:
+            return 'hybrid'  # Mixed proportions
+    
+    def _generate_skeleton(self, mesh: trimesh.Trimesh, analysis: Dict) -> Dict:
+        """Generate skeleton for the mesh"""
+        
+        skeleton = {
+            'bones': [],
+            'hierarchy': {},
+            'bind_poses': []
+        }
+        
+        # Create root bone at center
+        root_pos = analysis['center']
+        root_bone = {
+            'id': 0,
+            'name': 'root',
+            'position': root_pos,
+            'parent': -1,
+            'children': []
+        }
+        skeleton['bones'].append(root_bone)
+        
+        # Generate bones based on mesh type
+        mesh_type = analysis['mesh_type']
+        
+        if mesh_type == 'bipedal':
+            skeleton = self._generate_bipedal_skeleton(mesh, skeleton, analysis)
+        elif mesh_type == 'quadruped':
+            skeleton = self._generate_quadruped_skeleton(mesh, skeleton, analysis)
+        else:
+            skeleton = self._generate_hybrid_skeleton(mesh, skeleton, analysis)
+        
+        # Build hierarchy
+        for bone in skeleton['bones']:
+            if bone['parent'] >= 0:
+                skeleton['bones'][bone['parent']]['children'].append(bone['id'])
+        
+        return skeleton
+    
+    def _generate_bipedal_skeleton(self, mesh: trimesh.Trimesh, skeleton: Dict, analysis: Dict) -> Dict:
+        """Generate skeleton for bipedal creature"""
+        
+        bounds = analysis['bounds']
+        center = analysis['center']
+        height = analysis['height']
+        
+        # Spine bones
+        spine_positions = [
+            center + [0, 0, -height * 0.4],  # Hips
+            center + [0, 0, 0],               # Chest
+            center + [0, 0, height * 0.3]     # Head
+        ]
+        
+        parent_id = 0
+        for i, pos in enumerate(spine_positions):
+            bone = {
+                'id': len(skeleton['bones']),
+                'name': ['hips', 'chest', 'head'][i],
+                'position': pos,
+                'parent': parent_id,
+                'children': []
+            }
+            skeleton['bones'].append(bone)
+            parent_id = bone['id']
+        
+        # Add limbs
+        chest_id = skeleton['bones'][2]['id']  # Chest bone
+        hips_id = skeleton['bones'][1]['id']   # Hips bone
+        
+        # Arms
+        arm_offset = analysis['width'] * 0.4
+        for side, offset in [('left', -arm_offset), ('right', arm_offset)]:
+            shoulder_pos = skeleton['bones'][chest_id]['position'] + [offset, 0, 0]
+            elbow_pos = shoulder_pos + [offset * 0.5, 0, -height * 0.2]
+            
+            # Shoulder
+            shoulder = {
+                'id': len(skeleton['bones']),
+                'name': f'{side}_shoulder',
+                'position': shoulder_pos,
+                'parent': chest_id,
+                'children': []
+            }
+            skeleton['bones'].append(shoulder)
+            
+            # Elbow/Hand
+            hand = {
+                'id': len(skeleton['bones']),
+                'name': f'{side}_hand',
+                'position': elbow_pos,
+                'parent': shoulder['id'],
+                'children': []
+            }
+            skeleton['bones'].append(hand)
+        
+        # Legs
+        for side, offset in [('left', -arm_offset * 0.5), ('right', arm_offset * 0.5)]:
+            hip_pos = skeleton['bones'][hips_id]['position'] + [offset, 0, 0]
+            foot_pos = hip_pos + [0, 0, -height * 0.4]
+            
+            # Leg
+            leg = {
+                'id': len(skeleton['bones']),
+                'name': f'{side}_leg',
+                'position': hip_pos,
+                'parent': hips_id,
+                'children': []
+            }
+            skeleton['bones'].append(leg)
+            
+            # Foot
+            foot = {
+                'id': len(skeleton['bones']),
+                'name': f'{side}_foot',
+                'position': foot_pos,
+                'parent': leg['id'],
+                'children': []
+            }
+            skeleton['bones'].append(foot)
+        
+        return skeleton
+    
+    def _generate_quadruped_skeleton(self, mesh: trimesh.Trimesh, skeleton: Dict, analysis: Dict) -> Dict:
+        """Generate skeleton for quadruped creature"""
+        
+        # Similar to bipedal but with 4 legs and horizontal spine
+        center = analysis['center']
+        width = analysis['width']
+        depth = analysis['depth']
+        
+        # Spine (horizontal)
+        spine_positions = [
+            center + [-width * 0.3, 0, 0],  # Tail
+            center,                          # Body
+            center + [width * 0.3, 0, 0]    # Head
+        ]
+        
+        parent_id = 0
+        for i, pos in enumerate(spine_positions):
+            bone = {
+                'id': len(skeleton['bones']),
+                'name': ['tail', 'body', 'head'][i],
+                'position': pos,
+                'parent': parent_id,
+                'children': []
+            }
+            skeleton['bones'].append(bone)
+            parent_id = bone['id'] if i < 2 else skeleton['bones'][1]['id']
+        
+        # Add 4 legs
+        body_id = skeleton['bones'][1]['id']
+        
+        for front_back, x_offset in [('front', width * 0.2), ('back', -width * 0.2)]:
+            for side, z_offset in [('left', -depth * 0.3), ('right', depth * 0.3)]:
+                leg_pos = skeleton['bones'][body_id]['position'] + [x_offset, -analysis['height'] * 0.3, z_offset]
+                
+                leg = {
+                    'id': len(skeleton['bones']),
+                    'name': f'{front_back}_{side}_leg',
+                    'position': leg_pos,
+                    'parent': body_id,
+                    'children': []
+                }
+                skeleton['bones'].append(leg)
+        
+        return skeleton
+    
+    def _generate_hybrid_skeleton(self, mesh: trimesh.Trimesh, skeleton: Dict, analysis: Dict) -> Dict:
+        """Generate skeleton for hybrid creature"""
+        # Mix of bipedal and quadruped features
+        # For simplicity, use bipedal as base
+        return self._generate_bipedal_skeleton(mesh, skeleton, analysis)
+    
+    def _compute_bone_weights(self, mesh: trimesh.Trimesh, skeleton: Dict) -> np.ndarray:
+        """Compute bone weights for vertices"""
+        
+        num_vertices = len(mesh.vertices)
+        num_bones = len(skeleton['bones'])
+        
+        # Initialize weights matrix
+        weights = np.zeros((num_vertices, num_bones))
+        
+        # For each vertex, compute influence from each bone
+        for v_idx, vertex in enumerate(mesh.vertices):
+            total_weight = 0
+            
+            for b_idx, bone in enumerate(skeleton['bones']):
+                # Distance-based weight
+                distance = np.linalg.norm(vertex - bone['position'])
+                
+                # Inverse distance weight with falloff
+                weight = 1.0 / (distance + 0.1)
+                weights[v_idx, b_idx] = weight
+                total_weight += weight
+            
+            # Normalize weights
+            if total_weight > 0:
+                weights[v_idx] /= total_weight
+            
+            # Keep only top 4 influences per vertex (standard for game engines)
+            top_4 = np.argsort(weights[v_idx])[-4:]
+            mask = np.zeros(num_bones, dtype=bool)
+            mask[top_4] = True
+            weights[v_idx, ~mask] = 0
+            
+            # Re-normalize
+            if weights[v_idx].sum() > 0:
+                weights[v_idx] /= weights[v_idx].sum()
+        
+        return weights
+    
+    def _create_default_animations(self, skeleton: Dict) -> Dict[str, List]:
+        """Create default animations for the skeleton"""
+        
+        animations = {}
+        
+        # Create basic animation sets
+        for anim_name, anim_func in self.animation_presets.items():
+            animations[anim_name] = anim_func(skeleton)
+        
+        return animations
+    
+    def _create_idle_animation(self, skeleton: Dict) -> List[Dict]:
+        """Create idle animation keyframes"""
+        
+        keyframes = []
+        
+        # Simple breathing/bobbing motion
+        for t in np.linspace(0, 2 * np.pi, 30):
+            frame = {
+                'time': t / (2 * np.pi),
+                'bones': {}
+            }
+            
+            # Subtle movement for each bone
+            for bone in skeleton['bones']:
+                if 'chest' in bone['name'] or 'body' in bone['name']:
+                    # Breathing motion
+                    offset = np.sin(t) * 0.02
+                    frame['bones'][bone['id']] = {
+                        'position': bone['position'] + [0, offset, 0],
+                        'rotation': [0, 0, 0, 1]  # Quaternion
+                    }
+                else:
+                    # No movement
+                    frame['bones'][bone['id']] = {
+                        'position': bone['position'],
+                        'rotation': [0, 0, 0, 1]
+                    }
+            
+            keyframes.append(frame)
+        
+        return keyframes
+    
+    def _create_walk_animation(self, skeleton: Dict) -> List[Dict]:
+        """Create walk animation keyframes"""
+        # Simplified walk cycle
+        keyframes = []
+        
+        for t in np.linspace(0, 2 * np.pi, 60):
+            frame = {
+                'time': t / (2 * np.pi),
+                'bones': {}
+            }
+            
+            # Animate legs with sine waves
+            for bone in skeleton['bones']:
+                if 'leg' in bone['name'] or 'foot' in bone['name']:
+                    # Alternating leg movement
+                    phase = 0 if 'left' in bone['name'] else np.pi
+                    offset = np.sin(t + phase) * 0.1
+                    
+                    frame['bones'][bone['id']] = {
+                        'position': bone['position'] + [offset, 0, 0],
+                        'rotation': [0, 0, 0, 1]
+                    }
+                else:
+                    frame['bones'][bone['id']] = {
+                        'position': bone['position'],
+                        'rotation': [0, 0, 0, 1]
+                    }
+            
+            keyframes.append(frame)
+        
+        return keyframes
+    
+    def _create_attack_animation(self, skeleton: Dict) -> List[Dict]:
+        """Create attack animation keyframes"""
+        # Quick strike motion
+        keyframes = []
+        
+        # Wind up
+        for t in np.linspace(0, 0.3, 10):
+            frame = {'time': t, 'bones': {}}
+            for bone in skeleton['bones']:
+                frame['bones'][bone['id']] = {
+                    'position': bone['position'],
+                    'rotation': [0, 0, 0, 1]
+                }
+            keyframes.append(frame)
+        
+        # Strike
+        for t in np.linspace(0.3, 0.5, 5):
+            frame = {'time': t, 'bones': {}}
+            for bone in skeleton['bones']:
+                if 'hand' in bone['name'] or 'head' in bone['name']:
+                    # Forward motion
+                    offset = (t - 0.3) * 0.5
+                    frame['bones'][bone['id']] = {
+                        'position': bone['position'] + [offset, 0, 0],
+                        'rotation': [0, 0, 0, 1]
+                    }
+                else:
+                    frame['bones'][bone['id']] = {
+                        'position': bone['position'],
+                        'rotation': [0, 0, 0, 1]
+                    }
+            keyframes.append(frame)
+        
+        # Return
+        for t in np.linspace(0.5, 1.0, 10):
+            frame = {'time': t, 'bones': {}}
+            for bone in skeleton['bones']:
+                frame['bones'][bone['id']] = {
+                    'position': bone['position'],
+                    'rotation': [0, 0, 0, 1]
+                }
+            keyframes.append(frame)
+        
+        return keyframes
+    
+    def _create_happy_animation(self, skeleton: Dict) -> List[Dict]:
+        """Create happy/excited animation keyframes"""
+        # Jumping or bouncing motion
+        keyframes = []
+        
+        for t in np.linspace(0, 2 * np.pi, 40):
+            frame = {
+                'time': t / (2 * np.pi),
+                'bones': {}
+            }
+            
+            # Bouncing motion
+            bounce = abs(np.sin(t * 2)) * 0.1
+            
+            for bone in skeleton['bones']:
+                frame['bones'][bone['id']] = {
+                    'position': bone['position'] + [0, bounce, 0],
+                    'rotation': [0, 0, 0, 1]
+                }
+            
+            keyframes.append(frame)
+        
+        return keyframes
+    
+    def _save_rigged_model(self, rigged_model: Dict) -> str:
+        """Save rigged model to file"""
+        
+        # Create temporary file
+        with tempfile.NamedTemporaryFile(suffix='.glb', delete=False) as tmp:
+            output_path = tmp.name
+        
+        # In production, this would export the rigged model with animations
+        # For now, just save the mesh
+        rigged_model['mesh'].export(output_path)
+        
+        return output_path
+    
+    def _save_mesh_without_rigging(self, mesh: Union[str, trimesh.Trimesh]) -> str:
+        """Save mesh without rigging as fallback"""
+        
+        if isinstance(mesh, str):
+            return mesh
+        
+        with tempfile.NamedTemporaryFile(suffix='.glb', delete=False) as tmp:
+            output_path = tmp.name
+        
+        mesh.export(output_path)
+        return output_path
+    
+    def to(self, device: str):
+        """Move model to specified device (compatibility method)"""
+        self.device = device

models/stt_processor.py

@@ -0,0 +1,154 @@
+import torch
+import torchaudio
+from transformers import AutoModelForSpeechSeq2Seq, AutoProcessor
+import numpy as np
+from typing import Optional, Union
+import librosa
+import soundfile as sf
+import os
+
+class KyutaiSTTProcessor:
+    """Processor for Kyutai Speech-to-Text model"""
+    
+    def __init__(self, device: str = "cuda"):
+        self.device = device if torch.cuda.is_available() else "cpu"
+        self.model = None
+        self.processor = None
+        self.model_id = "kyutai/stt-2.6b-en"  # English-only model for better accuracy
+        
+        # Audio processing parameters
+        self.sample_rate = 16000
+        self.chunk_length_s = 30  # Process in 30-second chunks
+        self.max_duration = 120  # Maximum 2 minutes of audio
+    
+    def load_model(self):
+        """Lazy load the STT model"""
+        if self.model is None:
+            try:
+                # Load processor and model
+                self.processor = AutoProcessor.from_pretrained(self.model_id)
+                
+                # Model configuration for low VRAM usage
+                torch_dtype = torch.float16 if self.device == "cuda" else torch.float32
+                
+                self.model = AutoModelForSpeechSeq2Seq.from_pretrained(
+                    self.model_id,
+                    torch_dtype=torch_dtype,
+                    low_cpu_mem_usage=True,
+                    use_safetensors=True
+                )
+                
+                self.model.to(self.device)
+                
+                # Enable better generation settings
+                self.model.generation_config.language = "english"
+                self.model.generation_config.task = "transcribe"
+                self.model.generation_config.forced_decoder_ids = None
+                
+            except Exception as e:
+                print(f"Failed to load STT model: {e}")
+                raise
+    
+    def preprocess_audio(self, audio_path: str) -> np.ndarray:
+        """Preprocess audio file for transcription"""
+        try:
+            # Load audio file
+            audio, sr = librosa.load(audio_path, sr=None, mono=True)
+            
+            # Resample if necessary
+            if sr != self.sample_rate:
+                audio = librosa.resample(audio, orig_sr=sr, target_sr=self.sample_rate)
+            
+            # Limit duration
+            max_samples = self.max_duration * self.sample_rate
+            if len(audio) > max_samples:
+                audio = audio[:max_samples]
+            
+            # Normalize audio
+            audio = audio / np.max(np.abs(audio) + 1e-7)
+            
+            return audio
+            
+        except Exception as e:
+            print(f"Error preprocessing audio: {e}")
+            raise
+    
+    def transcribe(self, audio_input: Union[str, np.ndarray]) -> str:
+        """Transcribe audio to text"""
+        try:
+            # Load model if not already loaded
+            self.load_model()
+            
+            # Process audio input
+            if isinstance(audio_input, str):
+                audio = self.preprocess_audio(audio_input)
+            else:
+                audio = audio_input
+            
+            # Process with model
+            inputs = self.processor(
+                audio, 
+                sampling_rate=self.sample_rate, 
+                return_tensors="pt"
+            ).to(self.device)
+            
+            # Generate transcription
+            with torch.no_grad():
+                generated_ids = self.model.generate(
+                    inputs["input_features"],
+                    max_new_tokens=128,
+                    do_sample=False,
+                    num_beams=1  # Greedy decoding for speed
+                )
+            
+            # Decode transcription
+            transcription = self.processor.batch_decode(
+                generated_ids, 
+                skip_special_tokens=True,
+                clean_up_tokenization_spaces=True
+            )[0]
+            
+            # Clean up transcription
+            transcription = self._clean_transcription(transcription)
+            
+            return transcription
+            
+        except Exception as e:
+            print(f"Transcription error: {e}")
+            # Return a default description on error
+            return "Create a unique digital monster companion"
+    
+    def _clean_transcription(self, text: str) -> str:
+        """Clean up transcription output"""
+        # Remove extra whitespace
+        text = " ".join(text.split())
+        
+        # Ensure proper capitalization
+        if text and text[0].islower():
+            text = text[0].upper() + text[1:]
+        
+        # Add period if missing
+        if text and not text[-1] in '.!?':
+            text += '.'
+        
+        return text
+    
+    def transcribe_streaming(self, audio_stream):
+        """Streaming transcription (for future implementation)"""
+        # This would handle real-time audio streams
+        # For now, return placeholder
+        raise NotImplementedError("Streaming transcription not yet implemented")
+    
+    def to(self, device: str):
+        """Move model to specified device"""
+        self.device = device
+        if self.model:
+            self.model.to(device)
+    
+    def __del__(self):
+        """Cleanup when object is destroyed"""
+        if self.model:
+            del self.model
+        if self.processor:
+            del self.processor
+        torch.cuda.empty_cache()

models/text_generator.py

@@ -0,0 +1,299 @@
+import torch
+from transformers import AutoModelForCausalLM, AutoTokenizer
+import json
+import random
+from typing import Dict, Any, List
+
+class QwenTextGenerator:
+    """Text generation using Qwen2.5-0.5B-Instruct for monster traits and dialogue"""
+    
+    def __init__(self, device: str = "cuda"):
+        self.device = device if torch.cuda.is_available() else "cpu"
+        self.model = None
+        self.tokenizer = None
+        self.model_id = "Qwen/Qwen2.5-0.5B-Instruct"
+        
+        # Generation parameters
+        self.max_new_tokens = 150
+        self.temperature = 0.8
+        self.top_p = 0.9
+        
+        # Monster trait templates
+        self.trait_categories = {
+            'elements': ['fire', 'water', 'earth', 'wind', 'electric', 'ice', 'nature', 'dark', 'light', 'neutral'],
+            'personalities': ['brave', 'timid', 'aggressive', 'gentle', 'playful', 'serious', 'loyal', 'independent', 'curious', 'protective'],
+            'body_types': ['bipedal', 'quadruped', 'serpentine', 'avian', 'aquatic', 'insectoid', 'humanoid', 'amorphous'],
+            'sizes': ['tiny', 'small', 'medium', 'large', 'giant'],
+            'special_features': ['wings', 'horns', 'tail', 'spikes', 'fur', 'scales', 'armor', 'crystals', 'flames', 'aura']
+        }
+    
+    def load_model(self):
+        """Lazy load the text generation model"""
+        if self.model is None:
+            try:
+                # Load tokenizer
+                self.tokenizer = AutoTokenizer.from_pretrained(self.model_id)
+                
+                # Model configuration
+                torch_dtype = torch.float16 if self.device == "cuda" else torch.float32
+                
+                self.model = AutoModelForCausalLM.from_pretrained(
+                    self.model_id,
+                    torch_dtype=torch_dtype,
+                    device_map="auto" if self.device == "cuda" else None,
+                    low_cpu_mem_usage=True
+                )
+                
+                if self.device == "cpu":
+                    self.model.to(self.device)
+                
+            except Exception as e:
+                print(f"Failed to load text generation model: {e}")
+                raise
+    
+    def generate_traits(self, description: str) -> Dict[str, Any]:
+        """Generate monster traits from description"""
+        try:
+            self.load_model()
+            
+            # Create prompt for trait generation
+            prompt = self._create_trait_prompt(description)
+            
+            # Generate response
+            inputs = self.tokenizer(prompt, return_tensors="pt").to(self.device)
+            
+            with torch.no_grad():
+                outputs = self.model.generate(
+                    **inputs,
+                    max_new_tokens=self.max_new_tokens,
+                    temperature=self.temperature,
+                    top_p=self.top_p,
+                    do_sample=True,
+                    pad_token_id=self.tokenizer.eos_token_id
+                )
+            
+            response = self.tokenizer.decode(outputs[0][inputs['input_ids'].shape[1]:], skip_special_tokens=True)
+            
+            # Parse traits from response
+            traits = self._parse_traits(response, description)
+            
+            return traits
+            
+        except Exception as e:
+            print(f"Error generating traits: {e}")
+            return self._generate_fallback_traits(description)
+    
+    def generate_dialogue(self, traits: Dict[str, Any]) -> str:
+        """Generate monster dialogue (emoji + numbers)"""
+        try:
+            # Create emoji dialogue based on personality and mood
+            personality = traits.get('personality', 'neutral')
+            
+            # Emoji mapping for personalities
+            emoji_map = {
+                'brave': ['💪', '🔥', '⚔️', '🛡️'],
+                'timid': ['😰', '🥺', '💦', '❓'],
+                'aggressive': ['😤', '💢', '🔥', '⚡'],
+                'gentle': ['💚', '🌸', '✨', '🌟'],
+                'playful': ['😊', '🎮', '🎯', '🎪'],
+                'serious': ['🤖', '📊', '⚡', '💯'],
+                'loyal': ['💖', '🤝', '🛡️', '⭐'],
+                'independent': ['🚀', '🌍', '🔮', '💫'],
+                'curious': ['🔍', '❓', '💡', '🌟'],
+                'protective': ['🛡️', '💪', '🏰', '⚔️']
+            }
+            
+            # Get appropriate emojis
+            emojis = emoji_map.get(personality, ['🤖', '💚', '✨'])
+            selected_emojis = random.sample(emojis, min(2, len(emojis)))
+            
+            # Generate status numbers (representing monster's current state)
+            hp_percent = random.randint(70, 100)
+            happiness = random.randint(60, 95)
+            energy = random.randint(50, 90)
+            
+            # Create dialogue
+            dialogue = f"{selected_emojis[0]}{selected_emojis[1] if len(selected_emojis) > 1 else '💚'}"
+            dialogue += f"{hp_percent}️⃣{happiness}️⃣"
+            
+            return dialogue
+            
+        except Exception as e:
+            print(f"Error generating dialogue: {e}")
+            return "🤖💚9️⃣0️⃣"
+    
+    def _create_trait_prompt(self, description: str) -> str:
+        """Create prompt for trait generation"""
+        prompt = f"""<|im_start|>system
+You are a creative game designer creating unique digital monsters. Generate detailed traits for a monster based on the description.
+<|im_end|>
+<|im_start|>user
+Create traits for this monster: {description}
+
+Include: name, species, element, personality, appearance details, and special abilities.
+<|im_end|>
+<|im_start|>assistant
+"""
+        return prompt
+    
+    def _parse_traits(self, response: str, original_description: str) -> Dict[str, Any]:
+        """Parse traits from model response"""
+        traits = {
+            'description': original_description,
+            'raw_response': response
+        }
+        
+        # Extract name
+        if "name:" in response.lower():
+            name_start = response.lower().find("name:") + 5
+            name_end = response.find("\n", name_start)
+            if name_end == -1:
+                name_end = len(response)
+            traits['name'] = response[name_start:name_end].strip()
+        else:
+            traits['name'] = self._generate_name()
+        
+        # Extract or assign element
+        element_found = False
+        for element in self.trait_categories['elements']:
+            if element in response.lower():
+                traits['element'] = element
+                element_found = True
+                break
+        
+        if not element_found:
+            traits['element'] = random.choice(self.trait_categories['elements'])
+        
+        # Extract or assign personality
+        personality_found = False
+        for personality in self.trait_categories['personalities']:
+            if personality in response.lower():
+                traits['personality'] = personality
+                personality_found = True
+                break
+        
+        if not personality_found:
+            traits['personality'] = random.choice(self.trait_categories['personalities'])
+        
+        # Extract appearance
+        traits['appearance'] = self._extract_appearance(response)
+        
+        # Extract abilities
+        traits['abilities'] = self._extract_abilities(response, traits['element'])
+        
+        # Add color scheme based on element
+        traits['color_scheme'] = self._get_color_scheme(traits['element'])
+        
+        return traits
+    
+    def _generate_name(self) -> str:
+        """Generate a random monster name"""
+        prefixes = ['Pyro', 'Aqua', 'Terra', 'Aero', 'Volt', 'Cryo', 'Flora', 'Shadow', 'Lumi', 'Neo']
+        suffixes = ['mon', 'beast', 'guard', 'wing', 'claw', 'fang', 'horn', 'tail', 'byte', 'spark']
+        
+        return random.choice(prefixes) + random.choice(suffixes)
+    
+    def _extract_appearance(self, response: str) -> str:
+        """Extract appearance description"""
+        appearance_keywords = ['appearance', 'looks like', 'resembles', 'body', 'color', 'size']
+        
+        for keyword in appearance_keywords:
+            if keyword in response.lower():
+                start = response.lower().find(keyword)
+                end = response.find('.', start)
+                if end == -1:
+                    end = response.find('\n', start)
+                if end == -1:
+                    end = len(response)
+                
+                return response[start:end].strip()
+        
+        # Fallback appearance
+        body_type = random.choice(self.trait_categories['body_types'])
+        size = random.choice(self.trait_categories['sizes'])
+        feature = random.choice(self.trait_categories['special_features'])
+        
+        return f"A {size} {body_type} creature with {feature}"
+    
+    def _extract_abilities(self, response: str, element: str) -> List[str]:
+        """Extract or generate abilities"""
+        abilities = []
+        
+        ability_keywords = ['ability', 'power', 'skill', 'can', 'capable']
+        for keyword in ability_keywords:
+            if keyword in response.lower():
+                # Try to extract abilities from response
+                start = response.lower().find(keyword)
+                end = response.find('.', start)
+                if end > start:
+                    ability_text = response[start:end]
+                    abilities.append(ability_text.strip())
+        
+        # If no abilities found, generate based on element
+        if not abilities:
+            element_abilities = {
+                'fire': ['Flame Burst', 'Heat Wave', 'Ember Shield'],
+                'water': ['Aqua Jet', 'Bubble Shield', 'Tidal Wave'],
+                'earth': ['Rock Throw', 'Earthquake', 'Stone Armor'],
+                'wind': ['Gust', 'Tornado', 'Wind Shield'],
+                'electric': ['Thunder Shock', 'Static Field', 'Lightning Speed'],
+                'ice': ['Ice Beam', 'Frost Armor', 'Blizzard'],
+                'nature': ['Vine Whip', 'Healing Bloom', 'Nature\'s Guard'],
+                'dark': ['Shadow Strike', 'Dark Pulse', 'Void Shield'],
+                'light': ['Light Beam', 'Healing Light', 'Radiant Shield'],
+                'neutral': ['Tackle', 'Defense Curl', 'Focus']
+            }
+            
+            abilities = random.sample(
+                element_abilities.get(element, element_abilities['neutral']), 
+                2
+            )
+        
+        return abilities
+    
+    def _get_color_scheme(self, element: str) -> str:
+        """Get color scheme based on element"""
+        color_schemes = {
+            'fire': 'red and orange with yellow accents',
+            'water': 'blue and cyan with white highlights',
+            'earth': 'brown and green with stone textures',
+            'wind': 'white and light blue with swirling patterns',
+            'electric': 'yellow and blue with sparking effects',
+            'ice': 'light blue and white with crystalline features',
+            'nature': 'green and brown with leaf patterns',
+            'dark': 'black and purple with shadow effects',
+            'light': 'white and gold with glowing aura',
+            'neutral': 'gray and silver with balanced tones'
+        }
+        
+        return color_schemes.get(element, 'varied colors with unique patterns')
+    
+    def _generate_fallback_traits(self, description: str) -> Dict[str, Any]:
+        """Generate fallback traits if model fails"""
+        element = random.choice(self.trait_categories['elements'])
+        personality = random.choice(self.trait_categories['personalities'])
+        
+        return {
+            'name': self._generate_name(),
+            'species': 'Digital Monster',
+            'element': element,
+            'personality': personality,
+            'appearance': f"A unique {random.choice(self.trait_categories['sizes'])} digital creature",
+            'color_scheme': self._get_color_scheme(element),
+            'abilities': self._extract_abilities("", element),
+            'description': description
+        }
+    
+    def to(self, device: str):
+        """Move model to specified device"""
+        self.device = device
+        if self.model:
+            self.model.to(device)
+    
+    def __del__(self):
+        """Cleanup when object is destroyed"""
+        if self.model:
+            del self.model
+        if self.tokenizer:
+            del self.tokenizer
+        torch.cuda.empty_cache()

requirements.txt

@@ -1,57 +1,48 @@
-# Core ML Framework - Latest optimized versions
-transformers>=4.52.4  # Latest stable, supports Qwen 2.5
-torch>=2.2.0  # PyTorch 2.0+ for torch.compile
-torchaudio>=2.2.0
-diffusers>=0.30.0  # For OmniGen and other diffusion models
-# gradio>=5.34.2  # Replaced with Streamlit
-
-# Qwen 2.5 Optimization Stack
-# auto-gptq>=0.7.1  # Removed - not needed, using BitsAndBytesConfig instead
-optimum>=1.16.0
-accelerate>=0.26.1
-bitsandbytes>=0.42.0
-# FlashAttention2 will be installed at runtime if GPU is available
-
-# Enhanced Audio Processing - Kyutai STT
+# Core dependencies
+gradio>=4.16.0
+spaces>=0.19.0
+
+# AI/ML frameworks
+torch>=2.1.0
+torchvision>=0.16.0
+torchaudio>=2.1.0
+transformers>=4.36.0
+diffusers>=0.24.0
+accelerate>=0.25.0
+bitsandbytes>=0.41.0
+
+# Model-specific dependencies
+huggingface-hub>=0.20.0
+safetensors>=0.4.1
+sentencepiece>=0.1.99
+tokenizers>=0.15.0
+
+# Audio processing
+librosa>=0.10.1
 soundfile>=0.12.1
-webrtcvad>=2.0.10
-# Note: transformers and torch/torchaudio above provide Kyutai STT support
 
-# Production Backend
-fastapi>=0.108.0
-uvicorn[standard]>=0.25.0
-pydantic>=2.5.0
-websockets>=12.0
-streamlit>=1.28.0  # Modern UI framework replacing Gradio
+# Image processing
+Pillow>=10.0.0
+opencv-python>=4.8.0
+rembg>=2.0.50
 
-# Advanced State Management
-apscheduler>=3.10.4
-aiosqlite>=0.19.0
+# 3D processing
+trimesh>=4.0.0
+numpy-stl>=3.1.1
+pygltflib>=1.16.1
 
-# Zero GPU Optimization (kept for speech engine compatibility)
-spaces>=0.28.0
-
-# 3D Generation Pipeline Dependencies
-gradio_client>=0.8.0  # For Hunyuan3D Space API integration
-trimesh>=4.0.0  # 3D mesh processing
-aiohttp>=3.9.0  # Async HTTP for API calls
-
-# Core Utilities
+# Scientific computing
 numpy>=1.24.0
-pandas>=2.1.0
-pillow>=10.1.0
-python-dateutil>=2.8.2
-emoji>=2.8.0
-psutil>=5.9.0
-
-# Async Support
-aiofiles>=23.2.0
-asyncio-mqtt>=0.16.1
-
-# Scientific Computing
 scipy>=1.11.0
 scikit-learn>=1.3.0
 
-# Development Tools
-pytest>=7.4.0
-black>=23.0.0
+# Utilities
+python-dateutil>=2.8.2
+tqdm>=4.66.0
+pyyaml>=6.0.1
+requests>=2.31.0
+aiofiles>=23.2.1
+
+# Optional optimizations
+# onnxruntime-gpu>=1.16.0  # For ONNX model support
+# xformers>=0.0.23  # For memory-efficient attention

run_digipal.py

@@ -1,80 +0,0 @@
-#!/usr/bin/env python3
-"""
-DigiPal Launcher Script
-Starts both FastAPI backend and Streamlit frontend
-"""
-
-import subprocess
-import time
-import sys
-import os
-import threading
-import logging
-
-# Configure logging
-logging.basicConfig(
-    level=logging.INFO,
-    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
-)
-logger = logging.getLogger(__name__)
-
-def start_fastapi():
-    """Start FastAPI backend server"""
-    logger.info("Starting FastAPI backend server...")
-    try:
-        subprocess.run([sys.executable, "app.py"], check=True)
-    except subprocess.CalledProcessError as e:
-        logger.error(f"FastAPI server failed: {e}")
-    except KeyboardInterrupt:
-        logger.info("FastAPI server stopped")
-
-def start_streamlit():
-    """Start Streamlit frontend"""
-    logger.info("Starting Streamlit frontend...")
-    try:
-        port = os.getenv("STREAMLIT_PORT", "8501")
-        subprocess.run([
-            sys.executable, "-m", "streamlit", "run", 
-            "src/ui/streamlit_interface.py",
-            "--server.port", port,
-            "--server.address", "0.0.0.0"
-        ], check=True)
-    except subprocess.CalledProcessError as e:
-        logger.error(f"Streamlit frontend failed: {e}")
-    except KeyboardInterrupt:
-        logger.info("Streamlit frontend stopped")
-
-def main():
-    """Main launcher function"""
-    logger.info("🐉 DigiPal - Advanced AI Monster Companion")
-    logger.info("=" * 60)
-    logger.info("Starting both FastAPI backend and Streamlit frontend...")
-    api_port = os.getenv("API_PORT", "7861")
-    streamlit_port = os.getenv("STREAMLIT_PORT", "8501")
-    logger.info(f"FastAPI Backend: http://localhost:{api_port}")
-    logger.info(f"Streamlit Frontend: http://localhost:{streamlit_port}")
-    logger.info("=" * 60)
-    
-    # Create necessary directories
-    os.makedirs("data/saves", exist_ok=True)
-    os.makedirs("data/models", exist_ok=True)
-    os.makedirs("data/cache", exist_ok=True)
-    os.makedirs("logs", exist_ok=True)
-    
-    try:
-        # Start FastAPI in a separate thread
-        fastapi_thread = threading.Thread(target=start_fastapi, daemon=True)
-        fastapi_thread.start()
-        
-        # Give FastAPI time to start
-        time.sleep(3)
-        
-        # Start Streamlit (this will block)
-        start_streamlit()
-        
-    except KeyboardInterrupt:
-        logger.info("Shutting down DigiPal...")
-        sys.exit(0)
-
-if __name__ == "__main__":
-    main()

src/ai/__init__.py

@@ -1 +0,0 @@
-# AI module initialization

src/ai/qwen_processor.py

@@ -1,621 +0,0 @@
-import torch
-from transformers import (
-    AutoModelForCausalLM, 
-    AutoTokenizer, 
-    pipeline,
-    BitsAndBytesConfig
-)
-# GPTQConfig is no longer needed - we'll use BitsAndBytesConfig for quantization
-import asyncio
-import logging
-from typing import Dict, List, Optional, Any
-import json
-import time
-from dataclasses import dataclass
-import spaces
-from datetime import datetime
-
-# Check for optional FlashAttention2 availability
-try:
-    import flash_attn
-    FLASH_ATTN_AVAILABLE = True
-except ImportError:
-    FLASH_ATTN_AVAILABLE = False
-
-@dataclass
-class ModelConfig:
-    model_name: str
-    max_memory_gb: float
-    inference_speed: str  # "fast", "balanced", "quality"
-    use_quantization: bool = True
-    use_flash_attention: bool = True
-
-class QwenProcessor:
-    def __init__(self, config: ModelConfig):
-        self.config = config
-        self.logger = logging.getLogger(__name__)
-        
-        # Model configurations for different performance tiers
-        self.model_configs = {
-            "fast": {
-                "model_name": "Qwen/Qwen2.5-1.5B-Instruct",
-                "torch_dtype": torch.bfloat16,
-                "device_map": "auto",
-                "attn_implementation": "flash_attention_2" if FLASH_ATTN_AVAILABLE else None,
-                "max_memory_gb": 4
-            },
-            "balanced": {
-                "model_name": "Qwen/Qwen2.5-3B-Instruct",
-                "torch_dtype": torch.bfloat16,
-                "device_map": "auto", 
-                "attn_implementation": "flash_attention_2" if FLASH_ATTN_AVAILABLE else None,
-                "max_memory_gb": 8
-            },
-            "quality": {
-                "model_name": "Qwen/Qwen2.5-7B-Instruct",
-                "torch_dtype": torch.bfloat16,
-                "device_map": "auto",
-                "attn_implementation": "flash_attention_2" if FLASH_ATTN_AVAILABLE else None,
-                "max_memory_gb": 16
-            }
-        }
-        
-        self.model = None
-        self.tokenizer = None
-        self.pipeline = None
-        self.conversation_cache = {}
-        
-        # Performance tracking
-        self.inference_times = []
-        self.memory_usage = []
-        
-    def _try_install_flash_attention(self) -> bool:
-        """Try to install FlashAttention2 at runtime if GPU is available"""
-        global FLASH_ATTN_AVAILABLE
-        
-        # If already available, no need to install
-        if FLASH_ATTN_AVAILABLE:
-            return True
-            
-        # Only attempt installation if GPU is available
-        if not torch.cuda.is_available():
-            self.logger.info("GPU not available, skipping FlashAttention2 installation")
-            return False
-            
-        try:
-            self.logger.info("Attempting to install FlashAttention2 at runtime...")
-            
-            # Try simple pip install first
-            import subprocess
-            import sys
-            
-            # Try installing with different approaches
-            commands = [
-                # Try with pre-compiled wheel
-                [sys.executable, "-m", "pip", "install", "flash-attn", "--prefer-binary", "--no-build-isolation"],
-                # Fallback to regular installation
-                [sys.executable, "-m", "pip", "install", "flash-attn", "--no-deps"],
-            ]
-            
-            for cmd in commands:
-                try:
-                    result = subprocess.run(cmd, capture_output=True, text=True, timeout=180)
-                    if result.returncode == 0:
-                        # Try importing to verify installation
-                        try:
-                            import flash_attn
-                            FLASH_ATTN_AVAILABLE = True
-                            self.logger.info("FlashAttention2 installed successfully!")
-                            return True
-                        except ImportError:
-                            continue
-                    else:
-                        self.logger.debug(f"Installation attempt failed: {result.stderr}")
-                        continue
-                except subprocess.TimeoutExpired:
-                    self.logger.warning("FlashAttention2 installation timed out")
-                    continue
-                except Exception as e:
-                    self.logger.debug(f"Installation attempt error: {e}")
-                    continue
-                    
-            self.logger.info("FlashAttention2 installation failed, will use default attention mechanism")
-            
-        except Exception as e:
-            self.logger.warning(f"Could not attempt FlashAttention2 installation: {e}")
-            
-        return False
-
-    async def initialize(self):
-        """Initialize the Qwen 2.5 model with optimizations"""
-        try:
-            model_config = self.model_configs[self.config.inference_speed]
-            
-            # Enhanced device detection for local vs Spaces environments
-            is_cpu_only = not torch.cuda.is_available()
-            is_spaces_gpu = False
-            
-            # Check if we're in Spaces with GPU
-            if torch.cuda.is_available():
-                try:
-                    # Test if we can actually use GPU
-                    torch.cuda.current_device()
-                    torch.cuda.empty_cache()
-                    is_spaces_gpu = True
-                    is_cpu_only = False
-                    self.logger.info("GPU detected and accessible - using GPU acceleration")
-                    
-                    # Try to install FlashAttention2 at runtime if not available
-                    if not FLASH_ATTN_AVAILABLE:
-                        self._try_install_flash_attention()
-                        
-                except Exception as e:
-                    self.logger.warning(f"GPU detected but not accessible: {e} - falling back to CPU")
-                    is_cpu_only = True
-                    is_spaces_gpu = False
-            else:
-                self.logger.info("No GPU detected - using CPU only")
-            
-            # Quantization configuration - optimize based on environment
-            if self.config.use_quantization and not is_cpu_only:
-                try:
-                    quantization_config = BitsAndBytesConfig(
-                        load_in_4bit=True,
-                        bnb_4bit_compute_dtype=torch.bfloat16,
-                        bnb_4bit_use_double_quant=True,
-                        bnb_4bit_quant_type="nf4"
-                    )
-                    self.logger.info("4-bit quantization enabled for GPU")
-                except Exception as e:
-                    self.logger.warning(f"Quantization failed, falling back to full precision: {e}")
-                    quantization_config = None
-            else:
-                quantization_config = None
-                if is_cpu_only:
-                    self.logger.info("CPU-only environment detected, disabling quantization")
-            
-            # Load tokenizer
-            self.tokenizer = AutoTokenizer.from_pretrained(
-                model_config["model_name"],
-                trust_remote_code=True,
-                use_fast=True
-            )
-            
-            # Adjust model configuration based on environment
-            model_kwargs = {
-                "trust_remote_code": True,
-                "use_cache": True,
-                "low_cpu_mem_usage": True
-            }
-            
-            if is_cpu_only:
-                # CPU-only optimizations
-                model_kwargs.update({
-                    "torch_dtype": torch.float32,  # Use float32 for CPU compatibility
-                    "device_map": "cpu"
-                })
-                self.logger.info("Loading model for CPU-only environment")
-            else:
-                # GPU optimizations - use FlashAttention2 when available
-                use_flash_attention = (self.config.use_flash_attention and 
-                                     is_spaces_gpu and 
-                                     FLASH_ATTN_AVAILABLE)
-                
-                if use_flash_attention:
-                    attn_implementation = model_config["attn_implementation"]
-                    self.logger.info("Loading model for GPU environment with FlashAttention2")
-                else:
-                    attn_implementation = None  # Use default attention
-                    if self.config.use_flash_attention and not FLASH_ATTN_AVAILABLE:
-                        self.logger.info("FlashAttention2 requested but not available, using default attention")
-                    else:
-                        self.logger.info("Loading model for GPU environment with default attention")
-                
-                model_kwargs.update({
-                    "torch_dtype": model_config["torch_dtype"],
-                    "device_map": model_config["device_map"],
-                    "attn_implementation": attn_implementation
-                })
-            
-            if quantization_config is not None:
-                model_kwargs["quantization_config"] = quantization_config
-            
-            # Load model with optimizations
-            import os
-            if os.getenv("SPACE_ID") and not is_cpu_only:
-                # Use GPU wrapper for ZeroGPU compatibility
-                self.model = gpu_model_initialization(
-                    AutoModelForCausalLM,
-                    model_config["model_name"],
-                    **model_kwargs
-                )
-            else:
-                # Direct model loading for local environments
-                self.model = AutoModelForCausalLM.from_pretrained(
-                    model_config["model_name"],
-                    **model_kwargs
-                )
-            
-            # Compile model for faster inference (PyTorch 2.0+) - only on GPU
-            if hasattr(torch, "compile") and not is_cpu_only:
-                try:
-                    self.model = torch.compile(self.model, mode="reduce-overhead")
-                    self.logger.info("Model compiled with torch.compile for faster inference")
-                except Exception as e:
-                    self.logger.warning(f"Model compilation failed: {e}")
-            
-            # Create pipeline with appropriate device mapping
-            pipeline_kwargs = {
-                "task": "text-generation",
-                "model": self.model,
-                "tokenizer": self.tokenizer,
-                "batch_size": 1,
-                "return_full_text": False
-            }
-            
-            if is_cpu_only:
-                pipeline_kwargs["device"] = -1  # CPU device for pipeline
-            # Do not pass device_map when model is already loaded with accelerate
-            
-            self.pipeline = pipeline(**pipeline_kwargs)
-            
-            self.logger.info(f"Qwen 2.5 model initialized: {model_config['model_name']} ({'GPU' if not is_cpu_only else 'CPU'})")
-            
-        except Exception as e:
-            self.logger.error(f"Failed to initialize Qwen model: {e}")
-            raise
-    
-    async def generate_monster_response(self, 
-                                      monster_data: Dict[str, Any],
-                                      user_input: str,
-                                      conversation_history: List[Dict[str, str]] = None) -> Dict[str, Any]:
-        """Generate contextual response based on monster personality and state"""
-        start_time = time.time()
-        
-        if conversation_history is None:
-            conversation_history = []
-        
-        try:
-            # Build context from monster data
-            context = self._build_context(monster_data, conversation_history)
-            
-            # Generate appropriate prompt based on monster state
-            prompt = self._generate_prompt(context, user_input)
-            
-            # Configure generation parameters based on monster personality
-            generation_params = self._get_generation_params(monster_data)
-            
-            # Generate response using the pipeline
-            response = await self._generate_response(prompt, generation_params)
-            
-            # Post-process response based on monster personality
-            processed_response = self._post_process_response(
-                response, 
-                monster_data
-            )
-            
-            # Calculate emotional impact
-            emotional_impact = self._calculate_emotional_impact(
-                user_input,
-                processed_response,
-                monster_data
-            )
-            
-            # Track memory usage
-            if torch.cuda.is_available():
-                memory_used = torch.cuda.max_memory_allocated() / 1024**3
-                self.memory_usage.append({
-                    "timestamp": datetime.now().isoformat(),
-                    "memory_gb": memory_used
-                })
-            
-            inference_time = time.time() - start_time
-            
-            return {
-                "response": processed_response,
-                "emotional_impact": emotional_impact,
-                "inference_time": inference_time,
-                "model_used": self.config.model_name,
-                "context_length": len(prompt)
-            }
-            
-        except Exception as e:
-            self.logger.error(f"Response generation failed: {e}")
-            # Return a fallback response
-            return {
-                "response": self._get_fallback_response(monster_data),
-                "emotional_impact": {"neutral": 1.0},
-                "inference_time": 0.0,
-                "error": str(e)
-            }
-    
-    def _build_personality_prompt(self, monster_data: Dict[str, Any]) -> str:
-        """Build personality description for the monster"""
-        personality = monster_data.get('personality', {})
-        
-        # Core personality traits
-        primary_type = personality.get('primary_type', 'playful')
-        traits = []
-        
-        # Big Five personality factors
-        if personality.get('extraversion', 0.5) > 0.7:
-            traits.append("very outgoing and social")
-        elif personality.get('extraversion', 0.5) < 0.3:
-            traits.append("more reserved and introspective")
-        
-        if personality.get('agreeableness', 0.5) > 0.7:
-            traits.append("extremely friendly and cooperative")
-        elif personality.get('agreeableness', 0.5) < 0.3:
-            traits.append("more independent and sometimes stubborn")
-        
-        if personality.get('conscientiousness', 0.5) > 0.7:
-            traits.append("very disciplined and organized")
-        elif personality.get('conscientiousness', 0.5) < 0.3:
-            traits.append("more spontaneous and carefree")
-        
-        if personality.get('openness', 0.5) > 0.7:
-            traits.append("very curious and imaginative")
-        elif personality.get('openness', 0.5) < 0.3:
-            traits.append("more practical and traditional")
-        
-        # Learned preferences
-        favorites = personality.get('favorite_foods', [])
-        dislikes = personality.get('disliked_foods', [])
-        
-        personality_text = f"Personality Type: {primary_type.title()}\n"
-        
-        if traits:
-            personality_text += f"You are {', '.join(traits)}.\n"
-        
-        if favorites:
-            personality_text += f"Your favorite foods are: {', '.join(favorites[:3])}.\n"
-        
-        if dislikes:
-            personality_text += f"You dislike: {', '.join(dislikes[:3])}.\n"
-        
-        # Relationship context
-        relationship_level = personality.get('relationship_level', 0)
-        if relationship_level > 80:
-            personality_text += "You have a very strong bond with your caretaker.\n"
-        elif relationship_level > 50:
-            personality_text += "You trust and like your caretaker.\n"
-        elif relationship_level > 20:
-            personality_text += "You're getting to know your caretaker.\n"
-        else:
-            personality_text += "You're still warming up to your caretaker.\n"
-        
-        return personality_text
-    
-    def _build_conversation_context(self, 
-                                  history: List[Dict[str, str]], 
-                                  monster_data: Dict[str, Any]) -> str:
-        """Build conversation context from recent history"""
-        if not history:
-            return "This is your first conversation together."
-        
-        # Get recent messages (last 3 exchanges)
-        recent_history = history[-6:] if len(history) > 6 else history
-        
-        context = "Recent conversation:\n"
-        for i, msg in enumerate(recent_history):
-            if msg.get('role') == 'user':
-                context += f"Human: {msg.get('content', '')}\n"
-            else:
-                context += f"You: {msg.get('content', '')}\n"
-        
-        return context
-    
-    def _post_process_response(self, response: str, monster_data: Dict[str, Any]) -> str:
-        """Post-process the generated response"""
-        # Remove any unwanted prefixes/suffixes
-        response = response.strip()
-        
-        # Remove common artifacts
-        unwanted_prefixes = ["Assistant:", "Monster:", "DigiPal:", monster_data['name'] + ":"]
-        for prefix in unwanted_prefixes:
-            if response.startswith(prefix):
-                response = response[len(prefix):].strip()
-        
-        # Ensure appropriate length
-        sentences = response.split('.')
-        if len(sentences) > 2:
-            response = '. '.join(sentences[:2]) + '.'
-        
-        # Add emojis if missing
-        if not self._has_emoji(response):
-            response = self._add_contextual_emoji(response, monster_data)
-        
-        return response
-    
-    def _has_emoji(self, text: str) -> bool:
-        """Check if text contains emojis"""
-        import emoji
-        return bool(emoji.emoji_count(text))
-    
-    def _add_contextual_emoji(self, response: str, monster_data: Dict[str, Any]) -> str:
-        """Add appropriate emoji based on context"""
-        emotional_state = monster_data.get('emotional_state', 'neutral')
-        
-        emoji_map = {
-            'ecstatic': ' 🤩',
-            'happy': ' 😊',
-            'content': ' 😌',
-            'neutral': ' 🙂',
-            'melancholy': ' 😔',
-            'sad': ' 😢',
-            'angry': ' 😠',
-            'sick': ' 🤒',
-            'excited': ' 😆',
-            'tired': ' 😴'
-        }
-        
-        return response + emoji_map.get(emotional_state, ' 🙂')
-    
-    def _analyze_emotional_impact(self, user_input: str, response: str) -> Dict[str, float]:
-        """Analyze the emotional impact of the interaction"""
-        # Simple keyword-based analysis (can be enhanced with sentiment models)
-        positive_keywords = ['love', 'good', 'great', 'amazing', 'wonderful', 'happy', 'fun']
-        negative_keywords = ['bad', 'sad', 'angry', 'hate', 'terrible', 'awful', 'sick']
-        
-        user_input_lower = user_input.lower()
-        
-        impact = {
-            'happiness': 0.0,
-            'stress': 0.0,
-            'bonding': 0.0
-        }
-        
-        # Analyze user input sentiment
-        for keyword in positive_keywords:
-            if keyword in user_input_lower:
-                impact['happiness'] += 0.1
-                impact['bonding'] += 0.05
-        
-        for keyword in negative_keywords:
-            if keyword in user_input_lower:
-                impact['happiness'] -= 0.1
-                impact['stress'] += 0.1
-        
-        # Base interaction bonus
-        impact['bonding'] += 0.02  # Small bonding increase for any interaction
-        
-        return impact
-    
-    def _get_fallback_response(self, monster_data: Dict[str, Any]) -> str:
-        """Get fallback response when AI generation fails"""
-        fallback_responses = [
-            f"*{monster_data['name']} looks at you curiously* 🤔",
-            f"*{monster_data['name']} makes a happy sound* 😊",
-            f"*{monster_data['name']} tilts head thoughtfully* 💭",
-            f"*{monster_data['name']} seems interested* 👀"
-        ]
-        
-        import random
-        return random.choice(fallback_responses)
-    
-    def get_performance_stats(self) -> Dict[str, Any]:
-        """Get model performance statistics"""
-        if not self.inference_times:
-            return {"status": "No inference data available"}
-        
-        avg_time = sum(self.inference_times) / len(self.inference_times)
-        
-        return {
-            "average_inference_time": avg_time,
-            "total_inferences": len(self.inference_times),
-            "fastest_inference": min(self.inference_times),
-            "slowest_inference": max(self.inference_times),
-            "tokens_per_second": 128 / avg_time,  # Approximate
-            "model_config": self.config.__dict__
-        }
-
-    def _build_context(self, monster_data: Dict[str, Any], conversation_history: List[Dict[str, str]]) -> str:
-        """Build complete context from monster data and conversation history"""
-        personality_prompt = self._build_personality_prompt(monster_data)
-        conversation_context = self._build_conversation_context(conversation_history, monster_data)
-        
-        context = f"""You are {monster_data['name']}, a virtual monster companion.
-
-{personality_prompt}
-
-Current State:
-- Health: {monster_data['stats']['health']}/100
-- Happiness: {monster_data['stats']['happiness']}/100
-- Energy: {monster_data['stats']['energy']}/100
-- Emotional State: {monster_data['emotional_state']}
-- Activity: {monster_data['current_activity']}
-
-Instructions:
-- Respond as this specific monster with this personality
-- Keep responses to 1-2 sentences maximum
-- Include 1-2 relevant emojis
-- Show personality through word choice and tone
-- React appropriately to your current stats and emotional state
-- Remember past conversations and build on them
-
-{conversation_context}"""
-        
-        return context
-    
-    def _generate_prompt(self, context: str, user_input: str) -> str:
-        """Generate the final prompt for the model"""
-        messages = [
-            {"role": "system", "content": context},
-            {"role": "user", "content": user_input}
-        ]
-        
-        # Format messages for Qwen 2.5
-        prompt = self.tokenizer.apply_chat_template(
-            messages,
-            tokenize=False,
-            add_generation_prompt=True
-        )
-        
-        return prompt
-    
-    def _get_generation_params(self, monster_data: Dict[str, Any]) -> Dict[str, Any]:
-        """Get generation parameters based on monster personality"""
-        personality_type = monster_data.get("personality", {}).get("type", "playful")
-        
-        # Base parameters
-        params = {
-            "max_new_tokens": 128,
-            "temperature": 0.8,
-            "top_p": 0.9,
-            "top_k": 50,
-            "do_sample": True,
-            "pad_token_id": self.tokenizer.eos_token_id,
-            "repetition_penalty": 1.1,
-            "no_repeat_ngram_size": 3
-        }
-        
-        # Adjust based on personality
-        if personality_type == "energetic":
-            params["temperature"] = 0.9
-            params["top_p"] = 0.95
-        elif personality_type == "wise":
-            params["temperature"] = 0.7
-            params["top_p"] = 0.85
-        elif personality_type == "mysterious":
-            params["temperature"] = 0.85
-            params["top_k"] = 40
-        
-        return params
-    
-    async def _generate_response(self, prompt: str, generation_params: Dict[str, Any]) -> str:
-        """Generate response using the pipeline"""
-        try:
-            # Check if we're in Spaces environment and GPU is available
-            import os
-            if os.getenv("SPACE_ID") and torch.cuda.is_available():
-                # Use GPU wrapper function for ZeroGPU compatibility
-                response_text = gpu_generate_response(self, prompt, generation_params)
-            else:
-                # Direct pipeline call for local/CPU environments
-                outputs = self.pipeline(prompt, **generation_params)
-                response_text = outputs[0]["generated_text"].strip()
-            return response_text
-        except Exception as e:
-            self.logger.error(f"Pipeline generation failed: {e}")
-            raise
-    
-    def _calculate_emotional_impact(self, user_input: str, response: str, monster_data: Dict[str, Any]) -> Dict[str, float]:
-        """Calculate the emotional impact of the interaction"""
-        return self._analyze_emotional_impact(user_input, response)
-
-# ZeroGPU wrapper functions
-@spaces.GPU(duration=120)
-def gpu_generate_response(processor, prompt: str, generation_params: Dict[str, Any]) -> str:
-    """GPU-accelerated response generation wrapper"""
-    try:
-        outputs = processor.pipeline(prompt, **generation_params)
-        response_text = outputs[0]["generated_text"].strip()
-        return response_text
-    except Exception as e:
-        logging.getLogger(__name__).error(f"GPU generation failed: {e}")
-        raise
-
-@spaces.GPU(duration=60)
-def gpu_model_initialization(model_class, model_name: str, **kwargs) -> Any:
-    """GPU-accelerated model initialization wrapper"""
-    return model_class.from_pretrained(model_name, **kwargs)

src/ai/speech_engine.py

@@ -1,470 +0,0 @@
-import asyncio
-import numpy as np
-import torch
-import torchaudio
-from transformers import pipeline, AutoModelForSpeechSeq2Seq, AutoProcessor
-import webrtcvad
-import logging
-from typing import Dict, List, Optional, Tuple, Any
-import time
-from dataclasses import dataclass
-import io
-import wave
-import spaces
-
-@dataclass
-class SpeechConfig:
-    model_name: str = "kyutai/stt-2.6b-en"  # Kyutai STT model
-    device: str = "auto"
-    torch_dtype: str = "float16"
-    use_vad: bool = True
-    vad_aggressiveness: int = 2  # 0-3, higher = more aggressive
-    chunk_duration_ms: int = 30  # VAD chunk size
-    sample_rate: int = 16000
-    use_pipeline: bool = True  # Use transformers pipeline for easier integration
-
-class AdvancedSpeechEngine:
-    def __init__(self, config: SpeechConfig):
-        self.config = config
-        self.logger = logging.getLogger(__name__)
-        
-        # Kyutai STT model configurations
-        self.model_info = {
-            "name": "Kyutai STT-2.6B-EN",
-            "description": "Multilingual speech-to-text model optimized for English",
-            "memory_gb": 6,  # Approximate memory requirement for 2.6B model
-            "speed": "fast",
-            "accuracy": "high"
-        }
-        
-        self.speech_pipeline = None
-        self.model = None
-        self.processor = None
-        self.vad_model = None
-        
-        # Performance tracking
-        self.transcription_times = []
-        self.accuracy_scores = []
-        
-        # Audio processing
-        self.audio_buffer = []
-        self.is_processing = False
-        
-    async def initialize(self):
-        """Initialize the Kyutai STT speech recognition system"""
-        try:
-            # Enhanced device detection for local vs Spaces environments
-            device = self.config.device
-            torch_dtype = self.config.torch_dtype
-            
-            if device == "auto":
-                # For Zero GPU environments, try GPU first, fallback to CPU
-                if torch.cuda.is_available():
-                    try:
-                        # Test CUDA availability properly
-                        torch.cuda.current_device()
-                        torch.cuda.empty_cache()
-                        device = "cuda"
-                        self.logger.info("GPU detected and accessible for speech processing")
-                    except Exception as cuda_error:
-                        # CUDA not properly accessible, use CPU
-                        device = "cpu"
-                        if torch_dtype == "float16":
-                            torch_dtype = "float32"
-                        self.logger.info(f"CUDA not accessible ({cuda_error}), using CPU with float32")
-                else:
-                    device = "cpu"
-                    if torch_dtype == "float16":
-                        torch_dtype = "float32"
-                    self.logger.info("CUDA not available, using CPU with float32")
-            
-            # Adjust torch_dtype for CPU
-            if device == "cpu" and torch_dtype == "float16":
-                torch_dtype = "float32"  # Use float32 for CPU instead of float16
-                self.logger.info("CPU detected, switching from float16 to float32 dtype")
-            
-            # Convert string dtype to torch dtype
-            dtype_map = {
-                "float16": torch.float16,
-                "float32": torch.float32,
-                "bfloat16": torch.bfloat16
-            }
-            torch_dtype_obj = dtype_map.get(torch_dtype, torch.float32)
-            
-            # Initialize Kyutai STT with proper error handling
-            try:
-                if self.config.use_pipeline:
-                    # Use transformers pipeline for easier integration
-                    self.speech_pipeline = pipeline(
-                        "automatic-speech-recognition",
-                        model=self.config.model_name,
-                        torch_dtype=torch_dtype_obj,
-                        device=device,
-                        cache_dir="data/models/"
-                    )
-                    self.logger.info(f"Kyutai STT pipeline loaded on {device} with {torch_dtype}")
-                else:
-                    # Load model and processor separately for more control
-                    self.model = AutoModelForSpeechSeq2Seq.from_pretrained(
-                        self.config.model_name,
-                        torch_dtype=torch_dtype_obj,
-                        device_map="auto" if device == "cuda" else None,
-                        cache_dir="data/models/"
-                    )
-                    self.processor = AutoProcessor.from_pretrained(
-                        self.config.model_name,
-                        cache_dir="data/models/"
-                    )
-                    
-                    if device == "cuda" and not hasattr(self.model, 'device_map'):
-                        self.model = self.model.to(device)
-                    
-                    self.logger.info(f"Kyutai STT model and processor loaded on {device} with {torch_dtype}")
-                    
-            except Exception as model_error:
-                # Final fallback to CPU with basic settings
-                self.logger.warning(f"Failed to load on {device}, falling back to CPU: {model_error}")
-                
-                if self.config.use_pipeline:
-                    self.speech_pipeline = pipeline(
-                        "automatic-speech-recognition",
-                        model=self.config.model_name,
-                        torch_dtype=torch.float32,
-                        device="cpu",
-                        cache_dir="data/models/"
-                    )
-                else:
-                    self.model = AutoModelForSpeechSeq2Seq.from_pretrained(
-                        self.config.model_name,
-                        torch_dtype=torch.float32,
-                        device_map=None,
-                        cache_dir="data/models/"
-                    )
-                    self.processor = AutoProcessor.from_pretrained(
-                        self.config.model_name,
-                        cache_dir="data/models/"
-                    )
-                    self.model = self.model.to("cpu")
-                
-                self.logger.info("Kyutai STT model loaded on CPU (fallback)")
-            
-            # Initialize VAD if enabled
-            if self.config.use_vad:
-                self.vad_model = webrtcvad.Vad(self.config.vad_aggressiveness)
-            
-            self.logger.info(f"Kyutai STT speech engine initialized: {self.config.model_name} on {device}")
-            
-        except Exception as e:
-            self.logger.error(f"Failed to initialize Kyutai STT speech engine: {e}")
-            raise
-    
-    async def process_audio_stream(self, audio_data: np.ndarray) -> Dict[str, Any]:
-        """Process streaming audio for real-time transcription"""
-        start_time = time.time()
-        
-        try:
-            # Convert audio format if needed
-            if len(audio_data.shape) > 1:
-                audio_data = audio_data.mean(axis=1)  # Convert to mono
-            
-            # Normalize audio
-            audio_data = audio_data.astype(np.float32)
-            if np.max(np.abs(audio_data)) > 0:
-                audio_data = audio_data / np.max(np.abs(audio_data))
-            
-            # Voice Activity Detection
-            if self.config.use_vad:
-                has_speech = self._detect_speech_activity(audio_data)
-                if not has_speech:
-                    return {
-                        "success": True,
-                        "transcription": "",
-                        "confidence": 0.0,
-                        "processing_time": time.time() - start_time,
-                        "has_speech": False
-                    }
-            
-            # Transcribe with Kyutai STT
-            if self.config.use_pipeline and self.speech_pipeline:
-                # Use pipeline for simpler transcription
-                result = self.speech_pipeline(
-                    audio_data,
-                    generate_kwargs={
-                        "language": "en",
-                        "task": "transcribe",
-                        "max_new_tokens": 256
-                    }
-                )
-                
-                transcription = result["text"].strip()
-                # Pipeline doesn't provide confidence scores directly
-                confidence = 0.8  # Default confidence for pipeline
-                
-            else:
-                # Use model and processor for more control
-                # Prepare inputs
-                inputs = self.processor(
-                    audio_data,
-                    sampling_rate=self.config.sample_rate,
-                    return_tensors="pt"
-                )
-                
-                # Move inputs to device
-                device = next(self.model.parameters()).device
-                inputs = {k: v.to(device) for k, v in inputs.items()}
-                
-                # Generate transcription
-                with torch.no_grad():
-                    generated_tokens = self.model.generate(
-                        **inputs,
-                        language="en",
-                        task="transcribe",
-                        max_new_tokens=256,
-                        num_beams=1,  # Faster inference
-                        do_sample=False,
-                        temperature=1.0
-                    )
-                
-                # Decode transcription
-                transcription = self.processor.batch_decode(
-                    generated_tokens, 
-                    skip_special_tokens=True
-                )[0].strip()
-                
-                # Calculate confidence (simplified)
-                confidence = 0.8  # Default confidence
-            
-            processing_time = time.time() - start_time
-            self.transcription_times.append(processing_time)
-            
-            # Analyze speech characteristics
-            speech_analysis = self._analyze_speech_characteristics(audio_data, transcription)
-            
-            return {
-                "success": True,
-                "transcription": transcription,
-                "confidence": confidence,
-                "processing_time": processing_time,
-                "has_speech": True,
-                "speech_analysis": speech_analysis,
-                "detected_language": "en",  # Kyutai model is optimized for English
-                "language_probability": 1.0,
-                "model": "kyutai-stt-2.6b-en"
-            }
-            
-        except Exception as e:
-            self.logger.error(f"Audio processing failed: {e}")
-            return {
-                "success": False,
-                "transcription": "",
-                "confidence": 0.0,
-                "processing_time": time.time() - start_time,
-                "error": str(e)
-            }
-    
-    def _detect_speech_activity(self, audio_data: np.ndarray) -> bool:
-        """Detect if audio contains speech using WebRTC VAD"""
-        try:
-            # Convert to 16-bit PCM
-            pcm_data = (audio_data * 32767).astype(np.int16)
-            
-            # Split into chunks for VAD processing
-            chunk_size = int(self.config.sample_rate * self.config.chunk_duration_ms / 1000)
-            speech_chunks = 0
-            total_chunks = 0
-            
-            for i in range(0, len(pcm_data), chunk_size):
-                chunk = pcm_data[i:i+chunk_size]
-                
-                # Pad chunk if necessary
-                if len(chunk) < chunk_size:
-                    chunk = np.pad(chunk, (0, chunk_size - len(chunk)), mode='constant')
-                
-                # Convert to bytes
-                chunk_bytes = chunk.tobytes()
-                
-                # Check for speech
-                if self.vad_model.is_speech(chunk_bytes, self.config.sample_rate):
-                    speech_chunks += 1
-                
-                total_chunks += 1
-            
-            # Consider it speech if > 30% of chunks contain speech
-            speech_ratio = speech_chunks / total_chunks if total_chunks > 0 else 0
-            return speech_ratio > 0.3
-            
-        except Exception as e:
-            self.logger.warning(f"VAD processing failed: {e}")
-            return True  # Default to processing if VAD fails
-    
-    def _logprob_to_confidence(self, avg_logprob: float) -> float:
-        """Convert log probability to confidence score"""
-        # Empirical mapping from log probability to confidence
-        # Faster Whisper typically gives log probs between -3.0 and 0.0
-        confidence = max(0.0, min(1.0, (avg_logprob + 3.0) / 3.0))
-        return confidence
-    
-    def _analyze_speech_characteristics(self, audio_data: np.ndarray, transcription: str) -> Dict[str, Any]:
-        """Analyze speech characteristics for emotional context"""
-        try:
-            import librosa
-            
-            # Basic audio features
-            duration = len(audio_data) / self.config.sample_rate
-            
-            # Energy/Volume analysis
-            rms_energy = np.sqrt(np.mean(audio_data ** 2))
-            
-            # Pitch analysis
-            pitches, magnitudes = librosa.piptrack(
-                y=audio_data, 
-                sr=self.config.sample_rate,
-                threshold=0.1
-            )
-            
-            # Extract fundamental frequency
-            pitch_values = pitches[magnitudes > np.max(magnitudes) * 0.1]
-            if len(pitch_values) > 0:
-                avg_pitch = np.mean(pitch_values)
-                pitch_variance = np.var(pitch_values)
-            else:
-                avg_pitch = 0.0
-                pitch_variance = 0.0
-            
-            # Speaking rate (words per minute)
-            word_count = len(transcription.split()) if transcription else 0
-            speaking_rate = (word_count / duration * 60) if duration > 0 else 0
-            
-            # Emotional indicators (basic)
-            emotions = {
-                "excitement": min(1.0, rms_energy * 10),  # Higher energy = more excited
-                "calmness": max(0.0, 1.0 - (pitch_variance / 1000)),  # Lower pitch variance = calmer
-                "engagement": min(1.0, speaking_rate / 200),  # Normal speaking rate indicates engagement
-                "stress": min(1.0, max(0.0, (avg_pitch - 200) / 100))  # Higher pitch can indicate stress
-            }
-            
-            return {
-                "duration": duration,
-                "energy": rms_energy,
-                "average_pitch": avg_pitch,
-                "pitch_variance": pitch_variance,
-                "speaking_rate": speaking_rate,
-                "word_count": word_count,
-                "emotional_indicators": emotions
-            }
-            
-        except Exception as e:
-            self.logger.warning(f"Speech analysis failed: {e}")
-            return {
-                "duration": 0.0,
-                "energy": 0.0,
-                "emotional_indicators": {}
-            }
-    
-    async def batch_transcribe(self, audio_files: List[str]) -> List[Dict[str, Any]]:
-        """Batch transcribe multiple audio files using Kyutai STT"""
-        results = []
-        
-        for audio_file in audio_files:
-            try:
-                # Load audio file - use torchaudio for better PyTorch integration
-                audio_data, sample_rate = torchaudio.load(audio_file)
-                
-                # Convert to numpy and ensure mono
-                audio_data = audio_data.numpy()
-                if len(audio_data.shape) > 1:
-                    audio_data = audio_data.mean(axis=0)  # Convert to mono
-                
-                # Resample if necessary
-                if sample_rate != self.config.sample_rate:
-                    # Use torchaudio for resampling
-                    audio_tensor = torch.from_numpy(audio_data).unsqueeze(0)
-                    resampler = torchaudio.transforms.Resample(sample_rate, self.config.sample_rate)
-                    audio_tensor = resampler(audio_tensor)
-                    audio_data = audio_tensor.squeeze(0).numpy()
-                
-                # Process
-                result = await self.process_audio_stream(audio_data)
-                result["file_path"] = audio_file
-                result["original_sample_rate"] = sample_rate
-                
-                results.append(result)
-                
-            except Exception as e:
-                self.logger.error(f"Failed to process {audio_file}: {e}")
-                results.append({
-                    "success": False,
-                    "file_path": audio_file,
-                    "error": str(e)
-                })
-        
-        return results
-    
-    def get_performance_stats(self) -> Dict[str, Any]:
-        """Get speech processing performance statistics"""
-        if not self.transcription_times:
-            return {"status": "No transcription data available"}
-        
-        avg_time = sum(self.transcription_times) / len(self.transcription_times)
-        
-        return {
-            "average_processing_time": avg_time,
-            "total_transcriptions": len(self.transcription_times),
-            "fastest_transcription": min(self.transcription_times),
-            "slowest_transcription": max(self.transcription_times),
-            "model_config": self.config.__dict__,
-            "estimated_real_time_factor": avg_time / 1.0  # Assuming 1 second audio clips
-        }
-    
-    def optimize_for_hardware(self, available_vram_gb: float) -> SpeechConfig:
-        """Optimize Kyutai STT config based on available hardware"""
-        # Kyutai STT-2.6B requires about 6GB VRAM for optimal performance
-        if available_vram_gb >= 8:
-            return SpeechConfig(
-                model_name="kyutai/stt-2.6b-en",
-                device="cuda",
-                torch_dtype="float16",
-                use_vad=True,
-                use_pipeline=True
-            )
-        elif available_vram_gb >= 6:
-            return SpeechConfig(
-                model_name="kyutai/stt-2.6b-en",
-                device="cuda",
-                torch_dtype="float32",
-                use_vad=True,
-                use_pipeline=True
-            )
-        elif available_vram_gb >= 4:
-            return SpeechConfig(
-                model_name="kyutai/stt-2.6b-en",
-                device="cuda",
-                torch_dtype="float32",
-                use_vad=True,
-                use_pipeline=False  # More memory efficient without pipeline
-            )
-        else:
-            return SpeechConfig(
-                model_name="kyutai/stt-2.6b-en",
-                device="cpu",
-                torch_dtype="float32",
-                use_vad=True,
-                use_pipeline=True
-            )
-
-# Apply GPU decorator to methods after class definition for ZeroGPU compatibility
-try:
-    import os
-    if os.getenv("SPACE_ID") is not None:
-        # We're in Spaces environment, apply GPU decorator for Kyutai STT
-        AdvancedSpeechEngine.process_audio_stream = spaces.GPU(
-            AdvancedSpeechEngine.process_audio_stream, 
-            duration=120  # Kyutai STT may take longer than Whisper
-        )
-        AdvancedSpeechEngine.batch_transcribe = spaces.GPU(
-            AdvancedSpeechEngine.batch_transcribe,
-            duration=300  # Batch processing may take longer
-        )
-except (ImportError, NotImplementedError, AttributeError) as e:
-    # GPU decorator not available or failed, continue without it
-    pass

src/core/evolution_system.py

@@ -1,655 +0,0 @@
-import asyncio
-import logging
-from typing import Dict, List, Optional, Any, Tuple
-from datetime import datetime, timedelta
-from enum import Enum
-import random
-import json
-
-from .monster_engine import Monster, EvolutionStage, MonsterPersonalityType, EmotionalState
-
-class EvolutionTrigger(str, Enum):
-    TIME_BASED = "time_based"
-    STAT_BASED = "stat_based"
-    CARE_BASED = "care_based"
-    ITEM_BASED = "item_based"
-    SPECIAL_EVENT = "special_event"
-    TRAINING_BASED = "training_based"
-    RELATIONSHIP_BASED = "relationship_based"
-
-class EvolutionPath(str, Enum):
-    NORMAL = "normal"
-    VARIANT = "variant"
-    SPECIAL = "special"
-    CORRUPTED = "corrupted"
-    LEGENDARY = "legendary"
-
-class EvolutionSystem:
-    def __init__(self):
-        self.logger = logging.getLogger(__name__)
-        
-        # Evolution trees and requirements
-        self.evolution_trees = self._initialize_evolution_trees()
-        self.evolution_requirements = self._initialize_evolution_requirements()
-        self.special_conditions = self._initialize_special_conditions()
-        
-        # Evolution modifiers
-        self.care_quality_thresholds = {
-            "excellent": 1.8,
-            "good": 1.4,
-            "average": 1.0,
-            "poor": 0.6,
-            "terrible": 0.3
-        }
-        
-    def _initialize_evolution_trees(self) -> Dict[str, Dict[str, List[Dict[str, Any]]]]:
-        """Initialize the complete evolution tree structure"""
-        return {
-            "Botamon": {
-                EvolutionStage.BABY: [
-                    {
-                        "species": "Koromon",
-                        "path": EvolutionPath.NORMAL,
-                        "requirements": {
-                            "age_minutes": 60,
-                            "care_mistakes_max": 0,
-                            "health_min": 80
-                        }
-                    }
-                ]
-            },
-            "Koromon": {
-                EvolutionStage.CHILD: [
-                    {
-                        "species": "Agumon",
-                        "path": EvolutionPath.NORMAL,
-                        "requirements": {
-                            "age_minutes": 1440,  # 24 hours
-                            "stats_min": {"offense": 150, "life": 1200},
-                            "training_min": {"strength": 30},
-                            "care_quality_min": 1.0
-                        }
-                    },
-                    {
-                        "species": "Betamon", 
-                        "path": EvolutionPath.VARIANT,
-                        "requirements": {
-                            "age_minutes": 1440,
-                            "stats_min": {"defense": 150, "brains": 120},
-                            "training_min": {"intelligence": 30},
-                            "care_quality_min": 1.2
-                        }
-                    },
-                    {
-                        "species": "Kunemon",
-                        "path": EvolutionPath.CORRUPTED,
-                        "requirements": {
-                            "age_minutes": 1440,
-                            "care_mistakes_min": 3,
-                            "happiness_max": 40
-                        }
-                    }
-                ]
-            },
-            "Agumon": {
-                EvolutionStage.ADULT: [
-                    {
-                        "species": "Greymon",
-                        "path": EvolutionPath.NORMAL,
-                        "requirements": {
-                            "age_minutes": 4320,  # 72 hours
-                            "stats_min": {"offense": 250, "life": 1800},
-                            "training_min": {"strength": 80},
-                            "care_quality_min": 1.3,
-                            "battle_wins_min": 5
-                        }
-                    },
-                    {
-                        "species": "Tyrannomon",
-                        "path": EvolutionPath.VARIANT,
-                        "requirements": {
-                            "age_minutes": 4320,
-                            "stats_min": {"offense": 300, "life": 2000},
-                            "training_min": {"strength": 100, "endurance": 50},
-                            "care_quality_min": 1.1,
-                            "discipline_min": 70
-                        }
-                    },
-                    {
-                        "species": "Meramon",
-                        "path": EvolutionPath.SPECIAL,
-                        "requirements": {
-                            "age_minutes": 4320,
-                            "stats_min": {"offense": 200, "brains": 180},
-                            "training_min": {"spirit": 60},
-                            "special_item": "Fire_Crystal",
-                            "care_quality_min": 1.5
-                        }
-                    }
-                ]
-            },
-            "Greymon": {
-                EvolutionStage.PERFECT: [
-                    {
-                        "species": "MetalGreymon",
-                        "path": EvolutionPath.NORMAL,
-                        "requirements": {
-                            "age_minutes": 8640,  # 144 hours (6 days)
-                            "stats_min": {"offense": 400, "life": 2800, "defense": 300},
-                            "training_min": {"strength": 150, "technique": 100},
-                            "care_quality_min": 1.6,
-                            "battle_wins_min": 15,
-                            "relationship_level_min": 80
-                        }
-                    },
-                    {
-                        "species": "SkullGreymon",
-                        "path": EvolutionPath.CORRUPTED,
-                        "requirements": {
-                            "age_minutes": 8640,
-                            "stats_min": {"offense": 450},
-                            "care_mistakes_min": 8,
-                            "overtraining": True,
-                            "happiness_max": 30
-                        }
-                    }
-                ]
-            },
-            "MetalGreymon": {
-                EvolutionStage.ULTIMATE: [
-                    {
-                        "species": "WarGreymon",
-                        "path": EvolutionPath.LEGENDARY,
-                        "requirements": {
-                            "age_minutes": 14400,  # 10 days
-                            "stats_min": {"offense": 600, "life": 4000, "defense": 500, "brains": 400},
-                            "training_min": {"strength": 200, "technique": 150, "spirit": 100},
-                            "care_quality_min": 1.8,
-                            "battle_wins_min": 50,
-                            "relationship_level_min": 95,
-                            "special_achievements": ["Perfect_Care_Week", "Master_Trainer"]
-                        }
-                    }
-                ]
-            }
-        }
-    
-    def _initialize_evolution_requirements(self) -> Dict[str, Any]:
-        """Initialize detailed evolution requirement checkers"""
-        return {
-            "age_requirements": {
-                "check": lambda monster, req: monster.lifecycle.age_minutes >= req,
-                "display": lambda req: f"Age: {req/1440:.1f} days"
-            },
-            "stat_requirements": {
-                "check": self._check_stat_requirements,
-                "display": lambda req: f"Stats: {', '.join([f'{k}≥{v}' for k, v in req.items()])}"
-            },
-            "training_requirements": {
-                "check": self._check_training_requirements,
-                "display": lambda req: f"Training: {', '.join([f'{k}≥{v}' for k, v in req.items()])}"
-            },
-            "care_quality_requirements": {
-                "check": lambda monster, req: monster.stats.care_quality_score >= req,
-                "display": lambda req: f"Care Quality: {req:.1f}"
-            },
-            "item_requirements": {
-                "check": self._check_item_requirements,
-                "display": lambda req: f"Required Item: {req}"
-            },
-            "special_requirements": {
-                "check": self._check_stat_requirements,
-                "display": lambda req: f"Special: {', '.join(req) if isinstance(req, list) else req}"
-            }
-        }
-    
-    def _initialize_special_conditions(self) -> Dict[str, Any]:
-        """Initialize special evolution conditions"""
-        return {
-            "perfect_care_week": {
-                "description": "No care mistakes for 7 consecutive days",
-                "check": self._check_perfect_care_week
-            },
-            "master_trainer": {
-                "description": "Complete all training types to level 150+",
-                "check": self._check_master_trainer
-            },
-            "bond_master": {
-                "description": "Reach maximum relationship level",
-                "check": lambda monster: monster.personality.relationship_level >= 100
-            },
-            "evolution_master": {
-                "description": "Successfully evolve 10+ monsters",
-                "check": self._check_evolution_master
-            },
-            "overtraining": {
-                "description": "Training stats significantly exceed normal limits",
-                "check": self._check_overtraining
-            }
-        }
-    
-    async def check_evolution_eligibility(self, monster: Monster) -> Dict[str, Any]:
-        """Check if monster is eligible for evolution and return detailed info"""
-        try:
-            current_species = monster.species
-            current_stage = monster.lifecycle.stage
-            
-            # Get possible evolutions
-            possible_evolutions = self.evolution_trees.get(current_species, {}).get(current_stage, [])
-            
-            if not possible_evolutions:
-                return {
-                    "can_evolve": False,
-                    "reason": "No evolution paths available",
-                    "possible_evolutions": []
-                }
-            
-            evolution_results = []
-            
-            for evolution_option in possible_evolutions:
-                species = evolution_option["species"]
-                path = evolution_option["path"]
-                requirements = evolution_option["requirements"]
-                
-                # Check each requirement
-                met_requirements = []
-                missing_requirements = []
-                
-                for req_type, req_value in requirements.items():
-                    is_met = await self._check_requirement(monster, req_type, req_value)
-                    
-                    requirement_info = {
-                        "type": req_type,
-                        "requirement": req_value,
-                        "current_value": self._get_current_value(monster, req_type),
-                        "is_met": is_met
-                    }
-                    
-                    if is_met:
-                        met_requirements.append(requirement_info)
-                    else:
-                        missing_requirements.append(requirement_info)
-                
-                # Calculate evolution readiness percentage
-                total_requirements = len(met_requirements) + len(missing_requirements)
-                readiness_percentage = (len(met_requirements) / total_requirements * 100) if total_requirements > 0 else 0
-                
-                evolution_results.append({
-                    "species": species,
-                    "path": path.value,
-                    "readiness_percentage": readiness_percentage,
-                    "can_evolve": len(missing_requirements) == 0,
-                    "met_requirements": met_requirements,
-                    "missing_requirements": missing_requirements,
-                    "estimated_time_to_eligible": self._estimate_time_to_eligible(missing_requirements)
-                })
-            
-            # Find the best evolution option
-            eligible_evolutions = [e for e in evolution_results if e["can_evolve"]]
-            best_option = max(evolution_results, key=lambda x: x["readiness_percentage"]) if evolution_results else None
-            
-            return {
-                "can_evolve": len(eligible_evolutions) > 0,
-                "eligible_evolutions": eligible_evolutions,
-                "best_option": best_option,
-                "all_options": evolution_results,
-                "evolution_locked": monster.lifecycle.evolution_locked_until and 
-                                  monster.lifecycle.evolution_locked_until > datetime.now()
-            }
-            
-        except Exception as e:
-            self.logger.error(f"Evolution eligibility check failed: {e}")
-            return {
-                "can_evolve": False,
-                "reason": f"Error checking evolution: {str(e)}",
-                "possible_evolutions": []
-            }
-    
-    async def trigger_evolution(self, monster: Monster, target_species: str = None) -> Dict[str, Any]:
-        """Trigger monster evolution"""
-        try:
-            # Check if evolution is locked
-            if monster.lifecycle.evolution_locked_until and monster.lifecycle.evolution_locked_until > datetime.now():
-                return {
-                    "success": False,
-                    "reason": "Evolution is temporarily locked",
-                    "unlock_time": monster.lifecycle.evolution_locked_until
-                }
-            
-            # Get evolution eligibility
-            eligibility = await self.check_evolution_eligibility(monster)
-            
-            if not eligibility["can_evolve"]:
-                return {
-                    "success": False,
-                    "reason": "Evolution requirements not met",
-                    "eligibility": eligibility
-                }
-            
-            # Select evolution target
-            eligible_evolutions = eligibility["eligible_evolutions"]
-            
-            if target_species:
-                # Specific evolution requested
-                target_evolution = next((e for e in eligible_evolutions if e["species"] == target_species), None)
-                if not target_evolution:
-                    return {
-                        "success": False,
-                        "reason": f"Cannot evolve to {target_species}",
-                        "available_options": [e["species"] for e in eligible_evolutions]
-                    }
-            else:
-                # Choose best available evolution
-                target_evolution = max(eligible_evolutions, key=lambda x: x["readiness_percentage"])
-            
-            # Store previous state
-            previous_species = monster.species
-            previous_stage = monster.lifecycle.stage
-            
-            # Apply evolution
-            await self._apply_evolution(monster, target_evolution)
-            
-            # Log evolution event
-            evolution_result = {
-                "success": True,
-                "previous_species": previous_species,
-                "previous_stage": previous_stage.value,
-                "new_species": monster.species,
-                "new_stage": monster.lifecycle.stage.value,
-                "evolution_path": target_evolution["path"],
-                "stat_bonuses": self._calculate_evolution_bonuses(target_evolution),
-                "timestamp": datetime.now()
-            }
-            
-            self.logger.info(f"Monster evolved: {previous_species} -> {monster.species}")
-            
-            return evolution_result
-            
-        except Exception as e:
-            self.logger.error(f"Evolution trigger failed: {e}")
-            return {
-                "success": False,
-                "reason": f"Evolution failed: {str(e)}"
-            }
-    
-    async def _apply_evolution(self, monster: Monster, evolution_data: Dict[str, Any]):
-        """Apply evolution changes to monster"""
-        # Update basic info
-        monster.species = evolution_data["species"]
-        
-        # Determine new stage
-        stage_progression = {
-            EvolutionStage.EGG: EvolutionStage.BABY,
-            EvolutionStage.BABY: EvolutionStage.CHILD,
-            EvolutionStage.CHILD: EvolutionStage.ADULT,
-            EvolutionStage.ADULT: EvolutionStage.PERFECT,
-            EvolutionStage.PERFECT: EvolutionStage.ULTIMATE,
-            EvolutionStage.ULTIMATE: EvolutionStage.MEGA
-        }
-        
-        new_stage = stage_progression.get(monster.lifecycle.stage)
-        if new_stage:
-            monster.lifecycle.stage = new_stage
-        
-        # Apply stat bonuses
-        bonuses = self._calculate_evolution_bonuses(evolution_data)
-        for stat, bonus in bonuses.items():
-            if hasattr(monster.stats, stat):
-                current_value = getattr(monster.stats, stat)
-                new_value = int(current_value * bonus["multiplier"]) + bonus["flat_bonus"]
-                setattr(monster.stats, stat, new_value)
-        
-        # Reset some care stats
-        monster.stats.happiness = min(100, monster.stats.happiness + 20)
-        monster.stats.health = min(100, monster.stats.health + 30)
-        monster.stats.energy = min(100, monster.stats.energy + 40)
-        
-        # Update personality based on evolution path
-        self._apply_personality_changes(monster, evolution_data["path"])
-        
-        # Set evolution cooldown
-        monster.lifecycle.evolution_locked_until = datetime.now() + timedelta(hours=24)
-        
-        # Update emotional state
-        monster.emotional_state = EmotionalState.ECSTATIC
-        
-        # Add evolution achievement
-        if "special_achievements" not in monster.performance_metrics:
-            monster.performance_metrics["special_achievements"] = []
-        
-        monster.performance_metrics["special_achievements"].append({
-            "type": "evolution",
-            "species": monster.species,
-            "timestamp": datetime.now().isoformat()
-        })
-    
-    def _calculate_evolution_bonuses(self, evolution_data: Dict[str, Any]) -> Dict[str, Dict[str, float]]:
-        """Calculate stat bonuses for evolution"""
-        base_bonuses = {
-            "life": {"multiplier": 1.3, "flat_bonus": 200},
-            "mp": {"multiplier": 1.2, "flat_bonus": 50},
-            "offense": {"multiplier": 1.25, "flat_bonus": 30},
-            "defense": {"multiplier": 1.25, "flat_bonus": 30},
-            "speed": {"multiplier": 1.2, "flat_bonus": 20},
-            "brains": {"multiplier": 1.15, "flat_bonus": 25}
-        }
-        
-        # Modify bonuses based on evolution path
-        path_modifiers = {
-            EvolutionPath.NORMAL: 1.0,
-            EvolutionPath.VARIANT: 1.1,
-            EvolutionPath.SPECIAL: 1.3,
-            EvolutionPath.CORRUPTED: 0.9,
-            EvolutionPath.LEGENDARY: 1.5
-        }
-        
-        evolution_path = EvolutionPath(evolution_data["path"])
-        modifier = path_modifiers.get(evolution_path, 1.0)
-        
-        # Apply modifier to bonuses
-        modified_bonuses = {}
-        for stat, bonus in base_bonuses.items():
-            modified_bonuses[stat] = {
-                "multiplier": bonus["multiplier"] * modifier,
-                "flat_bonus": int(bonus["flat_bonus"] * modifier)
-            }
-        
-        return modified_bonuses
-    
-    def _apply_personality_changes(self, monster: Monster, evolution_path: str):
-        """Apply personality changes based on evolution path"""
-        path_personality_effects = {
-            EvolutionPath.NORMAL: {
-                "conscientiousness": 0.05,
-                "stability": 0.03
-            },
-            EvolutionPath.VARIANT: {
-                "openness": 0.08,
-                "curiosity": 0.05
-            },
-            EvolutionPath.SPECIAL: {
-                "extraversion": 0.1,
-                "confidence": 0.07
-            },
-            EvolutionPath.CORRUPTED: {
-                "neuroticism": 0.15,
-                "aggression": 0.1,
-                "happiness_decay_rate": 1.2
-            },
-            EvolutionPath.LEGENDARY: {
-                "all_traits": 0.1,
-                "relationship_bonus": 10
-            }
-        }
-        
-        effects = path_personality_effects.get(EvolutionPath(evolution_path), {})
-        
-        for trait, change in effects.items():
-            if trait == "all_traits":
-                # Boost all personality traits
-                for personality_trait in ["openness", "conscientiousness", "extraversion", "agreeableness"]:
-                    if hasattr(monster.personality, personality_trait):
-                        current = getattr(monster.personality, personality_trait)
-                        setattr(monster.personality, personality_trait, min(1.0, current + change))
-            elif trait == "relationship_bonus":
-                monster.personality.relationship_level = min(100, monster.personality.relationship_level + change)
-            elif hasattr(monster.personality, trait):
-                current = getattr(monster.personality, trait)
-                setattr(monster.personality, trait, min(1.0, max(0.0, current + change)))
-    
-    async def _check_requirement(self, monster: Monster, req_type: str, req_value: Any) -> bool:
-        """Check if a specific requirement is met"""
-        try:
-            if req_type == "age_minutes":
-                return monster.lifecycle.age_minutes >= req_value
-            
-            elif req_type == "care_mistakes_max":
-                return monster.lifecycle.care_mistakes <= req_value
-            
-            elif req_type == "care_mistakes_min":
-                return monster.lifecycle.care_mistakes >= req_value
-            
-            elif req_type == "stats_min":
-                return self._check_stat_requirements(monster, req_value)
-            
-            elif req_type == "training_min":
-                return self._check_training_requirements(monster, req_value)
-            
-            elif req_type == "care_quality_min":
-                return monster.stats.care_quality_score >= req_value
-            
-            elif req_type == "health_min":
-                return monster.stats.health >= req_value
-            
-            elif req_type == "happiness_max":
-                return monster.stats.happiness <= req_value
-            
-            elif req_type == "happiness_min":
-                return monster.stats.happiness >= req_value
-            
-            elif req_type == "discipline_min":
-                return monster.stats.discipline >= req_value
-            
-            elif req_type == "relationship_level_min":
-                return monster.personality.relationship_level >= req_value
-            
-            elif req_type == "special_item":
-                return req_value in monster.inventory and monster.inventory[req_value] > 0
-            
-            elif req_type == "special_achievements":
-                return self._check_special_achievements(monster, req_value)
-            
-            elif req_type == "battle_wins_min":
-                return monster.performance_metrics.get("battle_wins", 0) >= req_value
-            
-            elif req_type == "overtraining":
-                return self._check_overtraining(monster)
-            
-            else:
-                self.logger.warning(f"Unknown requirement type: {req_type}")
-                return False
-                
-        except Exception as e:
-            self.logger.error(f"Requirement check failed for {req_type}: {e}")
-            return False
-    
-    def _check_stat_requirements(self, monster: Monster, requirements: Dict[str, int]) -> bool:
-        """Check if stat requirements are met"""
-        for stat_name, min_value in requirements.items():
-            if hasattr(monster.stats, stat_name):
-                current_value = getattr(monster.stats, stat_name)
-                if current_value < min_value:
-                    return False
-            else:
-                return False
-        return True
-    
-    def _check_training_requirements(self, monster: Monster, requirements: Dict[str, int]) -> bool:
-        """Check if training requirements are met"""
-        for training_type, min_value in requirements.items():
-            current_value = monster.stats.training_progress.get(training_type, 0)
-            if current_value < min_value:
-                return False
-        return True
-    
-    def _check_item_requirements(self, monster: Monster, item_name: str) -> bool:
-        """Check if monster has required item"""
-        return item_name in monster.inventory and monster.inventory[item_name] > 0
-    
-    def _check_special_achievements(self, monster: Monster, required_achievements: List[str]) -> bool:
-        """Check if special achievements are unlocked"""
-        achievements = monster.performance_metrics.get("special_achievements", [])
-        achievement_types = [a.get("type") for a in achievements if isinstance(a, dict)]
-        
-        for required in required_achievements:
-            if required not in achievement_types:
-                return False
-        return True
-    
-    def _check_overtraining(self, monster: Monster) -> bool:
-        """Check if monster is overtrained"""
-        training_totals = sum(monster.stats.training_progress.values())
-        return training_totals > 800  # Threshold for overtraining
-    
-    def _check_perfect_care_week(self, monster: Monster) -> bool:
-        """Check if monster had perfect care for a week"""
-        # Simplified check - would need more complex tracking in production
-        return monster.lifecycle.care_mistakes == 0 and monster.lifecycle.age_minutes >= 10080  # 7 days
-    
-    def _check_master_trainer(self, monster: Monster) -> bool:
-        """Check if all training types are at 150+"""
-        for training_type in ["strength", "endurance", "intelligence", "dexterity", "spirit", "technique"]:
-            if monster.stats.training_progress.get(training_type, 0) < 150:
-                return False
-        return True
-    
-    def _check_evolution_master(self, monster: Monster) -> bool:
-        """Check if player has evolved many monsters"""
-        # This would need global tracking in production
-        evolutions = [a for a in monster.performance_metrics.get("special_achievements", []) 
-                     if isinstance(a, dict) and a.get("type") == "evolution"]
-        return len(evolutions) >= 10
-    
-    def _get_current_value(self, monster: Monster, req_type: str) -> Any:
-        """Get current value for a requirement type"""
-        value_getters = {
-            "age_minutes": lambda: monster.lifecycle.age_minutes,
-            "care_mistakes_max": lambda: monster.lifecycle.care_mistakes,
-            "care_mistakes_min": lambda: monster.lifecycle.care_mistakes,
-            "health_min": lambda: monster.stats.health,
-            "happiness_max": lambda: monster.stats.happiness,
-            "happiness_min": lambda: monster.stats.happiness,
-            "discipline_min": lambda: monster.stats.discipline,
-            "care_quality_min": lambda: monster.stats.care_quality_score,
-            "relationship_level_min": lambda: monster.personality.relationship_level,
-            "battle_wins_min": lambda: monster.performance_metrics.get("battle_wins", 0)
-        }
-        
-        getter = value_getters.get(req_type)
-        return getter() if getter else "N/A"
-    
-    def _estimate_time_to_eligible(self, missing_requirements: List[Dict[str, Any]]) -> str:
-        """Estimate time until evolution requirements are met"""
-        time_estimates = []
-        
-        for req in missing_requirements:
-            req_type = req["type"]
-            
-            if req_type == "age_minutes":
-                current = req["current_value"]
-                required = req["requirement"]
-                remaining_minutes = required - current
-                time_estimates.append(f"{remaining_minutes/1440:.1f} days")
-            
-            elif "training" in req_type:
-                # Estimate based on training rate
-                time_estimates.append("1-3 days of training")
-            
-            elif "stat" in req_type:
-                # Estimate based on training and care
-                time_estimates.append("2-5 days of care/training")
-            
-            else:
-                time_estimates.append("Variable")
-        
-        return ", ".join(time_estimates) if time_estimates else "Ready now"