Update app.py

app.py

@@ -4,7 +4,7 @@ from collections import defaultdict
 import json
 import os
 import re
-from time import time
+import time
 import uuid
 from typing import List, Dict, Any, Optional
 from dataclasses import dataclass
@@ -27,7 +27,6 @@ from openai import AsyncOpenAI, OpenAI
 import pyttsx3
 from rich.console import Console
 
-
 BASE_URL="http://localhost:1234/v1"
 BASE_API_KEY="not-needed"
 BASE_CLIENT = AsyncOpenAI(
@@ -44,15 +43,24 @@ console = Console()
 # --- Configuration ---
 LOCAL_BASE_URL = "http://localhost:1234/v1"
 LOCAL_API_KEY = "not-needed"
-# HuggingFace Spaces configuration
-HF_INFERENCE_URL = "https://api-inference.huggingface.co/models/"
-HF_API_KEY = os.getenv("HF_API_KEY", "")
-
+# Available model options
+MODEL_OPTIONS = {
+    "Local LM Studio": LOCAL_BASE_URL,
+}
 DEFAULT_TEMPERATURE = 0.7
 DEFAULT_MAX_TOKENS = 5000
 console = Console()
 
-#############################################################
+# --- Canvas Artifact Support ---
+@dataclass
+class CanvasArtifact:
+    id: str
+    type: str  # 'code', 'diagram', 'text', 'image'
+    content: str
+    title: str
+    timestamp: float
+    metadata: Dict[str, Any]
+
 @dataclass
 class LLMMessage:
     role: str
@@ -61,7 +69,6 @@ class LLMMessage:
     conversation_id: str = None
     timestamp: float = None
     metadata: Dict[str, Any] = None
-    
     def __post_init__(self):
         if self.message_id is None:
             self.message_id = str(uuid.uuid4())
@@ -75,7 +82,6 @@ class LLMRequest:
     message: LLMMessage
     response_event: str = None
     callback: Callable = None
-    
     def __post_init__(self):
         if self.response_event is None:
             self.response_event = f"llm_response_{self.message.message_id}"
@@ -87,32 +93,27 @@ class LLMResponse:
     success: bool = True
     error: str = None
 
-#############################################################
+# --- Event Manager (copied from your original code or imported) ---
 class EventManager:
     def __init__(self):
         self._handlers = defaultdict(list)
         self._lock = threading.Lock()
-    
     def register(self, event: str, handler: Callable):
         with self._lock:
             self._handlers[event].append(handler)
-    
     def unregister(self, event: str, handler: Callable):
         with self._lock:
             if event in self._handlers and handler in self._handlers[event]:
                 self._handlers[event].remove(handler)
-    
     def raise_event(self, event: str, data: Any):
         with self._lock:
             handlers = self._handlers[event][:]
-        
         for handler in handlers:
             try:
                 handler(data)
             except Exception as e:
                 console.log(f"Error in event handler for {event}: {e}", style="bold red")
 
-
 EVENT_MANAGER = EventManager()
 def RegisterEvent(event: str, handler: Callable):
     EVENT_MANAGER.register(event, handler)
@@ -124,20 +125,6 @@ def UnregisterEvent(event: str, handler: Callable):
     EVENT_MANAGER.unregister(event, handler)
 
 
- #############################################################
-@dataclass
-class CanvasArtifact:
-    id: str
-    type: str  # 'code', 'diagram', 'text', 'image'
-    content: str
-    title: str
-    timestamp: float
-    metadata: Dict[str, Any] = None
-
-    def __post_init__(self):
-        if self.metadata is None:
-            self.metadata = {}
-
 class LLMAgent:
     """Main Agent Driver ! 
     Agent For Multiple messages at once , 
@@ -235,7 +222,7 @@ class LLMAgent:
         """Default generate function if none provided"""
         return await self.openai_generate(messages)
     def create_interface(self):
-        """Create the full LCARS-styled interface without HuggingFace options"""
+        """Create the full LCARS-styled interface"""
         lcars_css = """
         :root {
             --lcars-orange: #FF9900;
@@ -354,11 +341,37 @@ class LLMAgent:
                     with gr.Column(scale=1):
                         # Configuration Panel
                         with gr.Column(elem_classes="lcars-panel"):
- 
-                            pass
+                            gr.Markdown("### 🔧 LM STUDIO CONFIGURATION")
+                            # Local LM Studio settings
+                            with gr.Row():
+                                base_url = gr.Textbox(
+                                    value=BASE_URL,
+                                    label="LM Studio URL",
+                                    elem_classes="lcars-input"
+                                )
+                                api_key = gr.Textbox(
+                                    value=BASE_API_KEY,
+                                    label="API Key",
+                                    type="password",
+                                    elem_classes="lcars-input"
+                                )
+                            with gr.Row():
+                                model_dropdown = gr.Dropdown(
+                                    choices=["Fetching models..."],
+                                    value="Fetching models...",
+                                    label="AI Model",
+                                    elem_classes="lcars-input"
+                                )
+                                fetch_models_btn = gr.Button("📡 Fetch Models", elem_classes="lcars-button")
+                            with gr.Row():
+                                temperature = gr.Slider(0.0, 2.0, value=0.7, label="Temperature")
+                                max_tokens = gr.Slider(128, 8192, value=2000, step=128, label="Max Tokens")
+                            with gr.Row():
+                                update_config_btn = gr.Button("💾 Apply Config", elem_classes="lcars-button")
+                                speech_toggle = gr.Checkbox(value=True, label="🔊 Speech Output")
                         # Canvas Artifacts
                         with gr.Column(elem_classes="lcars-panel"):
-                            gr.Markdown("""### 🎨 CANVAS ARTIFACTS""")
+                            gr.Markdown("### 🎨 CANVAS ARTIFACTS")
                             artifact_display = gr.JSON(label="")
                             with gr.Row():
                                 refresh_artifacts_btn = gr.Button("🔄 Refresh", elem_classes="lcars-button")
@@ -367,8 +380,8 @@ class LLMAgent:
                     with gr.Column(scale=2):
                         # Code Canvas
                         with gr.Accordion("💻 COLLABORATIVE CODE CANVAS", open=False):
-                            code_editor = gr.Code(interactive=True,
-                                value="# Welcome to LCARS Collaborative Canvas\nprint('Hello, Starfleet!')",
+                            code_editor = gr.Code(
+                                value="# Welcome to LCARS Collaborative Canvas\\nprint('Hello, Starfleet!')",
                                 language="python",
                                 lines=15,
                                 label=""
@@ -379,7 +392,7 @@ class LLMAgent:
                                 optimize_btn = gr.Button("⚡ Optimize", elem_classes="lcars-button")
                         # Chat Interface
                         with gr.Column(elem_classes="lcars-panel"):
-                            gr.Markdown("""### 💬 MISSION LOG""")
+                            gr.Markdown("### 💬 MISSION LOG")
                             chatbot = gr.Chatbot(label="", height=300)
                             with gr.Row():
                                 message_input = gr.Textbox(
@@ -400,13 +413,27 @@ class LLMAgent:
                                 clear_chat_btn = gr.Button("🗑️ Clear Chat", elem_classes="lcars-button")
                                 new_session_btn = gr.Button("🆕 New Session", elem_classes="lcars-button")
 
-            # Event handlers are connected here, no change needed
-            async def process_message(message, history, speech_enabled=True):
+            # === EVENT HANDLERS ===
+            async def fetch_models_updated(base_url_val, api_key_val):
+                models = await LLMAgent.fetch_available_models(base_url_val, api_key_val)
+                if models:
+                    return gr.update(choices=models, value=models[0])
+                return gr.update(choices=["No models found"])
+
+            def update_agent_connection(model_id, base_url_val, api_key_val):
+                self.agent = LLMAgent(
+                    model_id=model_id, 
+                    base_url=base_url_val,
+                    api_key=api_key_val,
+                    generate_fn=LLMAgent.openai_generate
+                )
+                return f"✅ Connected to LM Studio: {model_id}"
+
+            async def process_message(message, history, speech_enabled):
                 if not message.strip():
                     return "", history, "Please enter a message"
                 history = history + [[message, None]]
                 try:
-                    # Fixed: Uses the new chat_with_canvas method which includes canvas context
                     response = await self.chat_with_canvas(
                         message, self.current_conversation, include_canvas=True
                     )
@@ -435,19 +462,26 @@ class LLMAgent:
             def new_session():
                 self.clear_conversation(self.current_conversation)
                 self.clear_canvas(self.current_conversation)
-                return [], "# New session started\nprint('Ready!')", "🆕 New session started", []
+                return [], "# New session started\\nprint('Ready!')", "🆕 New session started", []
 
             # Connect events
+            fetch_models_btn.click(fetch_models_updated, 
+                                 inputs=[base_url, api_key],
+                                 outputs=model_dropdown)
+            update_config_btn.click(update_agent_connection,
+                                inputs=[model_dropdown, base_url, api_key],
+                                outputs=status_display)
             send_btn.click(process_message,
-                         inputs=[message_input, chatbot],
+                         inputs=[message_input, chatbot, speech_toggle],
                          outputs=[message_input, chatbot, status_display, artifact_display])
             message_input.submit(process_message,
-                               inputs=[message_input, chatbot],
+                               inputs=[message_input, chatbot, speech_toggle],
                                outputs=[message_input, chatbot, status_display, artifact_display])
             refresh_artifacts_btn.click(get_artifacts, outputs=artifact_display)
             clear_canvas_btn.click(clear_canvas, outputs=[artifact_display, status_display])
             clear_chat_btn.click(clear_chat, outputs=[chatbot, status_display])
             new_session_btn.click(new_session, outputs=[chatbot, code_editor, status_display, artifact_display])
+            interface.load(get_artifacts, outputs=artifact_display)
         return interface
     
     def _register_event_handlers(self):
@@ -949,27 +983,430 @@ class LLMAgent:
                 messages.insert(0, {"role": "system", "content": canvas_context})
 
         return await self.chat(messages)
- 
          
+         
+     
+console = Console()
 
+# --- Canvas Artifact Support ---
+@dataclass
+class CanvasArtifact:
+    id: str
+    type: str  # 'code', 'diagram', 'text', 'image'
+    content: str
+    title: str
+    timestamp: float
+    metadata: Dict[str, Any]
+
+class EnhancedAIAgent:
+    """
+    Wrapper around your AI_Agent that adds canvas/artifact management
+    without modifying the original agent.
+    """
+    def __init__(self, ai_agent):
+        self.agent = ai_agent
+        self.canvas_artifacts: Dict[str, List[CanvasArtifact]] = {}
+        self.max_canvas_artifacts = 50
+        console.log("[bold green]✓ Enhanced AI Agent wrapper initialized[/bold green]")
+    
+    def add_artifact_to_canvas(self, conversation_id: str, content: str, 
+                              artifact_type: str = "code", title: str = None):
+        """Add artifacts to the collaborative canvas"""
+        if conversation_id not in self.canvas_artifacts:
+            self.canvas_artifacts[conversation_id] = []
+        
+        artifact = CanvasArtifact(
+            id=str(uuid.uuid4())[:8],
+            type=artifact_type,
+            content=content,
+            title=title or f"{artifact_type}_{len(self.canvas_artifacts[conversation_id]) + 1}",
+            timestamp=time.time(),
+            metadata={"conversation_id": conversation_id}
+        )
+        
+        self.canvas_artifacts[conversation_id].append(artifact)
+        
+        # Keep only recent artifacts
+        if len(self.canvas_artifacts[conversation_id]) > self.max_canvas_artifacts:
+            self.canvas_artifacts[conversation_id] = self.canvas_artifacts[conversation_id][-self.max_canvas_artifacts:]
+        
+        console.log(f"[green]Added artifact to canvas: {artifact.title}[/green]")
+        return artifact
+    
+    def get_canvas_context(self, conversation_id: str) -> str:
+        """Get formatted canvas context for LLM prompts"""
+        if conversation_id not in self.canvas_artifacts or not self.canvas_artifacts[conversation_id]:
+            return ""
+        
+        context_lines = ["\n=== COLLABORATIVE CANVAS ARTIFACTS ==="]
+        for artifact in self.canvas_artifacts[conversation_id][-10:]:  # Last 10 artifacts
+            context_lines.append(f"\n--- {artifact.title} [{artifact.type.upper()}] ---")
+            preview = artifact.content[:500] + "..." if len(artifact.content) > 500 else artifact.content
+            context_lines.append(preview)
+        
+        return "\n".join(context_lines) + "\n=================================\n"
+    
+    async def chat_with_canvas(self, message: str, conversation_id: str = "default", 
+                              include_canvas: bool = True) -> str:
+        """Enhanced chat that includes canvas context"""
+        # Build context with canvas artifacts if requested
+        full_message = message
+        if include_canvas:
+            canvas_context = self.get_canvas_context(conversation_id)
+            if canvas_context:
+                full_message = f"{canvas_context}\n\nUser Query: {message}"
+        
+        try:
+            # Use your original agent's multi_turn_chat method
+            response = await self.agent.multi_turn_chat(full_message)
+            
+            # Auto-extract and add code artifacts to canvas
+            self._extract_artifacts_to_canvas(response, conversation_id)
+            
+            return response
+            
+        except Exception as e:
+            error_msg = f"Error in chat_with_canvas: {str(e)}"
+            console.log(f"[red]{error_msg}[/red]")
+            return error_msg
+    
+    def _extract_artifacts_to_canvas(self, response: str, conversation_id: str):
+        """Automatically extract code blocks and add to canvas"""
+        # Find all code blocks with optional language specification
+        code_blocks = re.findall(r'```(?:(\w+)\n)?(.*?)```', response, re.DOTALL)
+        for i, (lang, code_block) in enumerate(code_blocks):
+            if len(code_block.strip()) > 10:  # Only add substantial code blocks
+                self.add_artifact_to_canvas(
+                    conversation_id, 
+                    code_block.strip(), 
+                    "code", 
+                    f"code_snippet_{lang or 'unknown'}_{len(self.canvas_artifacts.get(conversation_id, [])) + 1}"
+                )
+    
+    def get_canvas_summary(self, conversation_id: str) -> List[Dict]:
+        """Get summary of canvas artifacts for display"""
+        if conversation_id not in self.canvas_artifacts:
+            return []
+        
+        artifacts = []
+        for artifact in reversed(self.canvas_artifacts[conversation_id]):  # Newest first
+            artifacts.append({
+                "id": artifact.id,
+                "type": artifact.type.upper(),
+                "title": artifact.title,
+                "preview": artifact.content[:100] + "..." if len(artifact.content) > 100 else artifact.content,
+                "timestamp": time.strftime("%H:%M:%S", time.localtime(artifact.timestamp))
+            })
+        
+        return artifacts
+    
+    def get_artifact_by_id(self, conversation_id: str, artifact_id: str) -> Optional[CanvasArtifact]:
+        """Get specific artifact by ID"""
+        if conversation_id not in self.canvas_artifacts:
+            return None
+            
+        for artifact in self.canvas_artifacts[conversation_id]:
+            if artifact.id == artifact_id:
+                return artifact
+        return None
+    
+    def clear_canvas(self, conversation_id: str = "default"):
+        """Clear canvas artifacts"""
+        if conversation_id in self.canvas_artifacts:
+            self.canvas_artifacts[conversation_id] = []
+            console.log(f"[yellow]Cleared canvas: {conversation_id}[/yellow]")
+    
+    def get_latest_code_artifact(self, conversation_id: str) -> Optional[str]:
+        """Get the most recent code artifact content"""
+        if conversation_id not in self.canvas_artifacts:
+            return None
+        
+        for artifact in reversed(self.canvas_artifacts[conversation_id]):
+            if artifact.type == "code":
+                return artifact.content
+        return None
 
 
 console = Console()
 
+# --- LCARS Styled Gradio Interface ---
+class LcarsInterface:
+    def __init__(self):
+        # Local LM Studio only
+        self.use_huggingface = False
+        self.agent = LLMAgent(generate_fn=LLMAgent.openai_generate)
+        self.current_conversation = "default"
+
+    def create_interface(self):
+        """Create the full LCARS-styled interface"""
+        lcars_css = """
+        :root {
+            --lcars-orange: #FF9900;
+            --lcars-red: #FF0033;
+            --lcars-blue: #6699FF;
+            --lcars-purple: #CC99FF;
+            --lcars-pale-blue: #99CCFF;
+            --lcars-black: #000000;
+            --lcars-dark-blue: #3366CC;
+            --lcars-gray: #424242;
+            --lcars-yellow: #FFFF66;
+        }
+        body {
+            background: var(--lcars-black);
+            color: var(--lcars-orange);
+            font-family: 'Antonio', 'LCD', 'Courier New', monospace;
+            margin: 0;
+            padding: 0;
+        }
+        .gradio-container {
+            background: var(--lcars-black) !important;
+            min-height: 100vh;
+        }
+        .lcars-container {
+            background: var(--lcars-black);
+            border: 4px solid var(--lcars-orange);
+            border-radius: 0 30px 0 0;
+            min-height: 100vh;
+            padding: 20px;
+        }
+        .lcars-header {
+            background: linear-gradient(90deg, var(--lcars-red), var(--lcars-orange));
+            padding: 20px 40px;
+            border-radius: 0 60px 0 0;
+            margin: -20px -20px 20px -20px;
+            border-bottom: 6px solid var(--lcars-blue);
+        }
+        .lcars-title {
+            font-size: 2.5em;
+            font-weight: bold;
+            color: var(--lcars-black);
+            margin: 0;
+        }
+        .lcars-subtitle {
+            font-size: 1.2em;
+            color: var(--lcars-black);
+            margin: 10px 0 0 0;
+        }
+        .lcars-panel {
+            background: rgba(66, 66, 66, 0.9);
+            border: 2px solid var(--lcars-orange);
+            border-radius: 0 20px 0 20px;
+            padding: 15px;
+            margin-bottom: 15px;
+        }
+        .lcars-button {
+            background: var(--lcars-orange);
+            color: var(--lcars-black) !important;
+            border: none !important;
+            border-radius: 0 15px 0 15px !important;
+            padding: 10px 20px !important;
+            font-family: inherit !important;
+            font-weight: bold !important;
+            margin: 5px !important;
+        }
+        .lcars-button:hover {
+            background: var(--lcars-red) !important;
+        }
+        .lcars-input {
+            background: var(--lcars-black) !important;
+            color: var(--lcars-orange) !important;
+            border: 2px solid var(--lcars-blue) !important;
+            border-radius: 0 10px 0 10px !important;
+            padding: 10px !important;
+        }
+        .lcars-chatbot {
+            background: var(--lcars-black) !important;
+            border: 2px solid var(--lcars-purple) !important;
+            border-radius: 0 15px 0 15px !important;
+        }
+        .status-indicator {
+            display: inline-block;
+            width: 12px;
+            height: 12px;
+            border-radius: 50%;
+            background: var(--lcars-red);
+            margin-right: 8px;
+        }
+        .status-online {
+            background: var(--lcars-blue);
+            animation: pulse 2s infinite;
+        }
+        @keyframes pulse {
+            0% { opacity: 1; }
+            50% { opacity: 0.5; }
+            100% { opacity: 1; }
+        }
+        """
+        with gr.Blocks(css=lcars_css, theme=gr.themes.Default(), title="LCARS Terminal") as interface:
+            with gr.Column(elem_classes="lcars-container"):
+                # Header
+                with gr.Row(elem_classes="lcars-header"):
+                    gr.Markdown("""
+                    <div style="text-align: center; width: 100%;">
+                        <div class="lcars-title">🚀 LCARS TERMINAL</div>
+                        <div class="lcars-subtitle">STARFLEET AI DEVELOPMENT CONSOLE</div>
+                        <div style="margin-top: 10px;">
+                            <span class="status-indicator status-online"></span>
+                            <span style="color: var(--lcars-black); font-weight: bold;">SYSTEM ONLINE</span>
+                        </div>
+                    </div>
+                    """)
+                # Main Content
+                with gr.Row():
+                    # Left Sidebar
+                    with gr.Column(scale=1):
+                        # Configuration Panel
+                        with gr.Column(elem_classes="lcars-panel"):
+                            gr.Markdown("### 🔧 LM STUDIO CONFIGURATION")
+                            # Local LM Studio settings
+                            with gr.Row():
+                                base_url = gr.Textbox(
+                                    value=LOCAL_BASE_URL,
+                                    label="LM Studio URL",
+                                    elem_classes="lcars-input"
+                                )
+                                api_key = gr.Textbox(
+                                    value=LOCAL_API_KEY,
+                                    label="API Key",
+                                    type="password",
+                                    elem_classes="lcars-input"
+                                )
+                            with gr.Row():
+                                model_dropdown = gr.Dropdown(
+                                    choices=["Fetching models..."],
+                                    value="Fetching models...",
+                                    label="AI Model",
+                                    elem_classes="lcars-input"
+                                )
+                                fetch_models_btn = gr.Button("📡 Fetch Models", elem_classes="lcars-button")
+                            with gr.Row():
+                                temperature = gr.Slider(0.0, 2.0, value=0.7, label="Temperature")
+                                max_tokens = gr.Slider(128, 8192, value=2000, step=128, label="Max Tokens")
+                            with gr.Row():
+                                update_config_btn = gr.Button("💾 Apply Config", elem_classes="lcars-button")
+                                speech_toggle = gr.Checkbox(value=True, label="🔊 Speech Output")
+                        # Canvas Artifacts
+                        with gr.Column(elem_classes="lcars-panel"):
+                            gr.Markdown("### 🎨 CANVAS ARTIFACTS")
+                            artifact_display = gr.JSON(label="")
+                            with gr.Row():
+                                refresh_artifacts_btn = gr.Button("🔄 Refresh", elem_classes="lcars-button")
+                                clear_canvas_btn = gr.Button("🗑️ Clear Canvas", elem_classes="lcars-button")
+                    # Main Content Area
+                    with gr.Column(scale=2):
+                        # Code Canvas
+                        with gr.Accordion("💻 COLLABORATIVE CODE CANVAS", open=False):
+                            code_editor = gr.Code(
+                                value="# Welcome to LCARS Collaborative Canvas\\nprint('Hello, Starfleet!')",
+                                language="python",
+                                lines=15,
+                                label=""
+                            )
+                            with gr.Row():
+                                load_to_chat_btn = gr.Button("💬 Discuss Code", elem_classes="lcars-button")
+                                analyze_btn = gr.Button("🔍 Analyze", elem_classes="lcars-button")
+                                optimize_btn = gr.Button("⚡ Optimize", elem_classes="lcars-button")
+                        # Chat Interface
+                        with gr.Column(elem_classes="lcars-panel"):
+                            gr.Markdown("### 💬 MISSION LOG")
+                            chatbot = gr.Chatbot(label="", height=300)
+                            with gr.Row():
+                                message_input = gr.Textbox(
+                                    placeholder="Enter your command or query...",
+                                    show_label=False,
+                                    lines=2,
+                                    scale=4
+                                )
+                                send_btn = gr.Button("🚀 SEND", elem_classes="lcars-button", scale=1)
+                        # Status
+                        with gr.Row():
+                            status_display = gr.Textbox(
+                                value="LCARS terminal operational. Awaiting commands.",
+                                label="Status",
+                                max_lines=2
+                            )
+                            with gr.Column(scale=0):
+                                clear_chat_btn = gr.Button("🗑️ Clear Chat", elem_classes="lcars-button")
+                                new_session_btn = gr.Button("🆕 New Session", elem_classes="lcars-button")
+
+            # === EVENT HANDLERS ===
+            async def fetch_models_updated(base_url_val, api_key_val):
+                models = await LLMAgent.fetch_available_models(base_url_val, api_key_val)
+                if models:
+                    return gr.update(choices=models, value=models[0])
+                return gr.update(choices=["No models found"])
+
+            def update_agent_connection(model_id, base_url_val, api_key_val):
+                self.agent = LLMAgent(
+                    model_id=model_id, 
+                    base_url=base_url_val,
+                    api_key=api_key_val,
+                    generate_fn=LLMAgent.openai_generate
+                )
+                return f"✅ Connected to LM Studio: {model_id}"
+
+            async def process_message(message, history, speech_enabled):
+                if not message.strip():
+                    return "", history, "Please enter a message"
+                history = history + [[message, None]]
+                try:
+                    response = await self.agent.chat_with_canvas(
+                        message, self.current_conversation, include_canvas=True
+                    )
+                    history[-1][1] = response
+                    if speech_enabled and self.agent.speech_enabled:
+                        self.agent.speak(response)
+                    artifacts = self.agent.get_canvas_summary(self.current_conversation)
+                    status = f"✅ Response received. Canvas artifacts: {len(artifacts)}"
+                    return "", history, status, artifacts
+                except Exception as e:
+                    error_msg = f"❌ Error: {str(e)}"
+                    history[-1][1] = error_msg
+                    return "", history, error_msg, self.agent.get_canvas_summary(self.current_conversation)
 
+            def get_artifacts():
+                return self.agent.get_canvas_summary(self.current_conversation)
+
+            def clear_canvas():
+                self.agent.clear_canvas(self.current_conversation)
+                return [], "✅ Canvas cleared"
+
+            def clear_chat():
+                self.agent.clear_conversation(self.current_conversation)
+                return [], "✅ Chat cleared"
+
+            def new_session():
+                self.agent.clear_conversation(self.current_conversation)
+                self.agent.clear_canvas(self.current_conversation)
+                return [], "# New session started\\nprint('Ready!')", "🆕 New session started", []
+
+            # Connect events
+            fetch_models_btn.click(fetch_models_updated, 
+                                 inputs=[base_url, api_key],
+                                 outputs=model_dropdown)
+            update_config_btn.click(update_agent_connection,
+                                inputs=[model_dropdown, base_url, api_key],
+                                outputs=status_display)
+            send_btn.click(process_message,
+                         inputs=[message_input, chatbot, speech_toggle],
+                         outputs=[message_input, chatbot, status_display, artifact_display])
+            message_input.submit(process_message,
+                               inputs=[message_input, chatbot, speech_toggle],
+                               outputs=[message_input, chatbot, status_display, artifact_display])
+            refresh_artifacts_btn.click(get_artifacts, outputs=artifact_display)
+            clear_canvas_btn.click(clear_canvas, outputs=[artifact_display, status_display])
+            clear_chat_btn.click(clear_chat, outputs=[chatbot, status_display])
+            new_session_btn.click(new_session, outputs=[chatbot, code_editor, status_display, artifact_display])
+            interface.load(get_artifacts, outputs=artifact_display)
+        return interface
 
 # --- Main Application ---
 def main():
     console.log("[bold blue]🚀 Starting LCARS Terminal...[/bold blue]")
-    is_space = os.getenv('SPACE_ID') is not None
-    if is_space:
-        console.log("[green]🌐 Detected HuggingFace Space[/green]")
-    else:
-        console.log("[blue]💻 Running locally[/blue]")
-    interface = LLMAgent()
+    interface = LcarsInterface()
     demo = interface.create_interface()
     demo.launch(
-        share=is_space
+        share=False
     )
 
 if __name__ == "__main__":