Update app.py

app.py

@@ -131,6 +131,7 @@ def RaiseEvent(event: str, data: Any):
 def UnregisterEvent(event: str, handler: Callable):
     EVENT_MANAGER.unregister(event, handler)
 
+
 class LLMAgent:
     """Main Agent Driver ! 
     Agent For Multiple messages at once , 
@@ -157,6 +158,7 @@ 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
@@ -166,17 +168,12 @@ class LLMAgent:
         self.max_tokens = max_tokens
         self.temperature = temperature
         self.async_client = self.CreateClient(base_url, api_key)
+        # Canvas Artifacts - NEW
+        self.canvas_artifacts: Dict[str, List[CanvasArtifact]] = {}
+        self.canvas_lock = Lock()                
         # Active requests waiting for responses
         self.pending_requests: Dict[str, LLMRequest] = {}
         self.pending_requests_lock = Lock()
-
-        # Canvas Artifacts - NEW
-        self.canvas_artifacts: Dict[str, List[CanvasArtifact]] = {}
-        self.canvas_lock = Lock()
-
-        # Register internal event handlers
-        self._register_event_handlers()
-
         # Speech synthesis
         try:
             self.tts_engine = pyttsx3.init()
@@ -184,11 +181,12 @@ class LLMAgent:
             self.speech_enabled = True
         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]")
+            self.speech_enabled = False        
+        # Register internal event handlers
+        self._register_event_handlers()
+        
         # Start the processing thread immediately
         self.start()
-
     def setup_tts(self):
         """Configure text-to-speech engine"""
         if hasattr(self, 'tts_engine'):
@@ -218,18 +216,19 @@ class LLMAgent:
                 console.log(f"[red]TTS Error: {e}[/red]")
         thread = threading.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 _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:
@@ -239,10 +238,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:
@@ -250,30 +251,36 @@ 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]")
@@ -283,10 +290,14 @@ 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]")
+            
             # Create response message
             response_message = LLMMessage(
                 role="assistant",
@@ -294,6 +305,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",
@@ -303,14 +315,17 @@ 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()
@@ -325,8 +340,9 @@ 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}")
@@ -345,8 +361,8 @@ class LLMAgent:
                 console.log(f"LLM call attempt {attempt + 1} failed: {e}")
                 if attempt == self.max_retries - 1:
                     raise e
-                 # Wait before retry
-
+ # Wait before retry
+    
     def _process_queue(self):
         """Main queue processing loop"""
         console.log("[bold cyan]LLM Agent queue processor started[/bold cyan]")
@@ -363,7 +379,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,
@@ -376,6 +392,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,
@@ -383,16 +400,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)
@@ -404,7 +424,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.
@@ -413,9 +433,11 @@ class LLMAgent:
         # Create future for the response
         loop = asyncio.get_event_loop()
         response_future = loop.create_future()
+
         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
@@ -428,15 +450,19 @@ class LLMAgent:
                     loop.call_soon_threadsafe(response_future.set_result, error_msg)
             else:
                 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 ""
+
         # Send message with callback using the queue system
         try:
             message_id = self.send_message(
@@ -444,12 +470,15 @@ 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
@@ -457,11 +486,12 @@ 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:
@@ -470,7 +500,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...")
@@ -479,19 +509,20 @@ 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]
 
+
     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:
         """Static method for generating responses using OpenAI API"""
@@ -508,7 +539,7 @@ 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:
@@ -523,7 +554,7 @@ class LLMAgent:
         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'''
@@ -531,7 +562,7 @@ class LLMAgent:
             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."""
@@ -543,20 +574,21 @@ class LLMAgent:
         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 {
@@ -625,6 +657,376 @@ class LLMAgent:
 
         return await self.chat(messages)
 
+        
+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
+        self.client = LLMAgent(
+            model_id=model_id,
+            system_prompt=self.system_prompt,
+            generate_fn=LLMAgent.openai_generate
+        )
+        
+        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
+        Args:
+            messages: List of message dicts with 'role' and 'content'
+            use_history: Whether to include conversation history
+        Returns:
+            str: LLM response
+        """
+        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"""
+        return {
+            "conversation_id": self.conversation_id,
+            "total_messages": len(self.history),
+            "user_messages": len([msg for msg in self.history if msg.get('role') == 'user']),
+            "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, 
+                             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
+            context_text: Plain text context (will be converted to system message)
+            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 = []
+        for file_path in file_paths:
+            try:
+                if os.path.exists(file_path):
+                    with open(file_path, 'r', encoding='utf-8') as f:
+                        content = f.read()
+                        contexts.append(f"--- {os.path.basename(file_path)} ---\n{content}")
+                else:
+                    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 ""
+    
+    
+    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:
+                if file_path.endswith(('.py', '.js', '.java', '.cpp', '.c', '.html', '.css')):
+                    code_context += f"\nFile: {file_path}\n```\n"
+                    try:
+                        with open(file_path, 'r') as f:
+                            code_context += f.read()
+                    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
+                - 'messages': List of message dicts
+                - 'text': Plain text context
+                - 'files': List of file paths
+                - 'urls': List of URLs
+                - 'code': List of code snippets or files
+                - '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```" 
+                                    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
+
 
 console = Console()