Cleanup

app.py

@@ -1,112 +1,121 @@
 """
 GCP - Game Context Protocol
-Build 3D game scenes with natural language
+Build 3D game scenes with natural language using AI.
+
+Architecture:
+- Gradio: Chat interface and static file serving
+- FastAPI: Scene API and MCP tools (local dev only)
+- Three.js: 3D rendering in embedded iframe
+- OpenAI: Natural language processing with function calling
 """
 import os
 import json
-import gradio as gr
-import threading
-import uvicorn
 import time
-import requests
-from pathlib import Path
-from backend.main import app as fastapi_app
-
-# Set up static paths for Gradio to serve model files
-# Files are accessible at /gradio_api/file=models/<filename>
-MODELS_DIR = Path(__file__).parent / "models"
-gr.set_static_paths(paths=["models"])  # Relative path from app.py
-
-# Get base URLs from environment
-# Auto-detect HF Spaces environment
-FASTAPI_INTERNAL = "http://localhost:8000"  # Always use localhost for internal calls
+import gradio as gr
+
+# Static file serving for 3D models (GLB files)
+# Accessible at /gradio_api/file=models/<path>
+gr.set_static_paths(paths=["models"])
+
+# =============================================================================
+# Environment Configuration
+# =============================================================================
 IS_HF_SPACES = bool(os.getenv("SPACE_ID"))
+FASTAPI_INTERNAL = "http://localhost:8000"
+FASTAPI_URL = ""  # Relative URLs for HF Spaces
+
 if IS_HF_SPACES:
-    # Running on HF Spaces
-    # Use relative URLs for iframe (browser will resolve against current origin)
-    # This avoids CORS/auth issues with cross-origin requests
-    FASTAPI_URL = ""  # Empty = relative URLs like "/view/scene/welcome"
-    space_host = os.getenv("SPACE_HOST", "")
-    SPACE_URL = f"https://{space_host}" if space_host else ""
-    print(f"🌐 HF Spaces detected: SPACE_ID={os.getenv('SPACE_ID')}, SPACE_HOST={space_host}")
-    print(f"   Using relative URLs for iframe")
-    print(f"   FASTAPI_INTERNAL={FASTAPI_INTERNAL}")
+    print(f"🌐 HF Spaces: {os.getenv('SPACE_ID')}")
 else:
-    # Local development - FastAPI on 8000, Gradio on 7860
-    SPACE_URL = os.getenv("SPACE_URL", "http://localhost:7860")
+    # Local dev: FastAPI on 8000, Gradio on 7860
     FASTAPI_URL = os.getenv("FASTAPI_URL", "http://localhost:8000")
     FASTAPI_INTERNAL = FASTAPI_URL
-    print(f"💻 Local dev mode: FASTAPI_URL={FASTAPI_URL}")
-BASE_URL = SPACE_URL  # For display in UI
+    print(f"💻 Local dev: {FASTAPI_URL}")
 
-# Global state for current scene
+# Global state
 current_scene_id = None
-selected_object_id = None  # Track currently looked-at object (FPS mode)
-
-
-def add_cache_buster(url):
-    """Add timestamp to URL to force iframe reload"""
-    import time
-    timestamp = int(time.time() * 1000)
-    separator = "&" if "?" in url else "?"
-    return f"{url}{separator}t={timestamp}"
-
-
-def wait_for_fastapi(max_retries=30, retry_interval=1):
-    """
-    Wait for FastAPI to be ready with health check.
-
-    Args:
-        max_retries: Maximum number of health check attempts
-        retry_interval: Seconds to wait between retries
-
-    Returns:
-        True if FastAPI is ready, False otherwise
-    """
-    print("\n" + "="*60)
-    print("⏳ Waiting for FastAPI/MCP server to be ready...")
-    print("="*60)
-
-    for i in range(max_retries):
-        try:
-            response = requests.get(f"{FASTAPI_INTERNAL}/health", timeout=2)
-            if response.status_code == 200:
-                data = response.json()
-                print(f"\n✅ FastAPI is ready! Service: {data.get('service', 'Unknown')}")
-                print(f"   Version: {data.get('version', 'Unknown')}")
-                print(f"   Status: {data.get('status', 'Unknown')}")
-                print("="*60 + "\n")
-                return True
-        except (requests.ConnectionError, requests.Timeout):
-            if i < max_retries - 1:
-                print(f"   Attempt {i+1}/{max_retries}: FastAPI not ready yet, retrying in {retry_interval}s...")
-                time.sleep(retry_interval)
-            else:
-                print(f"\n⚠️  FastAPI health check failed after {max_retries} attempts")
-                print("   The server might still start, but there could be issues.")
-                print("="*60 + "\n")
-                return False
-        except Exception as e:
-            print(f"   Unexpected error during health check: {e}")
-            time.sleep(retry_interval)
-
-    return False
-
-
-# Start FastAPI/MCP server in background (only for local dev)
-# On HF Spaces, FastAPI will be mounted on Gradio's port
+current_provider = "openai"  # "openai" or "gemini"
+
+
+def _get_toast_message(action_type: str, data: dict) -> str:
+    """Generate user-friendly toast message for an action."""
+    # Simple static messages
+    STATIC_MESSAGES = {
+        "removeObject": "Object removed",
+        "setLighting": "Lighting updated",
+        "updateMaterial": "Material updated",
+        "removeLight": "Light removed",
+        "updateLight": "Light updated",
+        "setBackground": "Background updated",
+        "setFog": "Fog updated",
+        "removeSkybox": "Skybox removed",
+        "removeParticles": "Particles removed",
+        "removeUIElement": "UI element removed",
+    }
+    if action_type in STATIC_MESSAGES:
+        return STATIC_MESSAGES[action_type]
+
+    # Dynamic messages with data
+    if action_type == "addObject":
+        return f"Added {data.get('type', 'object')}"
+    if action_type == "setControlMode":
+        return f"Switched to {data.get('mode', '').upper()} mode"
+    if action_type == "addLight":
+        return f"Added light: {data.get('name', 'Light')}"
+    if action_type == "setPlayerSpeed":
+        return f"Speed: {data.get('walk_speed', 5)} m/s"
+    if action_type == "setJumpForce":
+        return f"Jump: {data.get('jump_force', 5)} m/s"
+    if action_type == "setGravity":
+        return f"Gravity: {data.get('gravity', -9.82)} m/s²"
+    if action_type == "setCameraFov":
+        return f"FOV: {data.get('fov', 75)}°"
+    if action_type == "setMouseSensitivity":
+        return f"Sensitivity: {data.get('sensitivity', 0.002)}"
+    if action_type == "setPlayerDimensions":
+        return f"Height: {data.get('height', 1.7)}m"
+    if action_type == "addSkybox":
+        return f"Skybox: {data.get('preset', 'custom')}"
+    if action_type == "addParticles":
+        return f"Particles: {data.get('preset', 'effect')}"
+    if action_type == "renderText":
+        return f"Text: {data.get('text', '')[:15]}..."
+    if action_type == "renderBar":
+        return f"Bar: {data.get('label', 'Bar')}"
+    if action_type == "updateToonMaterial":
+        return "Toon " + ("on" if data.get("enabled", True) else "off")
+    if action_type == "addBrick":
+        return f"Added {data.get('brick_type', 'brick').replace('_', ' ')}"
+
+    return action_type  # Fallback to action name
+
+
+# =============================================================================
+# FastAPI Server (Local Dev Only)
+# =============================================================================
 if not IS_HF_SPACES:
-    def start_fastapi():
-        print("\n" + "="*60)
-        print("Starting FastAPI/MCP server on port 8000...")
-        print("="*60 + "\n")
-        uvicorn.run(fastapi_app, host="0.0.0.0", port=8000, log_level="info")
-
-    fastapi_thread = threading.Thread(target=start_fastapi, daemon=True)
-    fastapi_thread.start()
+    import threading
+    import uvicorn
+    import requests
+    from backend.main import app as fastapi_app
+
+    def _wait_for_fastapi():
+        """Wait for FastAPI health check."""
+        print("⏳ Waiting for FastAPI...")
+        for _ in range(30):
+            try:
+                if requests.get(f"{FASTAPI_INTERNAL}/health", timeout=2).ok:
+                    print("✅ FastAPI ready")
+                    return
+            except:
+                time.sleep(1)
+        print("⚠️ FastAPI timeout")
 
-    # Wait for FastAPI to be ready
-    wait_for_fastapi()
+    threading.Thread(
+        target=lambda: uvicorn.run(fastapi_app, host="0.0.0.0", port=8000, log_level="warning"),
+        daemon=True
+    ).start()
+    _wait_for_fastapi()
 
 
 def get_viewer_html(scene_id="welcome"):
@@ -153,20 +162,22 @@ def create_default_scene():
         return None
 
 
-# Initialize the GPT chat client
-gpt_client = None
+# Initialize the chat client
+chat_client = None
 
-def get_gpt_client():
-    """Get or create the GPT chat client"""
-    global gpt_client, current_scene_id
-    if gpt_client is None or gpt_client.scene_id != current_scene_id:
+def get_chat_client(provider: str = "openai"):
+    """Get or create the chat client with specified provider"""
+    global chat_client, current_scene_id, current_provider
+    # Recreate client if scene or provider changed
+    if chat_client is None or chat_client.scene_id != current_scene_id or chat_client.provider != provider:
         from chat_client import GCPChatClient
-        gpt_client = GCPChatClient(scene_id=current_scene_id, base_url=FASTAPI_URL)
-    return gpt_client
+        chat_client = GCPChatClient(scene_id=current_scene_id, base_url=FASTAPI_URL, provider=provider)
+        current_provider = provider
+    return chat_client
 
 
-def chat_response(message, history, crosshair_position=None):
-    """Handle chat messages using GPT with tool calling"""
+def chat_response(message, history, crosshair_position=None, provider="openai"):
+    """Handle chat messages using LLM with tool calling"""
     global current_scene_id
 
     # Handle help command locally (no need for LLM)
@@ -194,10 +205,12 @@ I'm an AI assistant that can help you build 3D scenes using natural language.
 - Press C in viewer to toggle FPS/Orbit camera
 - WASD to move, Space to jump in FPS mode
 - Click in viewer to enable mouse-look
-""", None
+
+**LLM Provider:** Currently using {provider.upper()}
+""".format(provider=provider), None
 
     try:
-        client = get_gpt_client()
+        client = get_chat_client(provider)
         # Pass crosshair position to chat client for context-aware object placement
         response, action_data = client.chat(message, crosshair_position=crosshair_position)
         return response, action_data
@@ -406,17 +419,25 @@ with gr.Blocks(title="GCP - Game Context Protocol") as demo:
         with gr.Column(elem_id="chat-column", scale=1, min_width=350):
             gr.Markdown("### 🎮 GCP - Game Context Protocol")
             chatbot = gr.Chatbot(
-                height=500,  # Taller to fill vertical space
+                height=450,  # Slightly shorter to make room for provider dropdown
                 show_label=False,
                 elem_id="chatbot",
-                # Gradio 6: type="messages" is now the default, removed
-            )
-            msg = gr.Textbox(
-                placeholder="'add a red cube' • 'set lighting to night' • 'help'",
-                show_label=False,
-                container=False,
-                elem_id="chat-input"
             )
+            with gr.Row():
+                msg = gr.Textbox(
+                    placeholder="'add a red cube' • 'set lighting to night' • 'help'",
+                    show_label=False,
+                    container=False,
+                    elem_id="chat-input",
+                    scale=4
+                )
+                provider_dropdown = gr.Dropdown(
+                    choices=["openai", "gemini"],
+                    value="openai",
+                    label="LLM",
+                    scale=1,
+                    min_width=100
+                )
 
         # Right column: 3D Viewer (scale=3 = ~75% width)
         with gr.Column(elem_id="viewer-column", scale=3):
@@ -511,8 +532,8 @@ with gr.Blocks(title="GCP - Game Context Protocol") as demo:
         history.append({"role": "user", "content": user_message})
         return "", history
 
-    def bot(history, crosshair_position):
-        """Generate bot response"""
+    def bot(history, crosshair_position, provider):
+        """Generate bot response using selected LLM provider"""
         # Gradio 6: content can be a string or list of content blocks
         content = history[-1]["content"]
         if isinstance(content, list):
@@ -532,8 +553,8 @@ with gr.Blocks(title="GCP - Game Context Protocol") as demo:
             except:
                 pass
 
-        # Process command with crosshair context
-        bot_message, action_result = chat_response(user_message, [], crosshair_pos_dict)
+        # Process command with crosshair context and selected provider
+        bot_message, action_result = chat_response(user_message, [], crosshair_pos_dict, provider)
         history.append({"role": "assistant", "content": bot_message})
 
         # Handle action_result
@@ -547,99 +568,11 @@ with gr.Blocks(title="GCP - Game Context Protocol") as demo:
                 # Full reload: update iframe src
                 viewer_html = f'<div id="viewer-container" style="width:100%; min-height:500px; height:70vh;"><iframe src="{action_result["url"]}" style="width:100%; height:100%; border:none;"></iframe></div>'
 
-            elif action_type in ["addObject", "removeObject", "setLighting", "setControlMode",
-                                  "updateMaterial", "addLight", "removeLight", "updateLight",
-                                  "setBackground", "setFog",
-                                  # Player tools
-                                  "setPlayerSpeed", "setJumpForce", "setGravity",
-                                  "setCameraFov", "setMouseSensitivity", "setPlayerDimensions",
-                                  # Environment tools
-                                  "addSkybox", "removeSkybox", "addParticles", "removeParticles",
-                                  # UI tools
-                                  "renderText", "renderBar", "removeUIElement",
-                                  # Toon shading
-                                  "updateToonMaterial",
-                                  # Brick blocks
-                                  "addBrick"]:
-                # Build action JSON for the JavaScript watcher
-                import json
-                import time
-
-                # Determine toast message based on action type
-                toast_message = ""
-                if action_type == "addObject":
-                    obj_type = action_result["data"].get("type", "object")
-                    toast_message = f"Added {obj_type} to scene"
-                elif action_type == "removeObject":
-                    toast_message = "Object removed"
-                elif action_type == "setLighting":
-                    toast_message = "Lighting updated"
-                elif action_type == "setControlMode":
-                    mode = action_result["data"].get("mode", "")
-                    toast_message = f"Switched to {mode.upper()} mode"
-                elif action_type == "updateMaterial":
-                    toast_message = "Material updated"
-                elif action_type == "addLight":
-                    light_name = action_result["data"].get("name", "Light")
-                    toast_message = f"Added light: {light_name}"
-                elif action_type == "removeLight":
-                    toast_message = "Light removed"
-                elif action_type == "updateLight":
-                    toast_message = "Light updated"
-                elif action_type == "setBackground":
-                    toast_message = "Background updated"
-                elif action_type == "setFog":
-                    toast_message = "Fog updated"
-                # Player tool toast messages
-                elif action_type == "setPlayerSpeed":
-                    speed = action_result["data"].get("walk_speed", 5)
-                    toast_message = f"Player speed: {speed} m/s"
-                elif action_type == "setJumpForce":
-                    force = action_result["data"].get("jump_force", 5)
-                    toast_message = f"Jump force: {force} m/s"
-                elif action_type == "setGravity":
-                    gravity = action_result["data"].get("gravity", -9.82)
-                    toast_message = f"Gravity: {gravity} m/s²"
-                elif action_type == "setCameraFov":
-                    fov = action_result["data"].get("fov", 75)
-                    toast_message = f"Camera FOV: {fov}°"
-                elif action_type == "setMouseSensitivity":
-                    sens = action_result["data"].get("sensitivity", 0.002)
-                    toast_message = f"Mouse sensitivity: {sens}"
-                elif action_type == "setPlayerDimensions":
-                    height = action_result["data"].get("height", 1.7)
-                    toast_message = f"Player height: {height}m"
-                # Environment tool toast messages
-                elif action_type == "addSkybox":
-                    preset = action_result["data"].get("preset", "custom")
-                    toast_message = f"Skybox added: {preset}"
-                elif action_type == "removeSkybox":
-                    toast_message = "Skybox removed"
-                elif action_type == "addParticles":
-                    preset = action_result["data"].get("preset", "effect")
-                    toast_message = f"Particles added: {preset}"
-                elif action_type == "removeParticles":
-                    toast_message = "Particles removed"
-                # UI tool toast messages
-                elif action_type == "renderText":
-                    text = action_result["data"].get("text", "")[:20]
-                    toast_message = f"Text rendered: {text}..."
-                elif action_type == "renderBar":
-                    label = action_result["data"].get("label", "Bar")
-                    toast_message = f"Bar rendered: {label}"
-                elif action_type == "removeUIElement":
-                    toast_message = "UI element removed"
-                # Toon shading toast
-                elif action_type == "updateToonMaterial":
-                    enabled = action_result["data"].get("enabled", True)
-                    toast_message = "Toon shading " + ("enabled" if enabled else "disabled")
-                # Brick toast
-                elif action_type == "addBrick":
-                    brick_type = action_result["data"].get("brick_type", "brick")
-                    toast_message = f"Added {brick_type.replace('_', ' ')}"
-
-                # Create JSON payload for the .then() JavaScript handler
-                # Include timestamp to ensure Gradio detects change even for repeated actions
+            else:
+                # Generate toast message for the action
+                toast_message = _get_toast_message(action_type, action_result.get("data", {}))
+
+                # Send action to viewer via postMessage
                 action_json = json.dumps({
                     "action": action_result["action"],
                     "data": action_result["data"],
@@ -689,7 +622,7 @@ with gr.Blocks(title="GCP - Game Context Protocol") as demo:
         queue=False
     ).then(
         bot,
-        [chatbot, crosshair_pos],
+        [chatbot, crosshair_pos, provider_dropdown],
         [chatbot, viewer, action_data]
     )
 

chat_client.py

@@ -1,12 +1,16 @@
 """
-GPT-powered Chat Client for GCP (Game Context Protocol)
+Multi-LLM Chat Client for GCP (Game Context Protocol)
 
-This module provides an intelligent chat interface that uses OpenAI's GPT
-with function calling to interact with the GCP tools.
+This module provides an intelligent chat interface that uses either OpenAI GPT
+or Google Gemini with function calling to interact with the GCP tools.
+
+Supports:
+- OpenAI GPT-4o-mini (default)
+- Google Gemini 2.0 Flash
 """
 import os
 import json
-from typing import Optional, Dict, Any, List
+from typing import Optional, Dict, Any, List, Literal
 
 # Load .env file if present
 from dotenv import load_dotenv
@@ -14,6 +18,16 @@ load_dotenv()
 
 from openai import OpenAI
 
+# Gemini import (optional - may not be installed)
+try:
+    import google.generativeai as genai
+    GEMINI_AVAILABLE = True
+except ImportError:
+    GEMINI_AVAILABLE = False
+    genai = None
+
+LLMProvider = Literal["openai", "gemini"]
+
 # Import GCP tools
 from backend.tools.scene_tools import (
     create_game_scene,
@@ -542,15 +556,85 @@ TOOLS = [
 ]
 
 
-class GCPChatClient:
-    """GPT-powered chat client for GCP"""
+def _convert_schema_for_gemini(schema: Dict) -> Dict:
+    """Convert OpenAI JSON schema to Gemini format."""
+    if not schema:
+        return {}
 
-    def __init__(self, scene_id: str, base_url: str = "http://localhost:8000"):
-        self.client = OpenAI()  # Uses OPENAI_API_KEY env var
+    result = {}
+
+    # Convert type
+    if "type" in schema:
+        type_map = {
+            "object": "OBJECT",
+            "string": "STRING",
+            "number": "NUMBER",
+            "integer": "INTEGER",
+            "boolean": "BOOLEAN",
+            "array": "ARRAY"
+        }
+        result["type"] = type_map.get(schema["type"], "STRING")
+
+    # Convert properties
+    if "properties" in schema:
+        result["properties"] = {}
+        for key, val in schema["properties"].items():
+            result["properties"][key] = _convert_schema_for_gemini(val)
+
+    # Copy other fields
+    if "description" in schema:
+        result["description"] = schema["description"]
+    if "enum" in schema:
+        result["enum"] = schema["enum"]
+    if "required" in schema:
+        result["required"] = schema["required"]
+    if "items" in schema:
+        result["items"] = _convert_schema_for_gemini(schema["items"])
+
+    return result
+
+
+def _convert_tools_to_gemini() -> List[Dict]:
+    """Convert OpenAI tool format to Gemini function declarations."""
+    gemini_tools = []
+    for tool in TOOLS:
+        func = tool["function"]
+        gemini_tools.append({
+            "name": func["name"],
+            "description": func["description"],
+            "parameters": _convert_schema_for_gemini(func["parameters"])
+        })
+    return gemini_tools
+
+
+class GCPChatClient:
+    """Multi-LLM chat client for GCP - supports OpenAI and Gemini"""
+
+    def __init__(
+        self,
+        scene_id: str,
+        base_url: str = "http://localhost:8000",
+        provider: LLMProvider = "openai"
+    ):
         self.scene_id = scene_id
         self.base_url = base_url
+        self.provider = provider
         self.conversation_history: List[Dict[str, Any]] = []
 
+        # Initialize the appropriate client
+        if provider == "gemini":
+            if not GEMINI_AVAILABLE:
+                raise ImportError("google-generativeai not installed. Run: pip install google-generativeai")
+            genai.configure(api_key=os.getenv("GOOGLE_API_KEY") or os.getenv("GEMINI_API_KEY"))
+            self.gemini_model = genai.GenerativeModel(
+                model_name="gemini-2.0-flash",
+                tools=_convert_tools_to_gemini()
+            )
+            self.client = None
+        else:
+            self.client = OpenAI()  # Uses OPENAI_API_KEY env var
+            self.gemini_model = None
+
         # System prompt
         self.system_prompt = f"""You are a helpful assistant for GCP (Game Context Protocol), a 3D scene building system.
 
@@ -841,12 +925,20 @@ The y coordinate should be adjusted based on object size (e.g., y=0.5 for a cube
 
 If the user DOES specify a position (e.g., "add a cube at 0, 0, 0"), use their specified position instead."""
 
-        # Build messages with system prompt
-        messages = [{"role": "system", "content": system_prompt}] + self.conversation_history
-
         # Track actions for frontend
         actions = []
 
+        # Route to appropriate provider
+        if self.provider == "gemini":
+            return self._chat_gemini(user_message, system_prompt, actions)
+        else:
+            return self._chat_openai(user_message, system_prompt, actions)
+
+    def _chat_openai(self, user_message: str, system_prompt: str, actions: List) -> tuple[str, Optional[Dict[str, Any]]]:
+        """Handle chat with OpenAI GPT"""
+        # Build messages with system prompt
+        messages = [{"role": "system", "content": system_prompt}] + self.conversation_history
+
         # Call GPT with tools
         while True:
             response = self.client.chat.completions.create(
@@ -919,6 +1011,72 @@ If the user DOES specify a position (e.g., "add a cube at 0, 0, 0"), use their s
 
                 return final_response, action_data
 
+    def _chat_gemini(self, user_message: str, system_prompt: str, actions: List) -> tuple[str, Optional[Dict[str, Any]]]:
+        """Handle chat with Google Gemini"""
+        # Start a chat session with Gemini
+        chat = self.gemini_model.start_chat(history=[])
+
+        # Combine system prompt with user message for first turn
+        full_prompt = f"{system_prompt}\n\nUser: {user_message}"
+
+        while True:
+            response = chat.send_message(full_prompt)
+
+            # Check for function calls
+            function_calls = []
+            for part in response.parts:
+                if hasattr(part, 'function_call') and part.function_call:
+                    function_calls.append(part.function_call)
+
+            if function_calls:
+                # Execute each function call
+                function_responses = []
+                for fc in function_calls:
+                    function_name = fc.name
+                    function_args = dict(fc.args)
+
+                    # Execute the tool
+                    try:
+                        result = self.execute_tool(function_name, function_args)
+                        actions.append({
+                            "tool": function_name,
+                            "args": function_args,
+                            "result": result
+                        })
+                        function_responses.append(genai.protos.Part(
+                            function_response=genai.protos.FunctionResponse(
+                                name=function_name,
+                                response={"result": result}
+                            )
+                        ))
+                    except Exception as e:
+                        function_responses.append(genai.protos.Part(
+                            function_response=genai.protos.FunctionResponse(
+                                name=function_name,
+                                response={"error": str(e)}
+                            )
+                        ))
+
+                # Send function results back to Gemini
+                full_prompt = function_responses
+            else:
+                # No function calls, extract text response
+                final_response = response.text or "Done!"
+
+                # Add to conversation history
+                self.conversation_history.append({
+                    "role": "assistant",
+                    "content": final_response
+                })
+
+                # Build action data for frontend
+                action_data = None
+                if actions:
+                    last_action = actions[-1]
+                    action_data = self._build_frontend_action(last_action)
+
+                return final_response, action_data
+
     def _build_frontend_action(self, action: Dict[str, Any]) -> Optional[Dict[str, Any]]:
         """Convert tool result to frontend action"""
         tool = action["tool"]
@@ -1034,6 +1192,10 @@ If the user DOES specify a position (e.g., "add a cube at 0, 0, 0"), use their s
 
 
 # Convenience function for simple usage
-def create_chat_client(scene_id: str = "welcome", base_url: str = "http://localhost:8000") -> GCPChatClient:
-    """Create a new GCP chat client"""
-    return GCPChatClient(scene_id, base_url)
+def create_chat_client(
+    scene_id: str = "welcome",
+    base_url: str = "http://localhost:8000",
+    provider: LLMProvider = "openai"
+) -> GCPChatClient:
+    """Create a new GCP chat client with specified LLM provider"""
+    return GCPChatClient(scene_id, base_url, provider)

requirements.txt

@@ -11,4 +11,5 @@ gradio
 
 # LLM
 openai
+google-generativeai
 python-dotenv