Update to new app icon (1024px)

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* 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
+logo.png filter=lfs diff=lfs merge=lfs -text

reachy_ios_bridge/database.py

@@ -103,6 +103,23 @@ class DatabaseService:
             )
         """)
 
+        # Websites table for generated websites
+        await db.execute("""
+            CREATE TABLE IF NOT EXISTS websites (
+                id TEXT PRIMARY KEY,
+                title TEXT NOT NULL,
+                description TEXT DEFAULT '',
+                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+            )
+        """)
+
+        # Index for faster queries by creation date
+        await db.execute("""
+            CREATE INDEX IF NOT EXISTS idx_websites_created 
+            ON websites(created_at)
+        """)
+
         logger.debug("Database tables created/verified")
     
     async def _migrate_add_enabled_tools(self, db: aiosqlite.Connection) -> None:
@@ -583,6 +600,129 @@ class DatabaseService:
             rows = await cursor.fetchall()
             return {row[0]: row[1] for row in rows}
 
+    # =========================================================================
+    # Websites CRUD Operations
+    # =========================================================================
+
+    async def get_all_websites(self) -> list[dict]:
+        """Get all saved websites from the database.
+
+        Returns:
+            List of website dictionaries.
+        """
+        async with aiosqlite.connect(self.db_path) as db:
+            db.row_factory = aiosqlite.Row
+            cursor = await db.execute(
+                "SELECT * FROM websites ORDER BY created_at DESC"
+            )
+            rows = await cursor.fetchall()
+            return [self._row_to_website(row) for row in rows]
+
+    async def get_website(self, website_id: str) -> Optional[dict]:
+        """Get a single website by ID.
+
+        Args:
+            website_id: The ID of the website.
+
+        Returns:
+            The website dictionary, or None if not found.
+        """
+        async with aiosqlite.connect(self.db_path) as db:
+            db.row_factory = aiosqlite.Row
+            cursor = await db.execute(
+                "SELECT * FROM websites WHERE id = ?", (website_id,)
+            )
+            row = await cursor.fetchone()
+            return self._row_to_website(row) if row else None
+
+    async def create_website(self, website_data: dict) -> dict:
+        """Create a new website record.
+
+        Args:
+            website_data: Dictionary containing website data (must include 'id', 'title').
+
+        Returns:
+            The created website dictionary.
+        """
+        now = datetime.utcnow().isoformat()
+        created_at = website_data.get("created_at") or now
+
+        async with aiosqlite.connect(self.db_path) as db:
+            await db.execute(
+                """
+                INSERT INTO websites (id, title, description, created_at, updated_at)
+                VALUES (?, ?, ?, ?, ?)
+                """,
+                (
+                    website_data["id"],
+                    website_data["title"],
+                    website_data.get("description", ""),
+                    created_at,
+                    now,
+                ),
+            )
+            await db.commit()
+
+        logger.info(f"Created website: {website_data['title']} ({website_data['id']})")
+        return await self.get_website(website_data["id"])
+
+    async def update_website(self, website_id: str, website_data: dict) -> Optional[dict]:
+        """Update an existing website record.
+
+        Args:
+            website_id: The ID of the website to update.
+            website_data: Dictionary containing updated website data.
+
+        Returns:
+            The updated website dictionary, or None if not found.
+        """
+        existing = await self.get_website(website_id)
+        if not existing:
+            return None
+
+        now = datetime.utcnow().isoformat()
+
+        async with aiosqlite.connect(self.db_path) as db:
+            await db.execute(
+                """
+                UPDATE websites SET
+                    title = ?,
+                    description = ?,
+                    updated_at = ?
+                WHERE id = ?
+                """,
+                (
+                    website_data.get("title", existing["title"]),
+                    website_data.get("description", existing["description"]),
+                    now,
+                    website_id,
+                ),
+            )
+            await db.commit()
+
+        logger.info(f"Updated website: {website_id}")
+        return await self.get_website(website_id)
+
+    async def delete_website(self, website_id: str) -> bool:
+        """Delete a website record.
+
+        Args:
+            website_id: The ID of the website to delete.
+
+        Returns:
+            True if deleted, False if not found.
+        """
+        async with aiosqlite.connect(self.db_path) as db:
+            cursor = await db.execute(
+                "DELETE FROM websites WHERE id = ?", (website_id,)
+            )
+            await db.commit()
+            deleted = cursor.rowcount > 0
+
+        if deleted:
+            logger.info(f"Deleted website: {website_id}")
+        return deleted
+
     # =========================================================================
     # Helper Methods
     # =========================================================================
@@ -636,6 +776,23 @@ class DatabaseService:
             "updated_at": row["updated_at"],
         }
 
+    def _row_to_website(self, row: aiosqlite.Row) -> dict:
+        """Convert a database row to a website dictionary.
+
+        Args:
+            row: The database row.
+
+        Returns:
+            Website dictionary with proper types.
+        """
+        return {
+            "id": row["id"],
+            "title": row["title"],
+            "description": row["description"],
+            "created_at": row["created_at"],
+            "updated_at": row["updated_at"],
+        }
+
     async def close(self) -> None:
         """Close database connection (if using persistent connection)."""
         if self._connection:

reachy_ios_bridge/openai_realtime.py

@@ -138,6 +138,7 @@ class OpenAIRealtimeService:
         self.on_error: Optional[Callable[[str], None]] = None
         self.on_app_change: Optional[Callable[[dict], None]] = None  # App activation changes
         self.on_tool_usage: Optional[Callable[[str, str], None]] = None  # (tool_name, status)
+        self.on_website_ready: Optional[Callable[[dict], None]] = None  # Website generation result
         
         # Setup tools handler callbacks
         self._setup_tools_handler()
@@ -264,7 +265,14 @@ Before using ANY tool, you MUST tell the user what you're about to do. This help
 
 6. PERSONALIZATION: Remember user details for personal interactions.
    - When user says their name: Use remember_user_name to save it
-   - To check if you know their name: Use get_user_name""" + language_instruction
+   - To check if you know their name: Use get_user_name
+
+7. WEBSITE GENERATION: Create beautiful websites with voice commands!
+   - Use generate_website when user asks to create a website, landing page, portfolio, etc.
+   - Examples: "Create a website for my bakery", "Make me a portfolio", "Build a landing page"
+   - You can also EDIT existing websites: "Change the colors", "Add a contact section"
+   - ALWAYS say "Let me create that website for you..." before using this tool.
+   - The website will be shown as a live preview while being built!""" + language_instruction
     
     def set_custom_personality(
         self,
@@ -691,6 +699,16 @@ Before using ANY tool, you MUST tell the user what you're about to do. This help
             
             logger.info(f"🔧 Tool result: {result}")
             
+            # Check if this is a website generation result
+            if tool_name == "generate_website" and result.get("success"):
+                if self.on_website_ready:
+                    self.on_website_ready({
+                        "website_id": result.get("website_id"),
+                        "url": result.get("url"),
+                        "title": result.get("title"),
+                        "is_edit": result.get("is_edit", False),
+                    })
+            
             # Send result back to OpenAI
             result_message = {
                 "type": "conversation.item.create",

reachy_ios_bridge/routes/__init__.py

@@ -13,6 +13,7 @@ from .tools import router as tools_router
 from .user_settings import router as user_settings_router
 from .voice import router as voice_router
 from .volume import router as volume_router
+from .websites import router as websites_router
 
 __all__ = [
     "animations_router",
@@ -28,5 +29,6 @@ __all__ = [
     "user_settings_router",
     "voice_router",
     "volume_router",
+    "websites_router",
 ]
 

reachy_ios_bridge/routes/conversation.py

@@ -15,6 +15,7 @@ from ..animation_coordinator import AnimationCoordinator
 from ..motion_service import MotionService
 from ..openai_realtime import ConnectionState, OpenAIRealtimeService, SpeakingState
 from ..speaking_gestures import SpeakingGesturesService
+from ..tools import set_website_streaming_callbacks
 
 from .audio_stream_manager import AudioStreamManager, ConversationTimings
 from .conversation_messages import (
@@ -84,6 +85,13 @@ def init_services() -> None:
     openai_service.on_error = _on_error
     openai_service.on_app_change = _on_app_change
     openai_service.on_tool_usage = _on_tool_usage
+    openai_service.on_website_ready = _on_website_ready
+    
+    # Wire up website streaming callbacks for live preview
+    set_website_streaming_callbacks(
+        on_generating=_on_website_generating,
+        on_chunk=_on_website_chunk,
+    )
     
     logger.info("Conversation services initialized")
 
@@ -370,6 +378,74 @@ def _on_tool_usage(tool_name: str, status: str) -> None:
     }))
 
 
+def _on_website_ready(data: dict) -> None:
+    """Handle website generation completion.
+    
+    Broadcasts to iOS clients so they can display the generated website.
+    
+    Args:
+        data: Website data containing id, url, title, is_edit
+    """
+    website_id = data.get("website_id", "")
+    url = data.get("url", "")
+    title = data.get("title", "Generated Website")
+    is_edit = data.get("is_edit", False)
+    
+    action = "updated" if is_edit else "created"
+    logger.info(f"🌐 Website {action}: {title} ({website_id})")
+    
+    asyncio.create_task(_broadcast({
+        "type": "website_ready",
+        "website_id": website_id,
+        "url": url,
+        "title": title,
+        "is_edit": is_edit,
+    }))
+
+
+def _on_website_generating(website_id: str, description: str, is_edit: bool) -> None:
+    """Handle website generation start - enables live preview on iOS.
+    
+    Broadcasts to iOS clients so they can show a preview sheet.
+    
+    Args:
+        website_id: Unique ID for this website.
+        description: User's description of the website.
+        is_edit: Whether this is editing an existing website.
+    """
+    action = "Editing" if is_edit else "Creating"
+    logger.info(f"🎨 {action} website {website_id}: {description[:50]}...")
+    
+    asyncio.create_task(_broadcast({
+        "type": "website_generating",
+        "website_id": website_id,
+        "description": description,
+        "is_edit": is_edit,
+    }))
+
+
+def _on_website_chunk(website_id: str, accumulated_html: str, is_complete: bool) -> None:
+    """Handle website HTML chunk for live preview streaming.
+    
+    Broadcasts accumulated HTML to iOS clients for real-time preview.
+    
+    Args:
+        website_id: The website being generated.
+        accumulated_html: All HTML content so far.
+        is_complete: Whether generation is complete.
+    """
+    # Only log completion to avoid spam
+    if is_complete:
+        logger.info(f"📄 Website {website_id} complete: {len(accumulated_html)} chars")
+    
+    asyncio.create_task(_broadcast({
+        "type": "website_chunk",
+        "website_id": website_id,
+        "html": accumulated_html,
+        "is_complete": is_complete,
+    }))
+
+
 def _on_app_change(data: dict) -> None:
     """Handle app activation/deactivation changes from voice commands.
     

reachy_ios_bridge/routes/websites.py

@@ -0,0 +1,221 @@
+"""Websites API endpoints for managing generated websites.
+
+Provides CRUD operations for websites and serves static website files.
+"""
+
+import logging
+import shutil
+from pathlib import Path
+from typing import Optional
+
+from fastapi import APIRouter, HTTPException
+from fastapi.responses import FileResponse
+from pydantic import BaseModel
+
+from ..database import get_database
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter(prefix="/websites", tags=["Websites"])
+
+# Directory to store generated websites (alongside the database)
+WEBSITES_DIR = Path.home() / ".reachy" / "websites"
+
+
+# =============================================================================
+# Response Models
+# =============================================================================
+
+
+class WebsiteInfo(BaseModel):
+    """Website metadata for API responses."""
+    id: str
+    title: str
+    description: str
+    url: str
+    created_at: str
+    updated_at: str
+
+
+class WebsitesListResponse(BaseModel):
+    """Response for listing all websites."""
+    success: bool
+    websites: list[WebsiteInfo]
+    count: int
+
+
+class WebsiteResponse(BaseModel):
+    """Response for single website operations."""
+    success: bool
+    website: Optional[WebsiteInfo] = None
+    message: Optional[str] = None
+
+
+# =============================================================================
+# Helper Functions
+# =============================================================================
+
+
+def _get_website_url(website_id: str) -> str:
+    """Get the URL path for a website."""
+    return f"/websites/{website_id}/index.html"
+
+
+def _website_to_info(website: dict) -> WebsiteInfo:
+    """Convert a database website dict to WebsiteInfo."""
+    return WebsiteInfo(
+        id=website["id"],
+        title=website["title"],
+        description=website["description"],
+        url=_get_website_url(website["id"]),
+        created_at=website["created_at"],
+        updated_at=website["updated_at"],
+    )
+
+
+# =============================================================================
+# CRUD Endpoints
+# =============================================================================
+
+
+@router.get("", response_model=WebsitesListResponse)
+async def list_websites() -> WebsitesListResponse:
+    """List all saved websites."""
+    try:
+        db = get_database()
+        websites = await db.get_all_websites()
+        
+        # Filter to only include websites that have files on disk
+        valid_websites = []
+        for website in websites:
+            website_dir = WEBSITES_DIR / website["id"]
+            if website_dir.exists() and (website_dir / "index.html").exists():
+                valid_websites.append(_website_to_info(website))
+            else:
+                # Clean up orphaned database entry
+                logger.warning(f"Website {website['id']} has no files, removing from database")
+                await db.delete_website(website["id"])
+        
+        return WebsitesListResponse(
+            success=True,
+            websites=valid_websites,
+            count=len(valid_websites),
+        )
+    except Exception as e:
+        logger.error(f"Error listing websites: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("/{website_id}", response_model=WebsiteResponse)
+async def get_website(website_id: str) -> WebsiteResponse:
+    """Get a single website by ID."""
+    try:
+        db = get_database()
+        website = await db.get_website(website_id)
+        
+        if not website:
+            raise HTTPException(status_code=404, detail="Website not found")
+        
+        # Verify files exist
+        website_dir = WEBSITES_DIR / website_id
+        if not website_dir.exists() or not (website_dir / "index.html").exists():
+            # Clean up orphaned database entry
+            await db.delete_website(website_id)
+            raise HTTPException(status_code=404, detail="Website files not found")
+        
+        return WebsiteResponse(
+            success=True,
+            website=_website_to_info(website),
+        )
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error getting website {website_id}: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.delete("/{website_id}")
+async def delete_website(website_id: str) -> dict:
+    """Delete a website (both database record and files)."""
+    try:
+        db = get_database()
+        
+        # Delete from database
+        deleted = await db.delete_website(website_id)
+        
+        # Delete files
+        website_dir = WEBSITES_DIR / website_id
+        if website_dir.exists():
+            shutil.rmtree(website_dir)
+            logger.info(f"Deleted website files: {website_dir}")
+        
+        if not deleted and not website_dir.exists():
+            raise HTTPException(status_code=404, detail="Website not found")
+        
+        return {
+            "success": True,
+            "message": f"Website {website_id} deleted successfully",
+        }
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error deleting website {website_id}: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+# =============================================================================
+# Static File Serving
+# =============================================================================
+
+
+@router.get("/{website_id}/index.html")
+async def serve_website(website_id: str) -> FileResponse:
+    """Serve the index.html file for a website."""
+    website_file = WEBSITES_DIR / website_id / "index.html"
+    
+    if not website_file.exists():
+        raise HTTPException(status_code=404, detail="Website not found")
+    
+    return FileResponse(
+        path=website_file,
+        media_type="text/html",
+        filename="index.html",
+    )
+
+
+@router.get("/{website_id}/{file_path:path}")
+async def serve_website_asset(website_id: str, file_path: str) -> FileResponse:
+    """Serve additional assets for a website (CSS, JS, images, etc.)."""
+    # Security: Prevent directory traversal
+    if ".." in file_path:
+        raise HTTPException(status_code=400, detail="Invalid file path")
+    
+    asset_file = WEBSITES_DIR / website_id / file_path
+    
+    if not asset_file.exists():
+        raise HTTPException(status_code=404, detail="Asset not found")
+    
+    # Determine media type based on extension
+    suffix = asset_file.suffix.lower()
+    media_types = {
+        ".html": "text/html",
+        ".css": "text/css",
+        ".js": "application/javascript",
+        ".json": "application/json",
+        ".png": "image/png",
+        ".jpg": "image/jpeg",
+        ".jpeg": "image/jpeg",
+        ".gif": "image/gif",
+        ".svg": "image/svg+xml",
+        ".ico": "image/x-icon",
+        ".woff": "font/woff",
+        ".woff2": "font/woff2",
+        ".ttf": "font/ttf",
+    }
+    media_type = media_types.get(suffix, "application/octet-stream")
+    
+    return FileResponse(
+        path=asset_file,
+        media_type=media_type,
+    )
+

reachy_ios_bridge/server.py

@@ -6,11 +6,13 @@ Individual endpoint handlers are organized in the routes/ package.
 
 import logging
 from contextlib import asynccontextmanager
+from pathlib import Path
 from typing import AsyncGenerator
 
 import uvicorn
 from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
+from fastapi.staticfiles import StaticFiles
 
 from .database import init_database
 from .models import RobotStatus
@@ -30,6 +32,7 @@ from .routes import (
     user_settings_router,
     voice_router,
     volume_router,
+    websites_router,
 )
 from .routes import speech as speech_route
 from .routes import motion as motion_route
@@ -117,6 +120,7 @@ app.include_router(tools_router)
 app.include_router(user_settings_router)
 app.include_router(voice_router)
 app.include_router(volume_router)
+app.include_router(websites_router)
 
 
 # Health and status endpoints
@@ -131,6 +135,27 @@ async def root() -> dict:
     }
 
 
+# Website endpoints
+
+@app.get("/api/websites", tags=["Websites"])
+async def list_generated_websites() -> dict:
+    """List all generated websites."""
+    from .tools.website_generator import list_websites
+    return {
+        "websites": list_websites(),
+    }
+
+
+@app.get("/api/websites/{website_id}", tags=["Websites"])
+async def get_website_details(website_id: str) -> dict:
+    """Get details about a specific generated website."""
+    from .tools.website_generator import get_website_info
+    info = get_website_info(website_id)
+    if not info:
+        return {"error": "Website not found"}
+    return info
+
+
 @app.get("/status", response_model=RobotStatus, tags=["Status"])
 async def get_status() -> RobotStatus:
     """Get current robot status."""

reachy_ios_bridge/tools/__init__.py

@@ -163,6 +163,7 @@ def _register_default_tools() -> None:
     from .vision import register_vision_tools
     from .weather import register_weather_tool
     from .web_search import register_web_search_tool
+    from .website_generator import register_website_generator_tool
     
     registry = _registry
     if registry:
@@ -170,9 +171,39 @@ def _register_default_tools() -> None:
         register_weather_tool(registry)
         register_web_search_tool(registry)
         register_vision_tools(registry)
+        register_website_generator_tool(registry)
 
 
 # Default tools for Reachy (all tools enabled)
 # IDs must match the function names in the OpenAI definitions
-DEFAULT_ENABLED_TOOLS = ["get_current_datetime", "get_weather", "web_search", "test_camera", "recognize_object"]
+DEFAULT_ENABLED_TOOLS = [
+    "get_current_datetime",
+    "get_weather",
+    "web_search",
+    "test_camera",
+    "recognize_object",
+    "generate_website",
+]
+
+
+# Re-export website streaming callbacks for easy access
+def set_website_streaming_callbacks(
+    on_generating: Optional[Callable[[str, str, bool], None]] = None,
+    on_chunk: Optional[Callable[[str, str, bool], None]] = None,
+) -> None:
+    """Set callbacks for website streaming events.
+    
+    Args:
+        on_generating: Called when website generation starts.
+            Signature: (website_id, description, is_edit) -> None
+        on_chunk: Called when a new HTML chunk is available.
+            Signature: (website_id, accumulated_html, is_complete) -> None
+    """
+    from .website_generator import (
+        set_website_chunk_callback,
+        set_website_generating_callback,
+    )
+    
+    set_website_generating_callback(on_generating)
+    set_website_chunk_callback(on_chunk)
 

reachy_ios_bridge/tools/website_generator.py

@@ -0,0 +1,474 @@
+"""Website generator tool using GPT-5.2 Responses API.
+
+Generates HTML/CSS/Tailwind websites through voice commands.
+Supports iterative editing through conversation context.
+Supports streaming for real-time preview on iOS.
+"""
+
+import asyncio
+import json
+import logging
+import os
+import uuid
+from datetime import datetime
+from pathlib import Path
+from typing import TYPE_CHECKING, Callable, Optional
+
+import aiohttp
+
+from ..database import get_database
+
+if TYPE_CHECKING:
+    from . import ToolRegistry
+
+logger = logging.getLogger(__name__)
+
+# OpenAI Responses API endpoint
+OPENAI_RESPONSES_URL = "https://api.openai.com/v1/responses"
+GPT52_MODEL = "gpt-5.2"
+
+# Streaming chunk callback type
+# Callback signature: (website_id: str, html_chunk: str, is_complete: bool) -> None
+WebsiteChunkCallback = Callable[[str, str, bool], None]
+
+# Global callback for streaming website chunks to iOS
+_website_chunk_callback: Optional[WebsiteChunkCallback] = None
+_website_generating_callback: Optional[Callable[[str, str, bool], None]] = None
+
+
+def set_website_chunk_callback(callback: Optional[WebsiteChunkCallback]) -> None:
+    """Set the callback for streaming website HTML chunks.
+    
+    Args:
+        callback: Function that receives (website_id, html_chunk, is_complete).
+    """
+    global _website_chunk_callback
+    _website_chunk_callback = callback
+
+
+def set_website_generating_callback(
+    callback: Optional[Callable[[str, str, bool], None]]
+) -> None:
+    """Set the callback for when website generation starts.
+    
+    Args:
+        callback: Function that receives (website_id, description, is_edit).
+    """
+    global _website_generating_callback
+    _website_generating_callback = callback
+
+# Directory to store generated websites (alongside the database)
+WEBSITES_DIR = Path.home() / ".reachy" / "websites"
+
+# System prompt for website generation
+WEBSITE_SYSTEM_PROMPT = """You are an expert web developer who creates beautiful, modern websites.
+
+IMPORTANT RULES:
+1. Generate a SINGLE, complete HTML file with embedded CSS and inline Tailwind classes
+2. Use Tailwind CSS via CDN: <script src="https://cdn.tailwindcss.com"></script>
+3. Create responsive, mobile-first designs
+4. Use modern design patterns: gradients, shadows, rounded corners, smooth transitions
+5. Include beautiful typography and proper spacing
+6. Add subtle animations and hover effects for interactivity
+7. Use a cohesive color palette that matches the website's purpose
+8. Include placeholder images from https://picsum.photos/ or similar
+9. Make the website feel professional and polished
+
+OUTPUT FORMAT:
+- Return ONLY the HTML code, nothing else
+- Start with <!DOCTYPE html> and end with </html>
+- Do not include any explanations or markdown code blocks
+- The HTML must be valid and complete
+
+When editing an existing website:
+- Make the requested changes while preserving the overall design
+- Keep the same color scheme unless asked to change it
+- Maintain responsive behavior
+"""
+
+# Store active website sessions for iterative editing
+_website_sessions: dict[str, dict] = {}
+
+
+# OpenAI function definition for the website generator tool
+WEBSITE_GENERATOR_TOOL_DEFINITION = {
+    "type": "function",
+    "name": "generate_website",
+    "description": (
+        "Generate or edit a website using HTML, CSS, and Tailwind. "
+        "Use this when the user asks to create a website, landing page, portfolio, "
+        "or any web page. Also use this to make changes to an existing website."
+    ),
+    "parameters": {
+        "type": "object",
+        "properties": {
+            "description": {
+                "type": "string",
+                "description": (
+                    "Detailed description of the website to create or the changes to make. "
+                    "Include: purpose, style preferences, colors, sections, and any specific features."
+                ),
+            },
+            "website_id": {
+                "type": "string",
+                "description": (
+                    "Optional. The ID of an existing website to edit. "
+                    "Leave empty to create a new website."
+                ),
+            },
+        },
+        "required": ["description"],
+    },
+}
+
+
+async def generate_website(arguments: dict) -> dict:
+    """Generate or edit a website using GPT-5.2 with streaming support.
+    
+    Streams HTML chunks to iOS via callback for real-time preview.
+    
+    Args:
+        arguments: Tool arguments with 'description' and optional 'website_id'.
+        
+    Returns:
+        Result dictionary with website URL and metadata.
+    """
+    description = arguments.get("description", "").strip()
+    website_id = arguments.get("website_id", "").strip()
+    
+    if not description:
+        return {"success": False, "error": "Website description is required"}
+    
+    # Get API key
+    api_key = os.environ.get("OPENAI_API_KEY")
+    if not api_key:
+        return {"success": False, "error": "OpenAI API key not configured"}
+    
+    # Ensure websites directory exists
+    WEBSITES_DIR.mkdir(parents=True, exist_ok=True)
+    
+    # Determine if this is a new website or an edit
+    is_edit = bool(website_id) and website_id in _website_sessions
+    
+    if is_edit:
+        session_data = _website_sessions[website_id]
+        previous_response_id = session_data.get("last_response_id")
+        prompt = f"Edit the website with the following changes:\n\n{description}"
+        logger.info(f"🎨 Editing website {website_id}: {description[:50]}...")
+    else:
+        # Create new website
+        website_id = str(uuid.uuid4())[:8]
+        previous_response_id = None
+        prompt = f"Create a website with the following requirements:\n\n{description}"
+        logger.info(f"🎨 Creating new website {website_id}: {description[:50]}...")
+    
+    # Notify iOS that website generation is starting
+    if _website_generating_callback:
+        _website_generating_callback(website_id, description, is_edit)
+    
+    headers = {
+        "Authorization": f"Bearer {api_key}",
+        "Content-Type": "application/json",
+    }
+    
+    # Build the Responses API payload with streaming enabled
+    payload = {
+        "model": GPT52_MODEL,
+        "input": prompt,
+        "instructions": WEBSITE_SYSTEM_PROMPT,
+        "reasoning": {"effort": "medium"},
+        "text": {"format": {"type": "text"}},
+        "stream": True,  # Enable streaming for real-time preview
+    }
+    
+    # Add previous response ID for iterative editing
+    if previous_response_id:
+        payload["previous_response_id"] = previous_response_id
+    
+    html_content = ""
+    response_id = ""
+    last_chunk_time = asyncio.get_event_loop().time()
+    chunk_buffer = ""
+    CHUNK_THROTTLE_MS = 200  # Throttle updates to avoid flickering
+    
+    try:
+        async with aiohttp.ClientSession() as session:
+            async with session.post(
+                OPENAI_RESPONSES_URL,
+                headers=headers,
+                json=payload,
+                timeout=aiohttp.ClientTimeout(total=300),  # 5 min timeout for streaming
+            ) as response:
+                if response.status != 200:
+                    error_text = await response.text()
+                    logger.error(f"GPT-5.2 API error: {error_text}")
+                    return {
+                        "success": False,
+                        "error": f"Website generation failed: {response.status}",
+                    }
+                
+                # Process streaming response (Server-Sent Events format)
+                async for line in response.content:
+                    line_text = line.decode("utf-8").strip()
+                    
+                    # Skip empty lines and "data: " prefix handling
+                    if not line_text:
+                        continue
+                    
+                    if line_text.startswith("data: "):
+                        json_str = line_text[6:]  # Remove "data: " prefix
+                        
+                        if json_str == "[DONE]":
+                            # Stream complete
+                            break
+                        
+                        try:
+                            event = json.loads(json_str)
+                            event_type = event.get("type", "")
+                            
+                            # Capture response ID
+                            if event_type == "response.created":
+                                response_id = event.get("response", {}).get("id", "")
+                            
+                            # Handle text deltas (the HTML content)
+                            elif event_type == "response.output_text.delta":
+                                delta = event.get("delta", "")
+                                if delta:
+                                    html_content += delta
+                                    chunk_buffer += delta
+                                    
+                                    # Throttle streaming updates to avoid UI flickering
+                                    current_time = asyncio.get_event_loop().time()
+                                    if (current_time - last_chunk_time) * 1000 >= CHUNK_THROTTLE_MS:
+                                        if _website_chunk_callback and chunk_buffer:
+                                            _website_chunk_callback(
+                                                website_id,
+                                                html_content,  # Send accumulated HTML
+                                                False  # Not complete yet
+                                            )
+                                        chunk_buffer = ""
+                                        last_chunk_time = current_time
+                            
+                            # Handle completion
+                            elif event_type == "response.output_text.done":
+                                # Final chunk - send complete HTML
+                                if _website_chunk_callback:
+                                    _website_chunk_callback(
+                                        website_id,
+                                        html_content,
+                                        True  # Complete
+                                    )
+                                logger.info(f"📄 Streaming complete: {len(html_content)} chars")
+                        
+                        except json.JSONDecodeError:
+                            logger.debug(f"Non-JSON SSE line: {json_str[:50]}")
+    
+    except aiohttp.ClientError as e:
+        logger.error(f"Website generation request failed: {e}")
+        return {"success": False, "error": f"Request failed: {str(e)}"}
+    except asyncio.TimeoutError:
+        logger.error("Website generation timed out after 5 minutes")
+        return {"success": False, "error": "Generation timed out after 5 minutes - try a simpler request"}
+    except Exception as e:
+        logger.error(f"Website generation error: {e}", exc_info=True)
+        return {"success": False, "error": str(e)}
+    
+    # Clean up the HTML (remove markdown code blocks if present)
+    html_content = _clean_html_content(html_content)
+    
+    if not html_content:
+        return {
+            "success": False,
+            "error": "No HTML content generated",
+        }
+    
+    # Extract title from HTML
+    title = _extract_title(html_content) or "Generated Website"
+    
+    # Save the website
+    website_dir = WEBSITES_DIR / website_id
+    website_dir.mkdir(parents=True, exist_ok=True)
+    
+    index_file = website_dir / "index.html"
+    index_file.write_text(html_content, encoding="utf-8")
+    
+    # Store session for future edits
+    _website_sessions[website_id] = {
+        "last_response_id": response_id,
+        "title": title,
+        "created_at": datetime.now().isoformat(),
+        "updated_at": datetime.now().isoformat(),
+        "description": description,
+    }
+    
+    # Save to database for persistent storage
+    try:
+        db = get_database()
+        existing = await db.get_website(website_id)
+        if existing:
+            await db.update_website(website_id, {
+                "title": title,
+                "description": description,
+            })
+        else:
+            await db.create_website({
+                "id": website_id,
+                "title": title,
+                "description": description,
+            })
+        logger.info(f"💾 Website saved to database: {website_id}")
+    except Exception as e:
+        logger.warning(f"Failed to save website to database: {e}")
+    
+    # Build the URL (will be served by FastAPI static files)
+    # The actual host will be determined by the server
+    relative_url = f"/websites/{website_id}/"
+    
+    logger.info(f"✅ Website {'updated' if is_edit else 'created'}: {website_id} - {title}")
+    
+    return {
+        "success": True,
+        "website_id": website_id,
+        "url": relative_url,
+        "title": title,
+        "is_edit": is_edit,
+        "message": f"Website {'updated' if is_edit else 'created'} successfully! You can view it at the provided URL.",
+    }
+
+
+def _clean_html_content(html: str) -> str:
+    """Clean up HTML content by removing markdown code blocks if present.
+    
+    Args:
+        html: The raw HTML string from the API.
+        
+    Returns:
+        Cleaned HTML string.
+    """
+    text = html.strip()
+    if text.startswith("```html"):
+        text = text[7:]
+    elif text.startswith("```"):
+        text = text[3:]
+    if text.endswith("```"):
+        text = text[:-3]
+    text = text.strip()
+    
+    # Validate it's HTML
+    if text.startswith("<!DOCTYPE") or text.startswith("<html"):
+        return text
+    
+    return ""
+
+
+def _extract_html_from_response(data: dict) -> Optional[str]:
+    """Extract HTML content from GPT-5.2 Responses API output.
+    
+    Args:
+        data: The API response dictionary.
+        
+    Returns:
+        The HTML string, or None if not found.
+    """
+    output = data.get("output", [])
+    
+    for item in output:
+        if item.get("type") == "message":
+            content = item.get("content", [])
+            for content_item in content:
+                if content_item.get("type") in ("output_text", "text"):
+                    text = content_item.get("text", "")
+                    # Clean up the response - remove markdown code blocks if present
+                    text = text.strip()
+                    if text.startswith("```html"):
+                        text = text[7:]
+                    elif text.startswith("```"):
+                        text = text[3:]
+                    if text.endswith("```"):
+                        text = text[:-3]
+                    text = text.strip()
+                    
+                    # Validate it's HTML
+                    if text.startswith("<!DOCTYPE") or text.startswith("<html"):
+                        return text
+    
+    return None
+
+
+def _extract_title(html: str) -> Optional[str]:
+    """Extract the title from HTML content.
+    
+    Args:
+        html: The HTML string.
+        
+    Returns:
+        The title, or None if not found.
+    """
+    import re
+    match = re.search(r"<title[^>]*>([^<]+)</title>", html, re.IGNORECASE)
+    if match:
+        return match.group(1).strip()
+    return None
+
+
+def get_website_info(website_id: str) -> Optional[dict]:
+    """Get information about a generated website.
+    
+    Args:
+        website_id: The website ID.
+        
+    Returns:
+        Website metadata, or None if not found.
+    """
+    if website_id not in _website_sessions:
+        return None
+    
+    session = _website_sessions[website_id]
+    website_dir = WEBSITES_DIR / website_id
+    
+    if not website_dir.exists():
+        return None
+    
+    return {
+        "id": website_id,
+        "title": session.get("title", "Untitled"),
+        "description": session.get("description", ""),
+        "created_at": session.get("created_at"),
+        "updated_at": session.get("updated_at"),
+        "url": f"/websites/{website_id}/",
+    }
+
+
+def list_websites() -> list[dict]:
+    """List all generated websites.
+    
+    Returns:
+        List of website metadata dictionaries.
+    """
+    websites = []
+    for website_id, session in _website_sessions.items():
+        info = get_website_info(website_id)
+        if info:
+            websites.append(info)
+    return websites
+
+
+def register_website_generator_tool(registry: "ToolRegistry") -> None:
+    """Register the website generator tool with the registry.
+    
+    Args:
+        registry: The tool registry to register with.
+    """
+    from . import ToolInfo
+    
+    tool = ToolInfo(
+        id="generate_website",
+        name="Website Generator",
+        description="Create and edit websites using voice commands",
+        icon="globe",
+        definition=WEBSITE_GENERATOR_TOOL_DEFINITION,
+        handler=generate_website,
+    )
+    
+    registry.register(tool)
+