Update app.py

app.py

@@ -1,5 +1,4 @@
 # File: enhanced_gradio_interface.py
-
 import asyncio
 from collections import defaultdict
 import json
@@ -7,46 +6,59 @@ import os
 import re
 import time
 import uuid
-from typing import List, Dict, Any, Optional
+from typing import List, Dict, Any, Optional, Callable
 from dataclasses import dataclass
-from threading import Lock
-import threading
-import json
-import os
+from threading import Lock, Event, Thread
 import queue
 import traceback
-import uuid
-from typing import Coroutine, Dict, List, Any, Optional, Callable
-from dataclasses import dataclass
 from queue import Queue, Empty
-from threading import Lock, Event, Thread
-import threading
 from concurrent.futures import ThreadPoolExecutor
-import time
-
 import gradio as gr
 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(
-    base_url=BASE_URL,
-    api_key=BASE_API_KEY
-) # Global state for client
-BASEMODEL_ID = "leroydyer/qwen/qwen3-0.6b-q4_k_m.gguf"  # Global state for selected model ID
-CLIENT =OpenAI(
-    base_url=BASE_URL,
-    api_key=BASE_API_KEY
-) # Global state for client
-
-# --- Global Variables (if needed) ---
+
+# --- Configuration ---
+BASE_URL = "http://localhost:1234/v1"
+BASE_API_KEY = "not-needed"
+# Using the sync client for the agent's internal sync calls
+CLIENT = OpenAI(base_url=BASE_URL, api_key=BASE_API_KEY)
+# Using the async client for the static async methods and instance methods
+BASE_CLIENT = AsyncOpenAI(base_url=BASE_URL, api_key=BASE_API_KEY)
+BASEMODEL_ID = "leroydyer/qwen/qwen3-0.6b-q4_k_m.gguf"
+
 console = Console()
-# Example global client if needed elsewhere, adjust based on your setup
-# BASE_CLIENT = AsyncOpenAI(base_url=DEFAULT_BASE_URL, api_key=DEFAULT_API_KEY)
-# CLIENT = OpenAI(base_url=DEFAULT_BASE_URL, api_key=DEFAULT_API_KEY)
 
-# --- Dataclasses (copied from your original code or imported) ---
+# HuggingFace Spaces configuration (if needed)
+HF_INFERENCE_URL = "https://api-inference.huggingface.co/models/"
+HF_API_KEY = os.getenv("HF_API_KEY", "")
+
+# Available model options (for UI reference, actual client is configured separately)
+MODEL_OPTIONS = {
+    "Local LM Studio": BASE_URL,  # This is a URL, not a model ID
+    "Codellama 7B": "codellama/CodeLlama-7b-hf",
+    "Mistral 7B": "mistralai/Mistral-7B-v0.1",
+    "Llama 2 7B": "meta-llama/Llama-2-7b-chat-hf",
+    "Falcon 7B": "tiiuae/falcon-7b-instruct"
+}
+
+DEFAULT_TEMPERATURE = 0.7
+DEFAULT_MAX_TOKENS = 5000
+
+# --- Canvas Artifact Support ---
+@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 = {}
+
 @dataclass
 class LLMMessage:
     role: str
@@ -81,11 +93,11 @@ class LLMResponse:
     success: bool = True
     error: str = None
 
-# --- Event Manager (copied from your original code or imported) ---
+# --- Event Manager ---
 class EventManager:
     def __init__(self):
         self._handlers = defaultdict(list)
-        self._lock = threading.Lock()
+        self._lock = Lock()
 
     def register(self, event: str, handler: Callable):
         with self._lock:
@@ -117,9 +129,9 @@ def UnregisterEvent(event: str, handler: Callable):
     EVENT_MANAGER.unregister(event, handler)
 
 class LLMAgent:
-    """Main Agent Driver ! 
-    Agent For Multiple messages at once , 
-    has a message queing service as well as agenerator method for easy intergration with console     
+    """Main Agent Driver !
+    Agent For Multiple messages at once ,
+    has a message queing service as well as a generator method for easy integration with console
     applications as well as ui !"""
     def __init__(
         self,
@@ -130,9 +142,9 @@ class LLMAgent:
         timeout: int = 30000,
         max_tokens: int = 5000,
         temperature: float = 0.3,
-        base_url: str = "http://localhost:1234/v1",
-        api_key: str = "not-needed",
-        generate_fn: Callable[[List[Dict[str, str]]], Coroutine[Any, Any, str]] = None
+        base_url: str = BASE_URL,
+        api_key: str = BASE_API_KEY,
+        generate_fn: Callable[[List[Dict[str, str]]], str] = None # Changed to sync function
     ):
         self.model_id = model_id
         self.system_prompt = system_prompt or "You are a helpful AI assistant."
@@ -142,23 +154,29 @@ class LLMAgent:
         self.is_running = False
         self._stop_event = Event()
         self.processing_thread = None
-        
+
         # Conversation tracking
         self.conversations: Dict[str, List[LLMMessage]] = {}
         self.max_history_length = 20
-        self._generate = generate_fn or self._default_generate
+        # Use the provided generate function or the default sync one
+        self._generate = generate_fn or self._default_generate_sync
         self.api_key = api_key
-        self.base_url = base_url        
+        self.base_url = base_url
         self.max_tokens = max_tokens
         self.temperature = temperature
-        self.async_client = self.CreateClient(base_url, api_key)
-                
+        # Use the global async client for instance methods if needed
+        self.async_client = BASE_CLIENT
+
         # Active requests waiting for responses
         self.pending_requests: Dict[str, LLMRequest] = {}
         self.pending_requests_lock = Lock()
-        
+
+        # Canvas artifacts
+        self.canvas_artifacts: Dict[str, List[CanvasArtifact]] = defaultdict(list)
+
         # Register internal event handlers
         self._register_event_handlers()
+
         # Speech synthesis
         try:
             self.tts_engine = pyttsx3.init()
@@ -167,11 +185,11 @@ class LLMAgent:
         except Exception as e:
             console.log(f"[yellow]TTS not available: {e}[/yellow]")
             self.speech_enabled = False
-        
         console.log("[bold green]🚀 Enhanced LLM Agent Initialized[/bold green]")
-        
+
         # Start the processing thread immediately
         self.start()
+
     def setup_tts(self):
         """Configure text-to-speech engine"""
         if hasattr(self, 'tts_engine'):
@@ -185,7 +203,6 @@ class LLMAgent:
         """Convert text to speech in a non-blocking way"""
         if not hasattr(self, 'speech_enabled') or not self.speech_enabled:
             return
-            
         def _speak():
             try:
                 # Clean text for speech (remove markdown, code blocks)
@@ -193,29 +210,27 @@ class LLMAgent:
                 clean_text = re.sub(r'`.*?`', '', clean_text)
                 clean_text = clean_text.strip()
                 if clean_text:
-                    self.tts_engine.say(clean_text) 
+                    self.tts_engine.say(clean_text)
                     self.tts_engine.runAndWait()
                 else:
-                    self.tts_engine.say(text)  
-                    self.tts_engine.runAndWait()                    
+                    self.tts_engine.say(text)
+                    self.tts_engine.runAndWait()
             except Exception as e:
                 console.log(f"[red]TTS Error: {e}[/red]")
-        
-        thread = threading.Thread(target=_speak, daemon=True)
+        thread = Thread(target=_speak, daemon=True)
         thread.start()
-    
-    async def _default_generate(self, messages: List[Dict[str, str]]) -> str:
-        """Default generate function if none provided"""
-        return await self.openai_generate(messages)
-    
+
+    def _default_generate_sync(self, messages: List[Dict[str, str]]) -> str:
+        """Default sync generate function if none provided"""
+        return self._call_llm_sync(messages)
+
     def _register_event_handlers(self):
         """Register internal event handlers for response routing"""
         RegisterEvent("llm_internal_response", self._handle_internal_response)
-    
+
     def _handle_internal_response(self, response: LLMResponse):
         """Route responses to the appropriate request handlers"""
         console.log(f"[bold cyan]Handling internal response for: {response.request_id}[/bold cyan]")
-        
         request = None
         with self.pending_requests_lock:
             if response.request_id in self.pending_requests:
@@ -225,12 +240,12 @@ class LLMAgent:
             else:
                 console.log(f"No pending request found for: {response.request_id}", style="yellow")
                 return
-        
+
         # Raise the specific response event
         if request.response_event:
             console.log(f"[bold green]Raising event: {request.response_event}[/bold green]")
             RaiseEvent(request.response_event, response)
-        
+
         # Call callback if provided
         if request.callback:
             try:
@@ -238,36 +253,30 @@ class LLMAgent:
                 request.callback(response)
             except Exception as e:
                 console.log(f"Error in callback: {e}", style="bold red")
-    
+
     def _add_to_conversation_history(self, conversation_id: str, message: LLMMessage):
         """Add message to conversation history"""
         if conversation_id not in self.conversations:
             self.conversations[conversation_id] = []
-        
         self.conversations[conversation_id].append(message)
-        
         # Trim history if too long
         if len(self.conversations[conversation_id]) > self.max_history_length * 2:
             self.conversations[conversation_id] = self.conversations[conversation_id][-(self.max_history_length * 2):]
-    
+
     def _build_messages_from_conversation(self, conversation_id: str, new_message: LLMMessage) -> List[Dict[str, str]]:
         """Build message list from conversation history"""
         messages = []
-        
         # Add system prompt
         if self.system_prompt:
             messages.append({"role": "system", "content": self.system_prompt})
-        
         # Add conversation history
         if conversation_id in self.conversations:
             for msg in self.conversations[conversation_id][-self.max_history_length:]:
                 messages.append({"role": msg.role, "content": msg.content})
-        
         # Add the new message
         messages.append({"role": new_message.role, "content": new_message.content})
-        
         return messages
-    
+
     def _process_llm_request(self, request: LLMRequest):
         """Process a single LLM request"""
         console.log(f"[bold green]Processing LLM request: {request.message.message_id}[/bold green]")
@@ -277,14 +286,11 @@ class LLMAgent:
                 request.message.conversation_id or "default",
                 request.message
             )
-            
             console.log(f"Calling LLM with {len(messages)} messages")
-            
-            # Call LLM - Use sync call for thread compatibility
-            response_content = self._call_llm_sync(messages)
-            
-            console.log(f"[bold green]LLM response received: {response_content}...[/bold green]")
-            
+            # Call LLM using the sync generate function
+            response_content = self._generate(messages)
+            console.log(f"[bold green]LLM response received: {response_content[:50]}...[/bold green]")
+
             # Create response message
             response_message = LLMMessage(
                 role="assistant",
@@ -292,7 +298,7 @@ class LLMAgent:
                 conversation_id=request.message.conversation_id,
                 metadata={"request_id": request.message.message_id}
             )
-            
+
             # Update conversation history
             self._add_to_conversation_history(
                 request.message.conversation_id or "default",
@@ -302,17 +308,16 @@ class LLMAgent:
                 request.message.conversation_id or "default",
                 response_message
             )
-            
+
             # Create and send response
             response = LLMResponse(
                 message=response_message,
                 request_id=request.message.message_id,
                 success=True
             )
-            
             console.log(f"[bold blue]Sending internal response for: {request.message.message_id}[/bold blue]")
             RaiseEvent("llm_internal_response", response)
-            
+
         except Exception as e:
             console.log(f"[bold red]Error processing LLM request: {e}[/bold red]")
             traceback.print_exc()
@@ -327,9 +332,8 @@ class LLMAgent:
                 success=False,
                 error=str(e)
             )
-            
             RaiseEvent("llm_internal_response", error_response)
-    
+
     def _call_llm_sync(self, messages: List[Dict[str, str]]) -> str:
         """Sync call to the LLM with retry logic"""
         console.log(f"Making LLM call to {self.model_id}")
@@ -348,8 +352,8 @@ class LLMAgent:
                 console.log(f"LLM call attempt {attempt + 1} failed: {e}")
                 if attempt == self.max_retries - 1:
                     raise e
- # Wait before retry
-    
+                time.sleep(1) # Wait before retry
+
     def _process_queue(self):
         """Main queue processing loop"""
         console.log("[bold cyan]LLM Agent queue processor started[/bold cyan]")
@@ -366,7 +370,7 @@ class LLMAgent:
                 console.log(f"Error in queue processing: {e}", style="bold red")
                 traceback.print_exc()
         console.log("[bold cyan]LLM Agent queue processor stopped[/bold cyan]")
-    
+
     def send_message(
         self,
         content: str,
@@ -379,7 +383,7 @@ class LLMAgent:
         """Send a message to the LLM and get response via events"""
         if not self.is_running:
             raise RuntimeError("LLM Agent is not running. Call start() first.")
-        
+
         # Create message
         message = LLMMessage(
             role=role,
@@ -387,19 +391,19 @@ class LLMAgent:
             conversation_id=conversation_id,
             metadata=metadata or {}
         )
-        
+
         # Create request
         request = LLMRequest(
             message=message,
             response_event=response_event,
             callback=callback
         )
-        
+
         # Store in pending requests BEFORE adding to queue
         with self.pending_requests_lock:
             self.pending_requests[message.message_id] = request
             console.log(f"Added to pending requests: {message.message_id}")
-        
+
         # Add to queue
         try:
             self.request_queue.put(request, timeout=5.0)
@@ -411,7 +415,7 @@ class LLMAgent:
                 if message.message_id in self.pending_requests:
                     del self.pending_requests[message.message_id]
             raise RuntimeError("LLM Agent queue is full")
-    
+
     async def chat(self, messages: List[Dict[str, str]]) -> str:
         """
         Async chat method that sends message via queue and returns response string.
@@ -424,11 +428,10 @@ class LLMAgent:
         def chat_callback(response: LLMResponse):
             """Callback when LLM responds - thread-safe"""
             console.log(f"[bold yellow]✓ CHAT CALLBACK TRIGGERED![/bold yellow]")
-            
             if not response_future.done():
                 if response.success:
                     content = response.message.content
-                    console.log(f"Callback received content: {content}...")
+                    console.log(f"Callback received content: {content[:50]}...")
                     # Schedule setting the future result on the main event loop
                     loop.call_soon_threadsafe(response_future.set_result, content)
                 else:
@@ -439,14 +442,12 @@ class LLMAgent:
                 console.log(f"[bold red]Future already done, ignoring callback[/bold red]")
 
         console.log(f"Sending message to LLM agent...")
-
         # Extract the actual message content from the messages list
         user_message = ""
         for msg in messages:
             if msg.get("role") == "user":
                 user_message = msg.get("content", "")
                 break
-            
         if not user_message.strip():
             return ""
 
@@ -457,15 +458,12 @@ class LLMAgent:
                 conversation_id="default",
                 callback=chat_callback
             )
-
             console.log(f"Message sent with ID: {message_id}, waiting for response...")
-
             # Wait for the response and return it
             try:
                 response = await asyncio.wait_for(response_future, timeout=self.timeout)
                 console.log(f"[bold green]✓ Chat complete! Response length: {len(response)}[/bold green]")
                 return response
-
             except asyncio.TimeoutError:
                 console.log("[bold red]Response timeout[/bold red]")
                 # Clean up the pending request
@@ -473,12 +471,11 @@ class LLMAgent:
                     if message_id in self.pending_requests:
                         del self.pending_requests[message_id]
                 return "❌ Response timeout - check if LLM server is running"
-
         except Exception as e:
             console.log(f"[bold red]Error sending message: {e}[/bold red]")
             traceback.print_exc()
             return f"❌ Error sending message: {e}"
-    
+
     def start(self):
         """Start the LLM agent"""
         if not self.is_running:
@@ -487,7 +484,7 @@ class LLMAgent:
             self.processing_thread = Thread(target=self._process_queue, daemon=True)
             self.processing_thread.start()
             console.log("[bold green]LLM Agent started[/bold green]")
-    
+
     def stop(self):
         """Stop the LLM agent"""
         console.log("Stopping LLM Agent...")
@@ -496,22 +493,61 @@ class LLMAgent:
             self.processing_thread.join(timeout=10)
         self.is_running = False
         console.log("LLM Agent stopped")
-    
+
     def get_conversation_history(self, conversation_id: str = "default") -> List[LLMMessage]:
         """Get conversation history"""
         return self.conversations.get(conversation_id, [])[:]
-    
+
     def clear_conversation(self, conversation_id: str = "default"):
         """Clear conversation history"""
         if conversation_id in self.conversations:
             del self.conversations[conversation_id]
 
+    # --- Canvas Methods ---
+    def add_artifact(self, conversation_id: str, artifact_type: str, content: str, title: str = "", metadata: Dict = None):
+        """Add an artifact to the canvas for a conversation."""
+        artifact = CanvasArtifact(
+            id=str(uuid.uuid4()),
+            type=artifact_type,
+            content=content,
+            title=title,
+            timestamp=time.time(),
+            metadata=metadata or {}
+        )
+        self.canvas_artifacts[conversation_id].append(artifact)
+
+    def get_canvas_artifacts(self, conversation_id: str = "default") -> List[CanvasArtifact]:
+        """Get all artifacts for a conversation."""
+        return self.canvas_artifacts.get(conversation_id, [])
+
+    def get_canvas_summary(self, conversation_id: str = "default") -> List[Dict[str, Any]]:
+        """Get a summary of artifacts for display."""
+        artifacts = self.get_canvas_artifacts(conversation_id)
+        return [{"id": a.id, "type": a.type, "title": a.title, "timestamp": a.timestamp} for a in artifacts]
+
+    def clear_canvas(self, conversation_id: str = "default"):
+        """Clear canvas artifacts for a conversation."""
+        if conversation_id in self.canvas_artifacts:
+            self.canvas_artifacts[conversation_id] = []
+
+    async def chat_with_canvas(self, user_message: str, conversation_id: str = "default", include_canvas: bool = False) -> str:
+        """
+        Chat method that can optionally include canvas content in the prompt.
+        """
+        messages = [{"role": "user", "content": user_message}]
+        if include_canvas:
+            canvas_artifacts = self.get_canvas_artifacts(conversation_id)
+            if canvas_artifacts:
+                canvas_content = "\n\n--- CANVAS CONTENT ---\n"
+                for artifact in canvas_artifacts:
+                    canvas_content += f"\n[{artifact.type}] {artifact.title or 'Untitled'}:\n{artifact.content}\n"
+                canvas_content += "\n--- END CANVAS CONTENT ---\n"
+                # Add canvas content as a system message
+                messages.insert(0, {"role": "system", "content": canvas_content})
+        return await self.chat(messages)
 
-    async def _chat(self, messages: List[Dict[str, str]]) -> str:
-        return await self._generate(messages)
-    
     @staticmethod
-    async def openai_generate(messages: List[Dict[str, str]], max_tokens: int = 8096, temperature: float = 0.4, model: str = BASEMODEL_ID,tools=None) -> str:
+    async def openai_generate(messages: List[Dict[str, str]], max_tokens: int = 8096, temperature: float = 0.4, model: str = BASEMODEL_ID, tools=None) -> str:
         """Static method for generating responses using OpenAI API"""
         try:
             resp = await BASE_CLIENT.chat.completions.create(
@@ -526,56 +562,16 @@ class LLMAgent:
         except Exception as e:
             console.log(f"[bold red]Error in openai_generate: {e}[/bold red]")
             return f"[LLM_Agent Error - openai_generate: {str(e)}]"
-    
-    async def _call_(self, messages: List[Dict[str, str]]) -> str:
-        """Internal call method using instance client"""
-        try:
-            resp = await self.async_client.chat.completions.create(
-                model=self.model_id,
-                messages=messages,
-                temperature=self.temperature,
-                max_tokens=self.max_tokens
-            )
-            response_text = resp.choices[0].message.content or ""
-            return response_text
-        except Exception as e:
-            console.log(f"[bold red]Error in _call_: {e}[/bold red]")
-            return f"[LLM_Agent Error - _call_: {str(e)}]"  
-    
-    @staticmethod              
-    def CreateClient(base_url: str, api_key: str) -> AsyncOpenAI:
-        '''Create async OpenAI Client required for multi tasking'''
-        return AsyncOpenAI(
-            base_url=base_url,
-            api_key=api_key
-        ) 
-    
-    @staticmethod
-    async def fetch_available_models(base_url: str, api_key: str) -> List[str]:
-        """Fetches available models from the OpenAI API."""
-        try:
-            async_client = AsyncOpenAI(base_url=base_url, api_key=api_key)
-            models = await async_client.models.list()
-            model_choices = [model.id for model in models.data]
-            return model_choices
-        except Exception as e:
-            console.log(f"[bold red]LLM_Agent Error fetching models: {e}[/bold red]")
-            return ["LLM_Agent Error fetching models"]   
-    
-    def get_models(self) -> List[str]:             
-        """Get available models using instance credentials"""
-        return asyncio.run(self.fetch_available_models(self.base_url, self.api_key))
-    
 
     def get_queue_size(self) -> int:
         """Get current queue size"""
         return self.request_queue.qsize()
-    
+
     def get_pending_requests_count(self) -> int:
         """Get number of pending requests"""
         with self.pending_requests_lock:
             return len(self.pending_requests)
-    
+
     def get_status(self) -> Dict[str, Any]:
         """Get agent status information"""
         return {
@@ -585,22 +581,21 @@ class LLMAgent:
             "conversations_count": len(self.conversations),
             "model": self.model_id
         }
+
 class AI_Agent:
     def __init__(self, model_id: str, system_prompt: str = "You are a helpful assistant. Respond concisely in 1-2 sentences.", history: List[Dict] = None):
         self.model_id = model_id
         self.system_prompt = system_prompt
         self.history = history or []
         self.conversation_id = f"conv_{uuid.uuid4().hex[:8]}"
-        
-        # Create agent instance
+        # Create agent instance - using the static async method as the generate function
         self.client = LLMAgent(
             model_id=model_id,
             system_prompt=self.system_prompt,
-            generate_fn=LLMAgent.openai_generate
+            generate_fn=lambda msgs: asyncio.run(LLMAgent.openai_generate(msgs, model=model_id))
         )
-        
         console.log(f"[bold green]✓ MyAgent initialized with model: {model_id}[/bold green]")
-    
+
     async def call_llm(self, messages: List[Dict], use_history: bool = True) -> str:
         """
         Send messages to LLM and get response
@@ -612,67 +607,55 @@ class AI_Agent:
         """
         try:
             console.log(f"[bold yellow]Sending {len(messages)} messages to LLM (use_history: {use_history})...[/bold yellow]")
-            
             # Enhance messages based on history setting
             enhanced_messages = await self._enhance_messages(messages, use_history)
-            
             response = await self.client.chat(enhanced_messages)
             console.log(f"[bold green]✓ Response received ({len(response)} chars)[/bold green]")
-            
             # Update conversation history ONLY if we're using history
             if use_history:
                 self._update_history(messages, response)
-            
             return response
-            
         except Exception as e:
             console.log(f"[bold red]✗ ERROR: {e}[/bold red]")
             traceback.print_exc()
             return f"Error: {str(e)}"
-    
+
     async def _enhance_messages(self, messages: List[Dict], use_history: bool) -> List[Dict]:
         """Enhance messages with system prompt and optional history"""
         enhanced = []
-        
         # Add system prompt if not already in messages
         has_system = any(msg.get('role') == 'system' for msg in messages)
         if not has_system and self.system_prompt:
             enhanced.append({"role": "system", "content": self.system_prompt})
-        
         # Add conversation history only if requested
         if use_history and self.history:
             enhanced.extend(self.history[-10:])  # Last 10 messages for context
-        
         # Add current messages
         enhanced.extend(messages)
-        
         return enhanced
-    
+
     def _update_history(self, messages: List[Dict], response: str):
         """Update conversation history with new exchange"""
         # Add user messages to history
         for msg in messages:
             if msg.get('role') in ['user', 'assistant']:
                 self.history.append(msg)
-        
         # Add assistant response to history
         self.history.append({"role": "assistant", "content": response})
-        
         # Keep history manageable (last 20 exchanges)
         if len(self.history) > 40:  # 20 user + 20 assistant messages
             self.history = self.history[-40:]
-    
+
     async def simple_query(self, query: str) -> str:
         """Simple one-shot query method - NO history/context"""
         messages = [{"role": "user", "content": query}]
         return await self.call_llm(messages, use_history=False)
-    
+
     async def multi_turn_chat(self, user_input: str) -> str:
         """Multi-turn chat that maintains context across calls"""
         messages = [{"role": "user", "content": user_input}]
         response = await self.call_llm(messages, use_history=True)
         return response
-    
 
     def get_conversation_summary(self) -> Dict:
         """Get conversation summary"""
@@ -683,27 +666,27 @@ class AI_Agent:
             "assistant_messages": len([msg for msg in self.history if msg.get('role') == 'assistant']),
             "recent_exchanges": self.history[-4:] if self.history else []
         }
-    
+
     def clear_history(self):
         """Clear conversation history"""
         self.history.clear()
         console.log("[bold yellow]Conversation history cleared[/bold yellow]")
-    
+
     def update_system_prompt(self, new_prompt: str):
         """Update the system prompt"""
         self.system_prompt = new_prompt
         console.log(f"[bold blue]System prompt updated[/bold blue]")
-    
+
     def stop(self):
         """Stop the client gracefully"""
         if hasattr(self, 'client') and self.client:
             self.client.stop()
-            console.log("[bold yellow]MyAgent client stopped[/bold yellow]") 
-    async def contextual_query(self, query: str, context_messages: List[Dict] = None, 
+            console.log("[bold yellow]MyAgent client stopped[/bold yellow]")
+
+    async def contextual_query(self, query: str, context_messages: List[Dict] = None,
                              context_text: str = None, context_files: List[str] = None) -> str:
         """
         Query with specific context but doesn't update main history
-        
         Args:
             query: The user question
             context_messages: List of message dicts for context
@@ -711,28 +694,22 @@ class AI_Agent:
             context_files: List of file paths to read and include as context
         """
         messages = []
-        
         # Add system prompt
         if self.system_prompt:
             messages.append({"role": "system", "content": self.system_prompt})
-        
         # Handle different context types
         if context_messages:
             messages.extend(context_messages)
-        
         if context_text:
             messages.append({"role": "system", "content": f"Additional context: {context_text}"})
-        
         if context_files:
             file_context = await self._read_files_context(context_files)
             if file_context:
                 messages.append({"role": "system", "content": f"File contents:\n{file_context}"})
-        
         # Add the actual query
         messages.append({"role": "user", "content": query})
-        
         return await self.call_llm(messages, use_history=False)
-      
+
     async def _read_files_context(self, file_paths: List[str]) -> str:
         """Read multiple files and return as context string"""
         contexts = []
@@ -746,21 +723,17 @@ class AI_Agent:
                     console.log(f"[bold yellow]File not found: {file_path}[/bold yellow]")
             except Exception as e:
                 console.log(f"[bold red]Error reading file {file_path}: {e}[/bold red]")
-        
-        return "\n\n".join(contexts) if contexts else ""
-    
-    
+        return "\n".join(contexts) if contexts else ""
+
     async def query_with_code_context(self, query: str, code_snippets: List[str] = None,
                                     code_files: List[str] = None) -> str:
         """
         Specialized contextual query for code-related questions
         """
         code_context = "CODE CONTEXT:\n"
-        
         if code_snippets:
             for i, snippet in enumerate(code_snippets, 1):
                 code_context += f"\nSnippet {i}:\n```\n{snippet}\n```\n"
-        
         if code_files:
             # Read code files and include them
             for file_path in code_files:
@@ -772,13 +745,11 @@ class AI_Agent:
                     except Exception as e:
                         code_context += f"Error reading file: {e}"
                     code_context += "\n```\n"
-        
         return await self.contextual_query(query, context_text=code_context)
-    
+
     async def multi_context_query(self, query: str, contexts: Dict[str, Any]) -> str:
         """
         Advanced contextual query with multiple context types
-        
         Args:
             query: The user question
             contexts: Dict with various context types
@@ -790,190 +761,32 @@ class AI_Agent:
                 - 'metadata': Any additional metadata
         """
         all_context_messages = []
-        
         # Build context from different sources
         if contexts.get('text'):
             all_context_messages.append({"role": "system", "content": f"Context: {contexts['text']}"})
-        
         if contexts.get('messages'):
             all_context_messages.extend(contexts['messages'])
-        
         if contexts.get('files'):
             file_context = await self._read_files_context(contexts['files'])
             if file_context:
                 all_context_messages.append({"role": "system", "content": f"File Contents:\n{file_context}"})
-        
         if contexts.get('code'):
-            code_context = "\n".join([f"Code snippet {i}:\n```\n{code}\n```" 
+            code_context = "\n".join([f"Code snippet {i}:\n```\n{code}\n```"
                                     for i, code in enumerate(contexts['code'], 1)])
             all_context_messages.append({"role": "system", "content": f"Code Context:\n{code_context}"})
-        
         if contexts.get('metadata'):
             all_context_messages.append({"role": "system", "content": f"Metadata: {contexts['metadata']}"})
-        
         return await self.contextual_query(query, context_messages=all_context_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
 
 
+# --- LCARS Styled Gradio Interface ---
 class LcarsInterface:
-    """LCARS-styled Gradio interface for your AI_Agent"""
-    
-    def __init__(self, ai_agent):
-        """
-        Initialize interface with your AI_Agent instance
-        
-        Args:
-            ai_agent: Instance of your AI_Agent class
-        """
-        self.enhanced_agent = EnhancedAIAgent(ai_agent)
-        self.current_conversation = "default"
-        self.processing_lock = Lock()
-        console.log("[bold cyan]✓ LCARS Interface initialized[/bold cyan]")
-    
+    def __init__(self):
+        # Start with the configured local client
+        self.agent = LLMAgent(generate_fn=LLMAgent.openai_generate)
+
     def create_interface(self):
         """Create the full LCARS-styled interface"""
-        
-        # Enhanced LCARS CSS
         lcars_css = """
         :root {
             --lcars-orange: #FF9900;
@@ -986,18 +799,17 @@ class LcarsInterface:
             --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);
@@ -1005,193 +817,147 @@ class LcarsInterface:
             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);
-            box-shadow: 0 4px 20px rgba(255, 153, 0, 0.3);
         }
-        
         .lcars-title {
-            font-size: 3em;
+            font-size: 2.5em;
             font-weight: bold;
             color: var(--lcars-black);
-            text-shadow: 3px 3px 6px rgba(255, 255, 255, 0.4);
             margin: 0;
-            letter-spacing: 2px;
         }
-        
         .lcars-subtitle {
-            font-size: 1.4em;
+            font-size: 1.2em;
             color: var(--lcars-black);
             margin: 10px 0 0 0;
-            font-weight: bold;
         }
-        
         .lcars-panel {
-            background: linear-gradient(135deg, rgba(66, 66, 66, 0.9), rgba(40, 40, 40, 0.9));
-            border: 3px solid var(--lcars-orange);
-            border-radius: 0 25px 0 25px;
-            padding: 20px;
-            margin-bottom: 20px;
-            box-shadow: 0 4px 15px rgba(255, 153, 0, 0.2);
+            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: linear-gradient(135deg, var(--lcars-orange), var(--lcars-red)) !important;
+            background: var(--lcars-orange);
             color: var(--lcars-black) !important;
             border: none !important;
-            border-radius: 0 20px 0 20px !important;
-            padding: 12px 24px !important;
+            border-radius: 0 15px 0 15px !important;
+            padding: 10px 20px !important;
             font-family: inherit !important;
             font-weight: bold !important;
-            font-size: 1.1em !important;
-            cursor: pointer !important;
-            transition: all 0.3s ease !important;
-            margin: 8px !important;
-            box-shadow: 0 4px 8px rgba(255, 153, 0, 0.3) !important;
+            margin: 5px !important;
         }
-        
         .lcars-button:hover {
-            background: linear-gradient(135deg, var(--lcars-red), var(--lcars-orange)) !important;
-            transform: translateY(-2px) !important;
-            box-shadow: 0 6px 12px rgba(255, 153, 0, 0.4) !important;
+            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 15px 0 15px !important;
-            padding: 12px !important;
-            font-family: inherit !important;
-            font-size: 1.1em !important;
+            border-radius: 0 10px 0 10px !important;
+            padding: 10px !important;
         }
-        
         .lcars-chatbot {
             background: var(--lcars-black) !important;
-            border: 3px solid var(--lcars-purple) !important;
-            border-radius: 0 20px 0 20px !important;
-            min-height: 400px;
-            max-height: 500px;
-        }
-        
-        .lcars-code-editor {
-            background: var(--lcars-black) !important;
-            color: var(--lcars-pale-blue) !important;
-            border: 3px solid var(--lcars-blue) !important;
-            border-radius: 0 20px 0 20px !important;
-            font-family: 'Fira Code', 'Courier New', monospace !important;
-            font-size: 1em !important;
+            border: 2px solid var(--lcars-purple) !important;
+            border-radius: 0 15px 0 15px !important;
         }
-        
         .status-indicator {
             display: inline-block;
-            width: 16px;
-            height: 16px;
+            width: 12px;
+            height: 12px;
             border-radius: 50%;
             background: var(--lcars-red);
-            margin-right: 12px;
-            box-shadow: 0 0 10px currentColor;
+            margin-right: 8px;
         }
-        
         .status-online {
             background: var(--lcars-blue);
-            animation: pulse 1.5s infinite;
+            animation: pulse 2s infinite;
         }
-        
         @keyframes pulse {
-            0% { transform: scale(1); opacity: 1; }
-            50% { transform: scale(1.1); opacity: 0.7; }
-            100% { transform: scale(1); opacity: 1; }
-        }
-        
-        .panel-title {
-            color: var(--lcars-yellow) !important;
-            font-size: 1.4em !important;
-            font-weight: bold !important;
-            margin-bottom: 15px !important;
-            border-bottom: 2px solid var(--lcars-orange);
-            padding-bottom: 8px;
+            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 Section
+                # Header
                 with gr.Row(elem_classes="lcars-header"):
                     gr.Markdown("""
                     <div style="text-align: center; width: 100%;">
-                        <div class="lcars-title">🚀 LCARS AI TERMINAL</div>
-                        <div class="lcars-subtitle">ADVANCED AI DEVELOPMENT CONSOLE</div>
+                        <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 Area
+                # Main Content
                 with gr.Row():
-                    # Left Sidebar - Canvas Artifacts
-                    with gr.Column(scale=1, min_width=400):
+                    # Left Sidebar
+                    with gr.Column(scale=1):
+                        # Configuration Panel
                         with gr.Column(elem_classes="lcars-panel"):
-                            gr.Markdown("### 🎨 CANVAS ARTIFACTS", elem_classes="panel-title")
-                            artifact_display = gr.JSON(
-                                label="",
-                                elem_id="artifact-display"
-                            )
+                            gr.Markdown("### 🔧 CONFIGURATION")
+                            with gr.Row():
+                                model_dropdown = gr.Dropdown(
+                                    choices=list(MODEL_OPTIONS.keys())[1:], # Exclude the 'Local LM Studio' URL entry
+                                    value=list(MODEL_OPTIONS.keys())[1], # Default to Codellama 7B
+                                    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="Canvas Summary")
                             with gr.Row():
                                 refresh_artifacts_btn = gr.Button("🔄 Refresh", elem_classes="lcars-button")
                                 clear_canvas_btn = gr.Button("🗑️ Clear Canvas", elem_classes="lcars-button")
-                                load_latest_btn = gr.Button("📥 Load Latest", elem_classes="lcars-button")
-                    
-                    # Main Content - Chat and Code Canvas
+                    # Main Content Area
                     with gr.Column(scale=2):
-                        # Collaborative Code Canvas
+                        # Code Canvas
                         with gr.Accordion("💻 COLLABORATIVE CODE CANVAS", open=True):
                             code_editor = gr.Code(
-                                value="# Welcome to LCARS Collaborative Canvas\n# Your code artifacts will appear here\n\nprint('Hello, Starfleet!')",
+                                value="# Welcome to LCARS Collaborative Canvas\nprint('Hello, Starfleet!')",
                                 language="python",
-                                lines=20,
-                                label="",
-                                elem_classes="lcars-code-editor"
+                                lines=15,
+                                label=""
                             )
-                            
                             with gr.Row():
-                                discuss_code_btn = gr.Button("💬 Discuss This Code", elem_classes="lcars-button")
-                                analyze_code_btn = gr.Button("🔍 Analyze", elem_classes="lcars-button")
-                                optimize_code_btn = gr.Button("⚡ Optimize", elem_classes="lcars-button")
-                                document_code_btn = gr.Button("📚 Document", elem_classes="lcars-button")
-                        
+                                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", elem_classes="panel-title")
-                            chatbot = gr.Chatbot(
-                                label="",
-                                elem_classes="lcars-chatbot",
-                                show_label=False,
-                                height=400
-                            )
-                            
+                            gr.Markdown("### 💬 MISSION LOG")
+                            chatbot = gr.Chatbot(label="", height=300, elem_classes="lcars-chatbot")
                             with gr.Row():
                                 message_input = gr.Textbox(
                                     placeholder="Enter your command or query...",
                                     show_label=False,
                                     lines=2,
-                                    elem_classes="lcars-input",
-                                    scale=4
+                                    elem_classes="lcars-input"
                                 )
-                                send_btn = gr.Button("🚀 TRANSMIT", elem_classes="lcars-button", scale=1)
-                        
-                        # Status and Controls
+                                send_btn = gr.Button("🚀 SEND", elem_classes="lcars-button")
+                        # Status
                         with gr.Row():
                             status_display = gr.Textbox(
-                                value=f"LCARS terminal operational. Model: {self.enhanced_agent.agent.model_id}",
+                                value="LCARS terminal operational. Awaiting commands.",
                                 label="Status",
                                 max_lines=2,
                                 elem_classes="lcars-input"
@@ -1199,175 +965,101 @@ class LcarsInterface:
                             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 ===
-            
+            def update_agent_config(model_key, temp_val, max_tok_val, speech_enabled):
+                # Map UI model key to actual model ID
+                model_id = MODEL_OPTIONS.get(model_key, BASEMODEL_ID)
+                
+                # Update agent attributes
+                self.agent.model_id = model_id
+                self.agent.temperature = temp_val
+                self.agent.max_tokens = max_tok_val
+                self.agent.speech_enabled = speech_enabled
+                
+                # Update TTS if enabled/disabled
+                if speech_enabled and not self.agent.speech_enabled:
+                    try:
+                        self.agent.tts_engine = pyttsx3.init()
+                        self.agent.setup_tts()
+                        self.agent.speech_enabled = True
+                    except Exception as e:
+                        console.log(f"[yellow]TTS re-enable failed: {e}[/yellow]")
+                elif not speech_enabled and self.agent.speech_enabled:
+                    self.agent.speech_enabled = False
+                
+                return f"✅ Config updated: {model_key}, T={temp_val}, MaxTok={max_tok_val}, Speech={speech_enabled}"
+
             def get_artifacts():
-                """Get current canvas artifacts"""
-                return self.enhanced_agent.get_canvas_summary(self.current_conversation)
-            
+                return self.agent.get_canvas_summary("default") # Assuming single conversation for UI
+
             def clear_canvas():
-                """Clear the canvas"""
-                self.enhanced_agent.clear_canvas(self.current_conversation)
+                self.agent.clear_canvas("default")
                 return [], "✅ Canvas cleared"
-            
-            def load_latest_artifact_to_canvas():
-                """Load the most recent code artifact to the canvas"""
-                latest_code = self.enhanced_agent.get_latest_code_artifact(self.current_conversation)
-                if latest_code:
-                    return latest_code, "✅ Latest artifact loaded"
-                return "# No code artifacts available", "⚠️ No artifacts found"
-            
-            async def process_message(message, history):
-                """Process a chat message"""
+
+            def clear_chat():
+                self.agent.clear_conversation("default")
+                return [], "✅ Chat cleared"
+
+            def new_session():
+                self.agent.clear_conversation("default")
+                self.agent.clear_canvas("default")
+                return [], "# New session started\nprint('Ready!')", "🆕 New session started", []
+
+            async def process_message(message, history, speech_enabled):
                 if not message.strip():
-                    return "", history, "Please enter a message"
-                
-                # Add user message to history
+                    return "", history, "Please enter a message", self.agent.get_canvas_summary("default")
                 history = history + [[message, None]]
-                
                 try:
-                    # Get AI response using the enhanced agent
-                    response = await self.enhanced_agent.chat_with_canvas(
-                        message, 
-                        self.current_conversation, 
-                        include_canvas=True
-                    )
-                    
-                    # Update history with response
+                    # For simplicity, use the basic chat method here. Canvas integration can be added if needed.
+                    response = await self.agent.chat([{"role": "user", "content": message}])
                     history[-1][1] = response
-                    
-                    # Get updated artifacts
-                    artifacts = get_artifacts()
-                    
+                    if speech_enabled and self.agent.speech_enabled:
+                        self.agent.speak(response)
+                    artifacts = self.agent.get_canvas_summary("default")
                     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, get_artifacts()
-            
-            def create_code_query(code, query_template):
-                """Create a query about code"""
-                if not code.strip():
-                    return "Please provide some code first"
-                return query_template.format(code=code)
-            
-            def discuss_code(code):
-                return create_code_query(code, "Please analyze this code:\n```python\n{code}\n```")
-            
-            def analyze_code(code):
-                return create_code_query(code, "Perform a comprehensive analysis of this code:\n```python\n{code}\n```")
-            
-            def optimize_code(code):
-                return create_code_query(code, "Optimize this code for performance and best practices:\n```python\n{code}\n```")
-            
-            def document_code(code):
-                return create_code_query(code, "Generate comprehensive documentation for this code:\n```python\n{code}\n```")
-            
-            def clear_chat():
-                """Clear chat history"""
-                self.enhanced_agent.agent.clear_history()
-                return [], "✅ Chat cleared"
-            
-            def new_session():
-                """Start new session"""
-                self.enhanced_agent.agent.clear_history()
-                self.enhanced_agent.clear_canvas(self.current_conversation)
-                return [], "# New collaborative session started\n\nprint('Ready for development!')", "🆕 New session started", []
-            
-            # Connect event handlers
+                    return "", history, error_msg, self.agent.get_canvas_summary("default")
+
+            # Connect events
+            update_config_btn.click(
+                update_agent_config,
+                inputs=[model_dropdown, temperature, max_tokens, speech_toggle],
+                outputs=status_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])
             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]
             )
-            
-            discuss_code_btn.click(
-                discuss_code,
-                inputs=code_editor,
-                outputs=message_input
-            )
-            
-            analyze_code_btn.click(
-                analyze_code,
-                inputs=code_editor,
-                outputs=message_input
-            )
-            
-            optimize_code_btn.click(
-                optimize_code,
-                inputs=code_editor,
-                outputs=message_input
-            )
-            
-            document_code_btn.click(
-                document_code,
-                inputs=code_editor,
-                outputs=message_input
-            )
-            
-            refresh_artifacts_btn.click(
-                get_artifacts,
-                outputs=artifact_display
-            )
-            
-            clear_canvas_btn.click(
-                clear_canvas,
-                outputs=[artifact_display, status_display]
-            )
-            
-            load_latest_btn.click(
-                load_latest_artifact_to_canvas,
-                outputs=[code_editor, 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]
-            )
-            
-            # Initialize artifacts on load
             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]")
 
-# --- Example Usage ---
-if __name__ == "__main__":
-    """
-    Example of how to use this interface with your AI_Agent
-    
-    Uncomment and modify based on your actual import paths:
-    """
- 
-    # Create your agent instance
-    my_agent = AI_Agent(
-        model_id="leroydyer/qwen/qwen3-0.6b-q4_k_m.gguf",
-        system_prompt="You are a helpful AI development assistant."
-    )
-    
-    # Create and launch the interface
-    interface = LcarsInterface(my_agent)
+    interface = LcarsInterface()
     demo = interface.create_interface()
-    demo.launch(share=False, show_error=True)
-    
-    console.log("[bold yellow]⚠️  Please uncomment and configure the main block with your AI_Agent[/bold yellow]")
-    console.log("[bold cyan]Example:[/bold cyan]")
-    console.log("  from your_module import AI_Agent")
-    console.log("  my_agent = AI_Agent(model_id='your-model', system_prompt='...')")
-    console.log("  interface = LcarsInterface(my_agent)")
-    console.log("  demo = interface.create_interface()")
-    console.log("  demo.launch()")
+    demo.launch(share=is_space)
+
+if __name__ == "__main__":
+    main()